diff --git a/src/main/java/g0001_0100/s0023_merge_k_sorted_lists/readme.md b/src/main/java/g0001_0100/s0023_merge_k_sorted_lists/readme.md index 3d4409279..a96a7d090 100644 --- a/src/main/java/g0001_0100/s0023_merge_k_sorted_lists/readme.md +++ b/src/main/java/g0001_0100/s0023_merge_k_sorted_lists/readme.md @@ -12,7 +12,7 @@ _Merge all the linked-lists into one sorted linked-list and return it._ **Output:** [1,1,2,3,4,4,5,6] -**Explanation:** The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted list: 1->1->2->3->4->4->5->6 +**Explanation:** The linked-lists are: [ 1->4->5, 1->3->4, 2->6 ] merging them into one sorted linked list: 1->1->2->3->4->4->5->6 **Example 2:** @@ -29,11 +29,11 @@ _Merge all the linked-lists into one sorted linked-list and return it._ **Constraints:** * `k == lists.length` -* `0 <= k <= 10^4` +* 0 <= k <= 104 * `0 <= lists[i].length <= 500` -* `-10^4 <= lists[i][j] <= 10^4` +* -104 <= lists[i][j] <= 104 * `lists[i]` is sorted in **ascending order**. -* The sum of `lists[i].length` won't exceed `10^4`. +* The sum of `lists[i].length` will not exceed 104. To solve the "Merge k Sorted Lists" problem in Java with a `Solution` class, we can use a priority queue (min-heap) to efficiently merge the lists. Here are the steps: @@ -130,4 +130,4 @@ class ListNode { } ``` -This implementation provides a solution to the "Merge k Sorted Lists" problem in Java using a priority queue. \ No newline at end of file +This implementation provides a solution to the "Merge k Sorted Lists" problem in Java using a priority queue. diff --git a/src/main/java/g0001_0100/s0024_swap_nodes_in_pairs/readme.md b/src/main/java/g0001_0100/s0024_swap_nodes_in_pairs/readme.md index 3b760b9f3..9a33becba 100644 --- a/src/main/java/g0001_0100/s0024_swap_nodes_in_pairs/readme.md +++ b/src/main/java/g0001_0100/s0024_swap_nodes_in_pairs/readme.md @@ -6,23 +6,31 @@ Given a linked list, swap every two adjacent nodes and return its head. You must **Example 1:** -![](https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg) - **Input:** head = [1,2,3,4] -**Output:** [2,1,4,3] +**Output:** [2,1,4,3] + +**Explanation:** + +![](https://assets.leetcode.com/uploads/2020/10/03/swap_ex1.jpg) **Example 2:** **Input:** head = [] -**Output:** [] +**Output:** [] **Example 3:** **Input:** head = [1] -**Output:** [1] +**Output:** [1] + +**Example 4:** + +**Input:** head = [1,2,3] + +**Output:** [2,1,3] **Constraints:** @@ -76,4 +84,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Swap Nodes in Pairs" problem in Java without modifying the values in the list's nodes. \ No newline at end of file +This implementation provides a solution to the "Swap Nodes in Pairs" problem in Java without modifying the values in the list's nodes. diff --git a/src/main/java/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md b/src/main/java/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md index d20719d93..5740b8cd6 100644 --- a/src/main/java/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md +++ b/src/main/java/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md @@ -2,9 +2,9 @@ Hard -Given a linked list, reverse the nodes of a linked list _k_ at a time and return its modified list. +Given the `head` of a linked list, reverse the nodes of the list `k` at a time, and return _the modified list_. -_k_ is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of _k_ then left-out nodes, in the end, should remain as it is. +`k` is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of `k` then left-out nodes, in the end, should remain as it is. You may not alter the values in the list's nodes, only nodes themselves may be changed. @@ -24,26 +24,13 @@ You may not alter the values in the list's nodes, only nodes themselves may be c **Output:** [3,2,1,4,5] -**Example 3:** - -**Input:** head = [1,2,3,4,5], k = 1 - -**Output:** [1,2,3,4,5] - -**Example 4:** - -**Input:** head = [1], k = 1 - -**Output:** [1] - **Constraints:** -* The number of nodes in the list is in the range `sz`. -* `1 <= sz <= 5000` +* The number of nodes in the list is `n`. +* `1 <= k <= n <= 5000` * `0 <= Node.val <= 1000` -* `1 <= k <= sz` -**Follow-up:** Can you solve the problem in O(1) extra memory space? +**Follow-up:** Can you solve the problem in `O(1)` extra memory space? To solve the "Reverse Nodes in k-Group" problem in Java with a `Solution` class, we can reverse the nodes in groups of k using a recursive approach. Here are the steps: @@ -109,4 +96,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Reverse Nodes in k-Group" problem in Java without modifying the values in the list's nodes. It recursively reverses the nodes in groups of k. \ No newline at end of file +This implementation provides a solution to the "Reverse Nodes in k-Group" problem in Java without modifying the values in the list's nodes. It recursively reverses the nodes in groups of k. diff --git a/src/main/java/g0001_0100/s0026_remove_duplicates_from_sorted_array/readme.md b/src/main/java/g0001_0100/s0026_remove_duplicates_from_sorted_array/readme.md index b4e776e2b..9df434879 100644 --- a/src/main/java/g0001_0100/s0026_remove_duplicates_from_sorted_array/readme.md +++ b/src/main/java/g0001_0100/s0026_remove_duplicates_from_sorted_array/readme.md @@ -4,11 +4,9 @@ Easy Given an integer array `nums` sorted in **non-decreasing order**, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each unique element appears only **once**. The **relative order** of the elements should be kept the **same**. -Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements. +Consider the number of _unique elements_ in `nums` to be `k`. After removing duplicates, return the number of unique elements `k`. -Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`. - -Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory. +The first `k` elements of `nums` should contain the unique numbers in **sorted order**. The remaining elements beyond index `k - 1` can be ignored. **Custom Judge:** @@ -22,7 +20,7 @@ The judge will test your solution with the following code: assert k == expectedNums.length; for (int i = 0; i < k; i++) { assert nums[i] == expectedNums[i]; - } + } If all assertions pass, then your solution will be **accepted**. @@ -44,6 +42,6 @@ If all assertions pass, then your solution will be **accepted**. **Constraints:** -* 0 <= nums.length <= 3 * 104 +* 1 <= nums.length <= 3 * 104 * `-100 <= nums[i] <= 100` -* `nums` is sorted in **non-decreasing** order. \ No newline at end of file +* `nums` is sorted in **non-decreasing** order. diff --git a/src/main/java/g0001_0100/s0027_remove_element/readme.md b/src/main/java/g0001_0100/s0027_remove_element/readme.md index 027b058d6..a0baa21ba 100644 --- a/src/main/java/g0001_0100/s0027_remove_element/readme.md +++ b/src/main/java/g0001_0100/s0027_remove_element/readme.md @@ -2,13 +2,12 @@ Easy -Given an integer array `nums` and an integer `val`, remove all occurrences of `val` in `nums` [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm). The relative order of the elements may be changed. +Given an integer array `nums` and an integer `val`, remove all occurrences of `val` in `nums` [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm). The order of the elements may be changed. Then return _the number of elements in_ `nums` _which are not equal to_ `val`. -Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements. +Consider the number of elements in `nums` which are not equal to `val` be `k`, to get accepted, you need to do the following things: -Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`. - -Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory. +* Change the array `nums` such that the first `k` elements of `nums` contain the elements which are not equal to `val`. The remaining elements of `nums` are not important as well as the size of `nums`. +* Return `k`. **Custom Judge:** @@ -25,7 +24,7 @@ The judge will test your solution with the following code: sort(nums, 0, k); // Sort the first k elements of nums for (int i = 0; i < actualLength; i++) { assert nums[i] == expectedNums[i]; - } + } If all assertions pass, then your solution will be **accepted**. @@ -49,4 +48,4 @@ If all assertions pass, then your solution will be **accepted**. * `0 <= nums.length <= 100` * `0 <= nums[i] <= 50` -* `0 <= val <= 100` \ No newline at end of file +* `0 <= val <= 100` diff --git a/src/main/java/g0001_0100/s0028_find_the_index_of_the_first_occurrence_in_a_string/readme.md b/src/main/java/g0001_0100/s0028_find_the_index_of_the_first_occurrence_in_a_string/readme.md index 098bd2485..16b5a75d9 100644 --- a/src/main/java/g0001_0100/s0028_find_the_index_of_the_first_occurrence_in_a_string/readme.md +++ b/src/main/java/g0001_0100/s0028_find_the_index_of_the_first_occurrence_in_a_string/readme.md @@ -1,36 +1,26 @@ -28\. Implement strStr() +28\. Find the Index of the First Occurrence in a String Easy -Implement [strStr()](http://www.cplusplus.com/reference/cstring/strstr/). - -Return the index of the first occurrence of needle in haystack, or `-1` if `needle` is not part of `haystack`. - -**Clarification:** - -What should we return when `needle` is an empty string? This is a great question to ask during an interview. - -For the purpose of this problem, we will return 0 when `needle` is an empty string. This is consistent to C's [strstr()](http://www.cplusplus.com/reference/cstring/strstr/) and Java's [indexOf()](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#indexOf(java.lang.String)). +Given two strings `needle` and `haystack`, return the index of the first occurrence of `needle` in `haystack`, or `-1` if `needle` is not part of `haystack`. **Example 1:** -**Input:** haystack = "hello", needle = "ll" +**Input:** haystack = "sadbutsad", needle = "sad" -**Output:** 2 +**Output:** 0 -**Example 2:** - -**Input:** haystack = "aaaaa", needle = "bba" +**Explanation:** "sad" occurs at index 0 and 6. The first occurrence is at index 0, so we return 0. -**Output:** -1 +**Example 2:** -**Example 3:** +**Input:** haystack = "leetcode", needle = "leeto" -**Input:** haystack = "", needle = "" +**Output:** -1 -**Output:** 0 +**Explanation:** "leeto" did not occur in "leetcode", so we return -1. **Constraints:** -* 0 <= haystack.length, needle.length <= 5 * 104 -* `haystack` and `needle` consist of only lower-case English characters. \ No newline at end of file +* 1 <= haystack.length, needle.length <= 104 +* `haystack` and `needle` consist of only lowercase English characters. \ No newline at end of file diff --git a/src/main/java/g0001_0100/s0030_substring_with_concatenation_of_all_words/readme.md b/src/main/java/g0001_0100/s0030_substring_with_concatenation_of_all_words/readme.md index e4075f47a..a288f65e2 100644 --- a/src/main/java/g0001_0100/s0030_substring_with_concatenation_of_all_words/readme.md +++ b/src/main/java/g0001_0100/s0030_substring_with_concatenation_of_all_words/readme.md @@ -2,9 +2,13 @@ Hard -You are given a string `s` and an array of strings `words` of **the same length**. Return all starting indices of substring(s) in `s` that is a concatenation of each word in `words` **exactly once**, **in any order**, and **without any intervening characters**. +You are given a string `s` and an array of strings `words`. All the strings of `words` are of **the same length**. -You can return the answer in **any order**. +A **concatenated string** is a string that exactly contains all the strings of any permutation of `words` concatenated. + +* For example, if `words = ["ab","cd","ef"]`, then `"abcdef"`, `"abefcd"`, `"cdabef"`, `"cdefab"`, `"efabcd"`, and `"efcdab"` are all concatenated strings. `"acdbef"` is not a concatenated string because it is not the concatenation of any permutation of `words`. + +Return an array of _the starting indices_ of all the concatenated substrings in `s`. You can return the answer in **any order**. **Example 1:** @@ -12,24 +16,36 @@ You can return the answer in **any order**. **Output:** [0,9] -**Explanation:** Substrings starting at index 0 and 9 are "barfoo" and "foobar" respectively. The output order does not matter, returning [9,0] is fine too. +**Explanation:** + +The substring starting at 0 is `"barfoo"`. It is the concatenation of `["bar","foo"]` which is a permutation of `words`. + The substring starting at 9 is `"foobar"`. It is the concatenation of `["foo","bar"]` which is a permutation of `words`. **Example 2:** **Input:** s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"] -**Output:** [] +**Output:** [] + +**Explanation:** + +There is no concatenated substring. **Example 3:** **Input:** s = "barfoofoobarthefoobarman", words = ["bar","foo","the"] -**Output:** [6,9,12] +**Output:** [6,9,12] + +**Explanation:** + +The substring starting at 6 is `"foobarthe"`. It is the concatenation of `["foo","bar","the"]`. + The substring starting at 9 is `"barthefoo"`. It is the concatenation of `["bar","the","foo"]`. + The substring starting at 12 is `"thefoobar"`. It is the concatenation of `["the","foo","bar"]`. **Constraints:** * 1 <= s.length <= 104 -* `s` consists of lower-case English letters. * `1 <= words.length <= 5000` * `1 <= words[i].length <= 30` -* `words[i]` consists of lower-case English letters. \ No newline at end of file +* `s` and `words[i]` consist of lowercase English letters. \ No newline at end of file diff --git a/src/main/java/g0001_0100/s0031_next_permutation/readme.md b/src/main/java/g0001_0100/s0031_next_permutation/readme.md index 8dc4ea508..ceb7d0b9a 100644 --- a/src/main/java/g0001_0100/s0031_next_permutation/readme.md +++ b/src/main/java/g0001_0100/s0031_next_permutation/readme.md @@ -2,9 +2,17 @@ Medium -Implement **next permutation**, which rearranges numbers into the lexicographically next greater permutation of numbers. +A **permutation** of an array of integers is an arrangement of its members into a sequence or linear order. -If such an arrangement is not possible, it must rearrange it as the lowest possible order (i.e., sorted in ascending order). +* For example, for `arr = [1,2,3]`, the following are all the permutations of `arr`: `[1,2,3], [1,3,2], [2, 1, 3], [2, 3, 1], [3,1,2], [3,2,1]`. + +The **next permutation** of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the **next permutation** of that array is the permutation that follows it in the sorted container. If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order). + +* For example, the next permutation of `arr = [1,2,3]` is `[1,3,2]`. +* Similarly, the next permutation of `arr = [2,3,1]` is `[3,1,2]`. +* While the next permutation of `arr = [3,2,1]` is `[1,2,3]` because `[3,2,1]` does not have a lexicographical larger rearrangement. + +Given an array of integers `nums`, _find the next permutation of_ `nums`. The replacement must be **[in place](http://en.wikipedia.org/wiki/In-place_algorithm)** and use only constant extra memory. @@ -26,12 +34,6 @@ The replacement must be **[in place](http://en.wikipedia.org/wiki/In-place_algor **Output:** [1,5,1] -**Example 4:** - -**Input:** nums = [1] - -**Output:** [1] - **Constraints:** * `1 <= nums.length <= 100` @@ -96,4 +98,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Next Permutation" problem in Java. It finds the next lexicographically greater permutation of the given array `nums` and modifies it in place. \ No newline at end of file +This implementation provides a solution to the "Next Permutation" problem in Java. It finds the next lexicographically greater permutation of the given array `nums` and modifies it in place. diff --git a/src/main/java/g0001_0100/s0032_longest_valid_parentheses/readme.md b/src/main/java/g0001_0100/s0032_longest_valid_parentheses/readme.md index f39d676e5..4f7ba516e 100644 --- a/src/main/java/g0001_0100/s0032_longest_valid_parentheses/readme.md +++ b/src/main/java/g0001_0100/s0032_longest_valid_parentheses/readme.md @@ -2,7 +2,7 @@ Hard -Given a string containing just the characters `'('` and `')'`, find the length of the longest valid (well-formed) parentheses substring. +Given a string containing just the characters `'('` and `')'`, return _the length of the longest valid (well-formed) parentheses_ **substring**. **Example 1:** @@ -76,4 +76,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Longest Valid Parentheses" problem in Java. It finds the length of the longest valid parentheses substring in the given string `s`. \ No newline at end of file +This implementation provides a solution to the "Longest Valid Parentheses" problem in Java. It finds the length of the longest valid parentheses substring in the given string `s`. diff --git a/src/main/java/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md b/src/main/java/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md index eddc18d75..5ed3224c9 100644 --- a/src/main/java/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md +++ b/src/main/java/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md @@ -4,7 +4,7 @@ Medium There is an integer array `nums` sorted in ascending order (with **distinct** values). -Prior to being passed to your function, `nums` is **possibly rotated** at an unknown pivot index `k` (`1 <= k < nums.length`) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]` (**0-indexed**). For example, `[0,1,2,4,5,6,7]` might be rotated at pivot index `3` and become `[4,5,6,7,0,1,2]`. +Prior to being passed to your function, `nums` is **possibly left rotated** at an unknown index `k` (`1 <= k < nums.length`) such that the resulting array is `[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]` (**0-indexed**). For example, `[0,1,2,4,5,6,7]` might be left rotated by `3` indices and become `[4,5,6,7,0,1,2]`. Given the array `nums` **after** the possible rotation and an integer `target`, return _the index of_ `target` _if it is in_ `nums`_, or_ `-1` _if it is not in_ `nums`. @@ -88,4 +88,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Search in Rotated Sorted Array" problem in Java. It searches for the index of `target` in the rotated sorted array `nums`. The algorithm has a time complexity of O(log n). \ No newline at end of file +This implementation provides a solution to the "Search in Rotated Sorted Array" problem in Java. It searches for the index of `target` in the rotated sorted array `nums`. The algorithm has a time complexity of O(log n). diff --git a/src/main/java/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md b/src/main/java/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md index 16bdb69dc..0e1036e1f 100644 --- a/src/main/java/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md +++ b/src/main/java/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/readme.md @@ -99,4 +99,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Find First and Last Position of Element in Sorted Array" problem in Java. It returns the starting and ending positions of `target` in `nums` using binary search, with a time complexity of O(log n). \ No newline at end of file +This implementation provides a solution to the "Find First and Last Position of Element in Sorted Array" problem in Java. It returns the starting and ending positions of `target` in `nums` using binary search, with a time complexity of O(log n). diff --git a/src/main/java/g0001_0100/s0035_search_insert_position/readme.md b/src/main/java/g0001_0100/s0035_search_insert_position/readme.md index 1de0a7a07..b178a53bc 100644 --- a/src/main/java/g0001_0100/s0035_search_insert_position/readme.md +++ b/src/main/java/g0001_0100/s0035_search_insert_position/readme.md @@ -24,18 +24,6 @@ You must write an algorithm with `O(log n)` runtime complexity. **Output:** 4 -**Example 4:** - -**Input:** nums = [1,3,5,6], target = 0 - -**Output:** 0 - -**Example 5:** - -**Input:** nums = [1], target = 0 - -**Output:** 0 - **Constraints:** * 1 <= nums.length <= 104 @@ -80,4 +68,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Search Insert Position" problem in Java. It returns the index where `target` would be inserted in `nums` using binary search, with a time complexity of O(log n). \ No newline at end of file +This implementation provides a solution to the "Search Insert Position" problem in Java. It returns the index where `target` would be inserted in `nums` using binary search, with a time complexity of O(log n). diff --git a/src/main/java/g0001_0100/s0039_combination_sum/readme.md b/src/main/java/g0001_0100/s0039_combination_sum/readme.md index 21570dc8f..2130d52f7 100644 --- a/src/main/java/g0001_0100/s0039_combination_sum/readme.md +++ b/src/main/java/g0001_0100/s0039_combination_sum/readme.md @@ -6,7 +6,7 @@ Given an array of **distinct** integers `candidates` and a target integer `targe The **same** number may be chosen from `candidates` an **unlimited number of times**. Two combinations are unique if the frequency of at least one of the chosen numbers is different. -It is **guaranteed** that the number of unique combinations that sum up to `target` is less than `150` combinations for the given input. +The test cases are generated such that the number of unique combinations that sum up to `target` is less than `150` combinations for the given input. **Example 1:** @@ -14,11 +14,7 @@ It is **guaranteed** that the number of unique combinations that sum up to `targ **Output:** [[2,2,3],[7]] -**Explanation:** - - 2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times. - 7 is a candidate, and 7 = 7. - These are the only two combinations. +**Explanation:** 2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times. 7 is a candidate, and 7 = 7. These are the only two combinations. **Example 2:** @@ -32,24 +28,12 @@ It is **guaranteed** that the number of unique combinations that sum up to `targ **Output:** [] -**Example 4:** - -**Input:** candidates = [1], target = 1 - -**Output:** [[1]] - -**Example 5:** - -**Input:** candidates = [1], target = 2 - -**Output:** [[1,1]] - **Constraints:** * `1 <= candidates.length <= 30` -* `1 <= candidates[i] <= 200` +* `2 <= candidates[i] <= 40` * All elements of `candidates` are **distinct**. -* `1 <= target <= 500` +* `1 <= target <= 40` To solve the "Combination Sum" problem in Java with a `Solution` class, we can follow these steps: @@ -100,4 +84,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Combination Sum" problem in Java. It explores all possible combinations of candidates using backtracking and returns the unique combinations whose sum equals the target. \ No newline at end of file +This implementation provides a solution to the "Combination Sum" problem in Java. It explores all possible combinations of candidates using backtracking and returns the unique combinations whose sum equals the target. diff --git a/src/main/java/g0001_0100/s0041_first_missing_positive/readme.md b/src/main/java/g0001_0100/s0041_first_missing_positive/readme.md index abfc2b245..32df8d6ae 100644 --- a/src/main/java/g0001_0100/s0041_first_missing_positive/readme.md +++ b/src/main/java/g0001_0100/s0041_first_missing_positive/readme.md @@ -2,31 +2,37 @@ Hard -Given an unsorted integer array `nums`, return the smallest missing positive integer. +Given an unsorted integer array `nums`. Return the _smallest positive integer_ that is _not present_ in `nums`. -You must implement an algorithm that runs in `O(n)` time and uses constant extra space. +You must implement an algorithm that runs in `O(n)` time and uses `O(1)` auxiliary space. **Example 1:** **Input:** nums = [1,2,0] -**Output:** 3 +**Output:** 3 + +**Explanation:** The numbers in the range [1,2] are all in the array. **Example 2:** **Input:** nums = [3,4,-1,1] -**Output:** 2 +**Output:** 2 + +**Explanation:** 1 is in the array but 2 is missing. **Example 3:** **Input:** nums = [7,8,9,11,12] -**Output:** 1 +**Output:** 1 + +**Explanation:** The smallest positive integer 1 is missing. **Constraints:** -* 1 <= nums.length <= 5 * 105 +* 1 <= nums.length <= 105 * -231 <= nums[i] <= 231 - 1 To solve the "First Missing Positive" problem in Java with a `Solution` class, we can follow these steps: @@ -70,4 +76,4 @@ public class Solution { } ``` -This implementation provides a solution to the "First Missing Positive" problem in Java. It marks positive integers found by negating the value at the corresponding index and then iterates through the modified array to find the smallest missing positive integer. If no positive number is found, it returns `nums.length + 1`. \ No newline at end of file +This implementation provides a solution to the "First Missing Positive" problem in Java. It marks positive integers found by negating the value at the corresponding index and then iterates through the modified array to find the smallest missing positive integer. If no positive number is found, it returns `nums.length + 1`. diff --git a/src/main/java/g0001_0100/s0042_trapping_rain_water/readme.md b/src/main/java/g0001_0100/s0042_trapping_rain_water/readme.md index 2e839c06a..d400d21b9 100644 --- a/src/main/java/g0001_0100/s0042_trapping_rain_water/readme.md +++ b/src/main/java/g0001_0100/s0042_trapping_rain_water/readme.md @@ -66,4 +66,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Trapping Rain Water" problem in Java. It calculates the amount of water that can be trapped between bars by using two pointers to track the left and right boundaries and two variables to track the maximum heights of bars encountered from the left and right directions. \ No newline at end of file +This implementation provides a solution to the "Trapping Rain Water" problem in Java. It calculates the amount of water that can be trapped between bars by using two pointers to track the left and right boundaries and two variables to track the maximum heights of bars encountered from the left and right directions. diff --git a/src/main/java/g0001_0100/s0045_jump_game_ii/readme.md b/src/main/java/g0001_0100/s0045_jump_game_ii/readme.md index db8fa23af..1622fd539 100644 --- a/src/main/java/g0001_0100/s0045_jump_game_ii/readme.md +++ b/src/main/java/g0001_0100/s0045_jump_game_ii/readme.md @@ -2,13 +2,14 @@ Medium -Given an array of non-negative integers `nums`, you are initially positioned at the first index of the array. +You are given a **0-indexed** array of integers `nums` of length `n`. You are initially positioned at index 0. -Each element in the array represents your maximum jump length at that position. +Each element `nums[i]` represents the maximum length of a forward jump from index `i`. In other words, if you are at index `i`, you can jump to any index `(i + j)` where: -Your goal is to reach the last index in the minimum number of jumps. +* `0 <= j <= nums[i]` and +* `i + j < n` -You can assume that you can always reach the last index. +Return _the minimum number of jumps to reach index_ `n - 1`. The test cases are generated such that you can reach index `n - 1`. **Example 1:** @@ -28,6 +29,7 @@ You can assume that you can always reach the last index. * 1 <= nums.length <= 104 * `0 <= nums[i] <= 1000` +* It's guaranteed that you can reach `nums[n - 1]`. To solve the "Jump Game II" problem in Java with a `Solution` class, we can follow these steps: @@ -61,4 +63,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Jump Game II" problem in Java. It calculates the minimum number of jumps required to reach the last index by iterating through the array and updating the maximum reachable position and the end position accordingly. \ No newline at end of file +This implementation provides a solution to the "Jump Game II" problem in Java. It calculates the minimum number of jumps required to reach the last index by iterating through the array and updating the maximum reachable position and the end position accordingly. diff --git a/src/main/java/g0001_0100/s0046_permutations/readme.md b/src/main/java/g0001_0100/s0046_permutations/readme.md index 49b6db09a..31b15e6dd 100644 --- a/src/main/java/g0001_0100/s0046_permutations/readme.md +++ b/src/main/java/g0001_0100/s0046_permutations/readme.md @@ -2,7 +2,7 @@ Medium -Given an array `nums` of distinct integers, return _all the possible permutations_. You can return the answer in **any order**. +Given an array `nums` of distinct integers, return all the possible permutations. You can return the answer in **any order**. **Example 1:** @@ -71,4 +71,4 @@ public class Solution { } ``` -This implementation provides a solution to the "Permutations" problem in Java. It generates all possible permutations of the given array of distinct integers using backtracking. \ No newline at end of file +This implementation provides a solution to the "Permutations" problem in Java. It generates all possible permutations of the given array of distinct integers using backtracking. diff --git a/src/main/java/g0001_0100/s0048_rotate_image/readme.md b/src/main/java/g0001_0100/s0048_rotate_image/readme.md index 9c58ae342..5077707b7 100644 --- a/src/main/java/g0001_0100/s0048_rotate_image/readme.md +++ b/src/main/java/g0001_0100/s0048_rotate_image/readme.md @@ -22,22 +22,9 @@ You have to rotate the image [**in-place**](https://en.wikipedia.org/wiki/In-pla **Output:** [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]] -**Example 3:** - -**Input:** matrix = [[1]] - -**Output:** [[1]] - -**Example 4:** - -**Input:** matrix = [[1,2],[3,4]] - -**Output:** [[3,1],[4,2]] - **Constraints:** -* `matrix.length == n` -* `matrix[i].length == n` +* `n == matrix.length == matrix[i].length` * `1 <= n <= 20` * `-1000 <= matrix[i][j] <= 1000` diff --git a/src/main/java/g0001_0100/s0049_group_anagrams/readme.md b/src/main/java/g0001_0100/s0049_group_anagrams/readme.md index 163c68ac0..3d2d7723f 100644 --- a/src/main/java/g0001_0100/s0049_group_anagrams/readme.md +++ b/src/main/java/g0001_0100/s0049_group_anagrams/readme.md @@ -2,27 +2,31 @@ Medium -Given an array of strings `strs`, group **the anagrams** together. You can return the answer in **any order**. - -An **Anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once. +Given an array of strings `strs`, group the anagrams together. You can return the answer in **any order**. **Example 1:** **Input:** strs = ["eat","tea","tan","ate","nat","bat"] -**Output:** [["bat"],["nat","tan"],["ate","eat","tea"]] +**Output:** [["bat"],["nat","tan"],["ate","eat","tea"]] + +**Explanation:** + +* There is no string in strs that can be rearranged to form `"bat"`. +* The strings `"nat"` and `"tan"` are anagrams as they can be rearranged to form each other. +* The strings `"ate"`, `"eat"`, and `"tea"` are anagrams as they can be rearranged to form each other. **Example 2:** **Input:** strs = [""] -**Output:** [[""]] +**Output:** [[""]] **Example 3:** **Input:** strs = ["a"] -**Output:** [["a"]] +**Output:** [["a"]] **Constraints:** @@ -76,4 +80,4 @@ class Solution { } ``` -This implementation ensures that all anagrams are grouped together efficiently using a HashMap. \ No newline at end of file +This implementation ensures that all anagrams are grouped together efficiently using a HashMap.