Added tasks 31-46

Author: ThanhNIT

src/main/python/g0001_0100/s0031_next_permutation/Solution.py

@@ -0,0 +1,31 @@
+# #Medium #Top_100_Liked_Questions #Array #Two_Pointers #Big_O_Time_O(n)_Space_O(1)
+# #2024_06_08_Time_35_ms_(93.06%)_Space_16.5_MB_(44.75%)
+
+class Solution:
+    def nextPermutation(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        if not nums or len(nums) <= 1:
+            return
+
+        i = len(nums) - 2
+        while i >= 0 and nums[i] >= nums[i + 1]:
+            i -= 1
+
+        if i >= 0:
+            j = len(nums) - 1
+            while nums[j] <= nums[i]:
+                j -= 1
+            self.swap(nums, i, j)
+
+        self.reverse(nums, i + 1, len(nums) - 1)
+
+    def swap(self, nums, i, j):
+        nums[i], nums[j] = nums[j], nums[i]
+
+    def reverse(self, nums, i, j):
+        while i < j:
+            self.swap(nums, i, j)
+            i += 1
+            j -= 1

src/main/python/g0001_0100/s0031_next_permutation/readme.md

@@ -0,0 +1,99 @@
+31\. Next Permutation
+
+Medium
+
+Implement **next permutation**, which rearranges numbers into the lexicographically next greater permutation of numbers.
+
+If such an arrangement is not possible, it must rearrange it as the lowest possible order (i.e., sorted in ascending order).
+
+The replacement must be **[in place](http://en.wikipedia.org/wiki/In-place_algorithm)** and use only constant extra memory.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** [1,3,2] 
+
+**Example 2:**
+
+**Input:** nums = [3,2,1]
+
+**Output:** [1,2,3] 
+
+**Example 3:**
+
+**Input:** nums = [1,1,5]
+
+**Output:** [1,5,1] 
+
+**Example 4:**
+
+**Input:** nums = [1]
+
+**Output:** [1] 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 100`
+*   `0 <= nums[i] <= 100`
+
+To solve the "Next Permutation" problem in Java with a `Solution` class, we can follow these steps:
+
+1. Define a `Solution` class.
+2. Define a method named `nextPermutation` that takes an integer array `nums` as input and modifies it to find the next permutation in lexicographic order.
+3. Find the first index `i` from the right such that `nums[i] > nums[i - 1]`. If no such index exists, reverse the entire array, as it's already the last permutation.
+4. Find the smallest index `j` from the right such that `nums[j] > nums[i - 1]`.
+5. Swap `nums[i - 1]` with `nums[j]`.
+6. Reverse the suffix of the array starting from index `i`.
+
+Here's the implementation:
+
+```java
+public class Solution {
+    public void nextPermutation(int[] nums) {
+        int n = nums.length;
+        
+        // Step 1: Find the first index i from the right such that nums[i] > nums[i - 1]
+        int i = n - 1;
+        while (i > 0 && nums[i] <= nums[i - 1]) {
+            i--;
+        }
+        
+        // Step 2: If no such index exists, reverse the entire array
+        if (i == 0) {
+            reverse(nums, 0, n - 1);
+            return;
+        }
+        
+        // Step 3: Find the smallest index j from the right such that nums[j] > nums[i - 1]
+        int j = n - 1;
+        while (nums[j] <= nums[i - 1]) {
+            j--;
+        }
+        
+        // Step 4: Swap nums[i - 1] with nums[j]
+        swap(nums, i - 1, j);
+        
+        // Step 5: Reverse the suffix of the array starting from index i
+        reverse(nums, i, n - 1);
+    }
+    
+    // Helper method to reverse a portion of the array
+    private void reverse(int[] nums, int start, int end) {
+        while (start < end) {
+            swap(nums, start, end);
+            start++;
+            end--;
+        }
+    }
+    
+    // Helper method to swap two elements in the array
+    private void swap(int[] nums, int i, int j) {
+        int temp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = temp;
+    }
+}
+```
+
+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.

src/main/python/g0001_0100/s0032_longest_valid_parentheses/Solution.py

@@ -0,0 +1,38 @@
+# #Hard #Top_100_Liked_Questions #String #Dynamic_Programming #Stack #Big_O_Time_O(n)_Space_O(1)
+# #2024_06_08_Time_36_ms_(89.25%)_Space_16.7_MB_(89.20%)
+
+class Solution:
+    def longestValidParentheses(self, s: str) -> int:
+        max_length = 0
+        left = 0
+        right = 0
+        n = len(s)
+        
+        # First pass: left to right
+        for i in range(n):
+            if s[i] == '(':
+                left += 1
+            else:
+                right += 1
+            if right > left:
+                left = 0
+                right = 0
+            if left == right:
+                max_length = max(max_length, 2 * right)
+        
+        left = 0
+        right = 0
+        
+        # Second pass: right to left
+        for i in range(n - 1, -1, -1):
+            if s[i] == '(':
+                left += 1
+            else:
+                right += 1
+            if left > right:
+                left = 0
+                right = 0
+            if left == right:
+                max_length = max(max_length, 2 * left)
+        
+        return max_length

src/main/python/g0001_0100/s0032_longest_valid_parentheses/readme.md

@@ -0,0 +1,79 @@
+32\. Longest Valid Parentheses
+
+Hard
+
+Given a string containing just the characters `'('` and `')'`, find the length of the longest valid (well-formed) parentheses substring.
+
+**Example 1:**
+
+**Input:** s = "(()"
+
+**Output:** 2
+
+**Explanation:** The longest valid parentheses substring is "()". 
+
+**Example 2:**
+
+**Input:** s = ")()())"
+
+**Output:** 4
+
+**Explanation:** The longest valid parentheses substring is "()()". 
+
+**Example 3:**
+
+**Input:** s = ""
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= s.length <= 3 * 10<sup>4</sup></code>
+*   `s[i]` is `'('`, or `')'`.
+
+To solve the "Longest Valid Parentheses" problem in Java with a `Solution` class, we can follow these steps:
+
+1. Define a `Solution` class.
+2. Define a method named `longestValidParentheses` that takes a string `s` as input and returns an integer representing the length of the longest valid parentheses substring.
+3. Initialize a stack to store the indices of characters.
+4. Initialize a variable `maxLen` to store the maximum length of valid parentheses found so far.
+5. Push `-1` onto the stack to mark the starting point of a potential valid substring.
+6. Iterate through each character of the string:
+   - If the character is `'('`, push its index onto the stack.
+   - If the character is `')'`:
+     - Pop the top index from the stack.
+     - If the stack is empty after popping, push the current index onto the stack to mark the starting point of the next potential valid substring.
+     - Otherwise, update `maxLen` with the maximum of the current `maxLen` and `i - stack.peek()`, where `i` is the current index and `stack.peek()` is the index at the top of the stack.
+7. Return `maxLen`.
+
+Here's the implementation:
+
+```java
+import java.util.Stack;
+
+public class Solution {
+    public int longestValidParentheses(String s) {
+        int maxLen = 0;
+        Stack<Integer> stack = new Stack<>();
+        stack.push(-1); // Mark the starting point of a potential valid substring
+        
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (c == '(') {
+                stack.push(i);
+            } else { // c == ')'
+                stack.pop();
+                if (stack.isEmpty()) {
+                    stack.push(i); // Mark the starting point of the next potential valid substring
+                } else {
+                    maxLen = Math.max(maxLen, i - stack.peek());
+                }
+            }
+        }
+        
+        return maxLen;
+    }
+}
+```
+
+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`.

src/main/python/g0001_0100/s0033_search_in_rotated_sorted_array/Solution.py

@@ -0,0 +1,27 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search
+# #Algorithm_II_Day_1_Binary_Search #Binary_Search_I_Day_11 #Level_2_Day_8_Binary_Search
+# #Udemy_Binary_Search #Big_O_Time_O(log_n)_Space_O(1)
+# #2024_06_08_Time_36_ms_(91.71%)_Space_16.8_MB_(98.65%)
+
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        lo, hi = 0, len(nums) - 1
+        
+        while lo <= hi:
+            mid = (hi - lo) // 2 + lo
+            if nums[mid] == target:
+                return mid
+            # If the left half is sorted
+            if nums[lo] <= nums[mid]:
+                if nums[lo] <= target <= nums[mid]:
+                    hi = mid - 1
+                else:
+                    lo = mid + 1
+            # If the right half is sorted
+            else:
+                if nums[mid] <= target <= nums[hi]:
+                    lo = mid + 1
+                else:
+                    hi = mid - 1
+        
+        return -1

src/main/python/g0001_0100/s0033_search_in_rotated_sorted_array/readme.md

@@ -0,0 +1,91 @@
+33\. Search in Rotated Sorted Array
+
+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]`.
+
+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`.
+
+You must write an algorithm with `O(log n)` runtime complexity.
+
+**Example 1:**
+
+**Input:** nums = [4,5,6,7,0,1,2], target = 0
+
+**Output:** 4 
+
+**Example 2:**
+
+**Input:** nums = [4,5,6,7,0,1,2], target = 3
+
+**Output:** -1 
+
+**Example 3:**
+
+**Input:** nums = [1], target = 0
+
+**Output:** -1 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 5000`
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+*   All values of `nums` are **unique**.
+*   `nums` is an ascending array that is possibly rotated.
+*   <code>-10<sup>4</sup> <= target <= 10<sup>4</sup></code>
+
+To solve the "Search in Rotated Sorted Array" problem in Java with a `Solution` class, we can follow these steps:
+
+1. Define a `Solution` class.
+2. Define a method named `search` that takes an integer array `nums` and an integer `target` as input and returns an integer representing the index of `target` in `nums`. If `target` is not found, return `-1`.
+3. Implement the binary search algorithm to find the index of `target` in the rotated sorted array.
+4. Set the left pointer `left` to 0 and the right pointer `right` to the length of `nums` minus 1.
+5. While `left` is less than or equal to `right`:
+   - Calculate the middle index `mid` as `(left + right) / 2`.
+   - If `nums[mid]` is equal to `target`, return `mid`.
+   - Check if the left half of the array (`nums[left]` to `nums[mid]`) is sorted:
+     - If `nums[left] <= nums[mid]` and `nums[left] <= target < nums[mid]`, update `right = mid - 1`.
+     - Otherwise, update `left = mid + 1`.
+   - Otherwise, check if the right half of the array (`nums[mid]` to `nums[right]`) is sorted:
+     - If `nums[mid] <= nums[right]` and `nums[mid] < target <= nums[right]`, update `left = mid + 1`.
+     - Otherwise, update `right = mid - 1`.
+6. If `target` is not found, return `-1`.
+
+Here's the implementation:
+
+```java
+public class Solution {
+    public int search(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+        
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            
+            if (nums[mid] == target) {
+                return mid;
+            }
+            
+            if (nums[left] <= nums[mid]) {
+                if (nums[left] <= target && target < nums[mid]) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            } else {
+                if (nums[mid] < target && target <= nums[right]) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
+        }
+        
+        return -1;
+    }
+}
+```
+
+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).

src/main/python/g0001_0100/s0034_find_first_and_last_position_of_element_in_sorted_array/Solution.py

@@ -0,0 +1,23 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Binary_Search
+# #Algorithm_II_Day_1_Binary_Search #Binary_Search_I_Day_5 #Big_O_Time_O(log_n)_Space_O(1)
+# #2024_06_08_Time_64_ms_(97.49%)_Space_17.8_MB_(39.66%)
+
+class Solution:
+    def searchRange(self, nums: List[int], target: int) -> List[int]:
+        ans = [-1, -1]
+        ans[0] = self.helper(nums, target, False)
+        ans[1] = self.helper(nums, target, True)
+        return ans
+
+    def helper(self, nums: List[int], target: int, equals: bool) -> int:
+        l, r = 0, len(nums) - 1
+        result = -1
+        while l <= r:
+            mid = l + (r - l) // 2
+            if nums[mid] == target:
+                result = mid
+            if nums[mid] < target or (nums[mid] == target and equals):
+                l = mid + 1
+            else:
+                r = mid - 1
+        return result