From a3e846c6060cbdd429e41aac2e55fd482951baa1 Mon Sep 17 00:00:00 2001 From: Prad Nukala Date: Tue, 6 Oct 2026 13:47:20 -0400 Subject: [PATCH] docs(docs): add documentation for Next Greater Element I and Remove Duplicates from Sorted Array II, update redirects --- .../496_next-greater-element-i.mdx | 59 +++++++++++++++++++ ...remove-duplicates-from-sorted-array-ii.mdx | 41 +++++++++++++ apps/docs/redirects.ts | 2 + 3 files changed, 102 insertions(+) create mode 100644 apps/docs/content/(01-linear-structures)/monotonic-stack/496_next-greater-element-i.mdx create mode 100644 apps/docs/content/(01-linear-structures)/two-pointers/80_remove-duplicates-from-sorted-array-ii.mdx diff --git a/apps/docs/content/(01-linear-structures)/monotonic-stack/496_next-greater-element-i.mdx b/apps/docs/content/(01-linear-structures)/monotonic-stack/496_next-greater-element-i.mdx new file mode 100644 index 0000000..1f30bbc --- /dev/null +++ b/apps/docs/content/(01-linear-structures)/monotonic-stack/496_next-greater-element-i.mdx @@ -0,0 +1,59 @@ +--- +title: '496. Next Greater Element I' +description: The next greater element of some element x in an array is the first greater element that is to the right of x in the same array +icon: dot +topics: + - { name: "Array", slug: "array" } + - { name: "Hash Table", slug: "hash-table" } + - { name: "Stack", slug: "stack" } + - { name: "Monotonic Stack", slug: "monotonic-stack" } +issue: "https://github.com/prdlk/leetcode/issues/74" +sidebar: + label: 'Next Greater Element I' + badge: 'Easy' +--- + +::::warning +Could you find an O(nums1.length + nums2.length) solution? +:::: + +### Example 1: +- Input: `nums1 = [4,1,2], nums2 = [1,3,4,2]` +- Output: `[-1,3,-1]` +- Explanation: + - The next greater element for each value of `nums1` is as follows: + - `4` is underlined in `nums2 = [1,3,4,2]`. There is no next greater element, so the answer is `-1`. + - `1` is underlined in `nums2 = [1,3,4,2]`. The next greater element is `3`. + - `2` is underlined in `nums2 = [1,3,4,2]`. There is no next greater element, so the answer is `-1`. + +### Example 2: +- Input: `nums1 = [2,4], nums2 = [1,2,3,4]` +- Output: `[3,-1]` +- Explanation: + - The next greater element for each value of `nums1` is as follows: + - `2` is underlined in `nums2 = [1,2,3,4]`. The next greater element is `3`. + - `4` is underlined in `nums2 = [1,2,3,4]`. There is no next greater element, so the answer is `-1`. + +### Constraints: + +- `1 <= nums1.length <= nums2.length <= 1000` +- `0 <= nums1[i], nums2[i] <= 10^4` +- All integers in `nums1` and `nums2` are unique. +- All the integers of `nums1` also appear in nums2. + +## Solution + +```py +class Solution: + def nextGreaterElement(self, nums1: list[int], nums2: list[int]) -> list[int]: + mono_stack = [] + next_greater = {} + + for cur in nums2: + while mono_stack and cur > mono_stack[-1]: + val = mono_stack.pop() + next_greater[val] = cur + mono_stack.append(cur) + + return [next_greater.get(x, -1) for x in nums1] +``` diff --git a/apps/docs/content/(01-linear-structures)/two-pointers/80_remove-duplicates-from-sorted-array-ii.mdx b/apps/docs/content/(01-linear-structures)/two-pointers/80_remove-duplicates-from-sorted-array-ii.mdx new file mode 100644 index 0000000..e6c758f --- /dev/null +++ b/apps/docs/content/(01-linear-structures)/two-pointers/80_remove-duplicates-from-sorted-array-ii.mdx @@ -0,0 +1,41 @@ +--- +title: '80. Remove Duplicates from Sorted Array II' +description: Given an integer array nums sorted in non-decreasing order, remove some duplicates in-place such that each unique element appears at most twice. The relative order of the elements should be kept the same +icon: dot +topics: + - { name: "Array", slug: "array" } + - { name: "Two Pointers", slug: "two-pointers" } +issue: "https://github.com/prdlk/leetcode/issues/48" +sidebar: + label: 'Remove Duplicates from Sorted Array II' + badge: 'Medium' +--- + +### Example 1: +- Input: `nums = [1,1,1,2,2,3]` +- Output: `5, nums = [1,1,2,2,3,_]` +- Explanation: Your function should return `k = 5`, with the first five elements of `nums` being `1`, `1`, `2`, `2` and `3` respectively. It does not matter what you leave beyond the returned `k` (hence they are underscores). + +### Example 2: +- Input: `nums = [0,0,1,1,1,1,2,3,3]` +- Output: `7, nums = [0,0,1,1,2,3,3,_,_]` +- Explanation: Your function should return `k = 7`, with the first seven elements of `nums` being `0`, `0`, `1`, `1`, `2`, `3` and `3` respectively. It does not matter what you leave beyond the returned `k` (hence they are underscores). + +### Constraints: + +- `1 <= nums.length <= 3 * 10^4` +- `-10^4 <= nums[i] <= 10^4` +- `nums` is sorted in non-decreasing order. + +## Solution + +```py +class Solution: + def removeDuplicates(self, nums: list[int]) -> int: + slow = 0 + for fast in range(len(nums)): + if slow < 2 or nums[fast] != nums[slow - 2]: + nums[slow] = nums[fast] + slow += 1 + return slow +``` diff --git a/apps/docs/redirects.ts b/apps/docs/redirects.ts index f818707..69a7b96 100644 --- a/apps/docs/redirects.ts +++ b/apps/docs/redirects.ts @@ -30,6 +30,7 @@ export default [ { from: "/73", to: "/matrix-index-math/set-matrix-zeroes" }, { from: "/74", to: "/binary-search/search-a-2d-matrix" }, { from: "/78", to: "/backtracking/subsets" }, + { from: "/80", to: "/two-pointers/remove-duplicates-from-sorted-array-ii" }, { from: "/84", to: "/monotonic-stack/largest-rectangle-in-histogram" }, { from: "/98", to: "/binary-search-tree/validate-binary-search-tree" }, { from: "/102", to: "/tree-bfs/binary-tree-level-order-traversal" }, @@ -78,6 +79,7 @@ export default [ { from: "/424", to: "/sliding-window/longest-repeating-character-replacement" }, { from: "/435", to: "/intervals/non-overlapping-intervals" }, { from: "/451", to: "/hash-table/sort-characters-by-frequency" }, + { from: "/496", to: "/monotonic-stack/next-greater-element-i" }, { from: "/525", to: "/prefix-sum/contiguous-array" }, { from: "/560", to: "/prefix-sum/subarray-sum-equals-k" }, { from: "/567", to: "/sliding-window/permutation-in-string" },