Improved tasks 73-98

Author: javadev

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

@@ -35,73 +35,48 @@ You must do it [in place](https://en.wikipedia.org/wiki/In-place_algorithm).
 *   A simple improvement uses `O(m + n)` space, but still not the best solution.
 *   Could you devise a constant space solution?
 
-To solve the "Set Matrix Zeroes" problem in Python with the Solution class, follow these steps:
+To solve this task using Python with a `Solution` class, you can follow these steps:
 
-1. Define a method `setZeroes` in the `Solution` class that takes a 2D integer matrix `matrix` as input and modifies it in place to set the entire row and column to zeros if an element is zero.
-2. Initialize two boolean arrays `rowZero` and `colZero` of size `m` and `n` respectively, where `m` is the number of rows in the matrix and `n` is the number of columns. These arrays will track whether a row or column needs to be set to zero.
-3. Iterate over the matrix to mark the rows and columns that contain zeros:
-   - If `matrix[i][j]` is zero, set `rowZero[i] = true` and `colZero[j] = true`.
-4. Iterate over the matrix again and set the entire row to zeros if `rowZero[i] = true` or the entire column to zeros if `colZero[j] = true`.
-5. Return the modified matrix.
+1. Define a class named `Solution`.
+2. Inside the class, define a method named `setZeroes` that takes `matrix` as an input parameter.
+3. Implement the logic to set entire rows and columns to zeros if any element in the row or column is zero.
+4. Use two boolean arrays `rows` and `cols` to keep track of which rows and columns need to be zeroed out.
+5. Iterate through the matrix and update the corresponding elements in the `rows` and `cols` arrays if any zero is encountered.
+6. Iterate through the matrix again and set the entire row to zeros if the corresponding `rows[i]` is True, and set the entire column to zeros if the corresponding `cols[j]` is True.
 
-Here's the implementation of the `setZeroes` method in Python:
+Here's the implementation:
 
 ```python
 class Solution:
     def setZeroes(self, matrix):
         """
         Do not return anything, modify matrix in-place instead.
         """
-        m = len(matrix)
-        n = len(matrix[0])
-        row0 = False
-        col0 = False
-
-        # Check if 0th column needs to be marked all 0s in future
+        m, n = len(matrix), len(matrix[0])
+        rows, cols = [False] * m, [False] * n
+        
+        # Mark which rows and columns contain zeros
         for i in range(m):
-            if matrix[i][0] == 0:
-                col0 = True
-                break
-
-        # Check if 0th row needs to be marked all 0s in future
-        for j in range(n):
-            if matrix[0][j] == 0:
-                row0 = True
-                break
-
-        # Store the signals in 0th row and column
-        for i in range(1, m):
-            for j in range(1, n):
+            for j in range(n):
                 if matrix[i][j] == 0:
-                    matrix[i][0] = 0
-                    matrix[0][j] = 0
-
-        # Mark 0 for all cells based on signal from 0th row and 0th column
-        for i in range(1, m):
-            for j in range(1, n):
-                if matrix[i][0] == 0 or matrix[0][j] == 0:
-                    matrix[i][j] = 0
-
-        # Set 0th column
-        if col0:
-            for i in range(m):
-                matrix[i][0] = 0
-
-        # Set 0th row
-        if row0:
+                    rows[i] = True
+                    cols[j] = True
+        
+        # Set entire rows and columns to zeros
+        for i in range(m):
             for j in range(n):
-                matrix[0][j] = 0
+                if rows[i] or cols[j]:
+                    matrix[i][j] = 0
 
 # Example usage:
-# sol = Solution()
-# matrix = [
-#     [1, 1, 1],
-#     [1, 0, 1],
-#     [1, 1, 1]
-# ]
-# sol.setZeroes(matrix)
-# print(matrix)  # Output should be [[1, 0, 1], [0, 0, 0], [1, 0, 1]]
-
+solution = Solution()
+matrix1 = [[1,1,1],[1,0,1],[1,1,1]]
+solution.setZeroes(matrix1)
+print(matrix1)  # Output: [[1,0,1],[0,0,0],[1,0,1]] 
+
+matrix2 = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+solution.setZeroes(matrix2)
+print(matrix2)  # Output: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
 ```
 
-This implementation modifies the matrix in place to set entire rows and columns to zeros, with a time complexity of O(m * n) and a space complexity of O(m + n), where `m` is the number of rows and `n` is the number of columns in the matrix.
+This solution has a time complexity of O(m * n), where m is the number of rows and n is the number of columns in the matrix. It modifies the matrix in-place, fulfilling the requirement of the task.

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

@@ -30,47 +30,45 @@ Write an efficient algorithm that searches for a value in an `m x n` matrix. Thi
 *   `1 <= m, n <= 100`
 *   <code>-10<sup>4</sup> <= matrix[i][j], target <= 10<sup>4</sup></code>
 
-To solve the "Search a 2D Matrix" problem in Python with the Solution class, follow these steps:
+To solve this task using Python with a `Solution` class, you can follow these steps:
 
-1. Define a method `searchMatrix` in the `Solution` class that takes a 2D integer matrix `matrix` and an integer `target` as input and returns `true` if the target value is found in the matrix, otherwise returns `false`.
-2. Initialize two pointers `row` and `col` to start at the top-right corner of the matrix. `row` starts from 0 and `col` starts from the last column.
-3. Loop until `row` is less than the number of rows in the matrix and `col` is greater than or equal to 0:
-   - If `matrix[row][col]` is equal to the target, return `true`.
-   - If `matrix[row][col]` is greater than the target, decrement `col`.
-   - If `matrix[row][col]` is less than the target, increment `row`.
-4. If the target is not found after the loop, return `false`.
+1. Define a class named `Solution`.
+2. Inside the class, define a method named `searchMatrix` that takes `matrix` and `target` as input parameters.
+3. Implement the efficient algorithm to search for the target value in the matrix.
+4. Use a binary search approach to efficiently find the target value.
+5. Start the binary search from the top-right corner of the matrix.
+6. If the current element is equal to the target, return True.
+7. If the current element is greater than the target, move left in the same row.
+8. If the current element is less than the target, move down to the next row.
+9. Repeat steps 6-8 until the entire matrix is traversed.
+10. If the target is not found, return False.
 
-Here's the implementation of the `searchMatrix` method in Python:
+Here's the implementation:
 
 ```python
 class Solution:
     def searchMatrix(self, matrix, target):
-        endRow = len(matrix)
-        endCol = len(matrix[0])
-        targetRow = 0
-        result = False
-
-        for i in range(endRow):
-            if matrix[i][endCol - 1] >= target:
-                targetRow = i
-                break
-
-        for i in range(endCol):
-            if matrix[targetRow][i] == target:
-                result = True
-                break
-
-        return result
+        if not matrix or not matrix[0]:
+            return False
+        
+        rows, cols = len(matrix), len(matrix[0])
+        row, col = 0, cols - 1
+        
+        while row < rows and col >= 0:
+            if matrix[row][col] == target:
+                return True
+            elif matrix[row][col] < target:
+                row += 1
+            else:
+                col -= 1
+        
+        return False
 
 # Example usage:
-# sol = Solution()
-# matrix = [
-#     [1, 3, 5, 7],
-#     [10, 11, 16, 20],
-#     [23, 30, 34, 60]
-# ]
-# target = 3
-# print(sol.searchMatrix(matrix, target))  # Output should be True
+solution = Solution()
+matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]]
+print(solution.searchMatrix(matrix, 3))   # Output: True
+print(solution.searchMatrix(matrix, 13))  # Output: False
 ```
 
-This implementation searches for the target value efficiently in the given matrix by starting from the top-right corner and moving either left or down based on the comparison with the target value. The time complexity of this solution is O(m + n), where m is the number of rows and n is the number of columns in the matrix.
+This solution has a time complexity of O(m + n), where m is the number of rows and n is the number of columns in the matrix. It efficiently searches for the target value by starting the search from the top-right corner and making decisions to move left or down based on the comparison with the current element.

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

@@ -40,45 +40,54 @@ You must solve this problem without using the library's sort function.
 
 **Follow up:** Could you come up with a one-pass algorithm using only constant extra space?
 
-To solve the "Sort Colors" problem in Python with the Solution class, follow these steps:
+To solve this task using Python with a `Solution` class, you can follow these steps:
 
-1. Define a method `sortColors` in the `Solution` class that takes an array of integers `nums` as input and sorts it in-place according to the colors red, white, and blue.
-2. Initialize three pointers: `low`, `mid`, and `high`. `low` points to the beginning of the array, `mid` points to the current element being processed, and `high` points to the end of the array.
-3. Loop while `mid` is less than or equal to `high`:
-   - If `nums[mid]` is 0, swap `nums[low]` with `nums[mid]`, increment `low` and `mid`.
-   - If `nums[mid]` is 1, increment `mid`.
-   - If `nums[mid]` is 2, swap `nums[mid]` with `nums[high]`, decrement `high`.
-4. After the loop, the array will be sorted in-place according to the colors red, white, and blue.
+1. Define a class named `Solution`.
+2. Inside the class, define a method named `sortColors` that takes `nums` as an input parameter.
+3. Implement the one-pass algorithm to sort the colors in-place.
+4. Use three pointers: `left`, `right`, and `curr`.
+5. Initialize `left` to 0, `right` to `len(nums) - 1`, and `curr` to 0.
+6. Iterate through the array while `curr` is less than or equal to `right`.
+7. If `nums[curr]` is 0, swap `nums[curr]` with `nums[left]`, increment both `left` and `curr`.
+8. If `nums[curr]` is 2, swap `nums[curr]` with `nums[right]`, decrement `right`.
+9. If `nums[curr]` is 1, simply increment `curr`.
+10. Repeat steps 6-9 until `curr` is greater than `right`.
 
-Here's the implementation of the `sortColors` method in Python:
+Here's the implementation:
 
 ```python
 class Solution:
-    def sortColors(self, nums: List[int]) -> None:
-        """
-        Do not return anything, modify nums in-place instead.
-        """
-        zeroes = 0
-        ones = 0
-
-        for i in range(len(nums)):
-            if nums[i] == 0:
-                nums[zeroes] = 0
-                zeroes += 1
-            elif nums[i] == 1:
-                ones += 1
-
-        for j in range(zeroes, zeroes + ones):
-            nums[j] = 1
-
-        for k in range(zeroes + ones, len(nums)):
-            nums[k] = 2
-            
+    def sortColors(self, nums):
+        left, right, curr = 0, len(nums) - 1, 0
+        
+        while curr <= right:
+            if nums[curr] == 0:
+                nums[curr], nums[left] = nums[left], nums[curr]
+                left += 1
+                curr += 1
+            elif nums[curr] == 2:
+                nums[curr], nums[right] = nums[right], nums[curr]
+                right -= 1
+            else:
+                curr += 1
+
 # Example usage:
-# sol = Solution()
-# nums = [2, 0, 2, 1, 1, 0]
-# sol.sortColors(nums)
-# print(nums)  # Output should be [0, 0, 1, 1, 2, 2]
+solution = Solution()
+nums1 = [2,0,2,1,1,0]
+solution.sortColors(nums1)
+print(nums1)  # Output: [0,0,1,1,2,2] 
+
+nums2 = [2,0,1]
+solution.sortColors(nums2)
+print(nums2)  # Output: [0,1,2] 
+
+nums3 = [0]
+solution.sortColors(nums3)
+print(nums3)  # Output: [0] 
+
+nums4 = [1]
+solution.sortColors(nums4)
+print(nums4)  # Output: [1] 
 ```
 
-This implementation sorts the array in-place using a one-pass algorithm with constant extra space. It iterates through the array and swaps elements as needed to group them according to their colors. The time complexity of this solution is O(n), where n is the length of the array.
+This solution sorts the colors in-place using a one-pass algorithm with constant extra space. It traverses the array only once, so the time complexity is O(n), where n is the length of the array `nums`.

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

@@ -41,56 +41,55 @@ A **substring** is a contiguous sequence of characters within the string.
 
 **Follow up:** Could you find an algorithm that runs in `O(m + n)` time?
 
-To solve the "Minimum Window Substring" problem in Python with the Solution class, follow these steps:
-
-1. Define a method `minWindow` in the `Solution` class that takes two strings `s` and `t` as input and returns the minimum window substring of `s` containing all characters from `t`.
-2. Create two frequency maps: `tFreqMap` to store the frequency of characters in string `t`, and `sFreqMap` to store the frequency of characters in the current window of string `s`.
-3. Initialize two pointers `left` and `right` to track the window boundaries. Initialize a variable `minLength` to store the minimum window length found so far.
-4. Iterate over string `s` using the `right` pointer until the end of the string:
-   - Update the frequency map `sFreqMap` for the character at index `right`.
-   - Check if the current window contains all characters from `t`. If it does, move the `left` pointer to minimize the window while maintaining the condition.
-   - Update the `minLength` if the current window length is smaller.
-   - Move the `right` pointer to expand the window.
-5. Return the minimum window substring found, or an empty string if no such substring exists.
-
-Here's the implementation of the `minWindow` method in Python:
+To solve this task using Python with a `Solution` class, you can follow these steps:
+
+1. Define a class named `Solution`.
+2. Inside the class, define a method named `minWindow` that takes `s` and `t` as input parameters.
+3. Implement an algorithm to find the minimum window substring of `s` that contains all characters of `t`.
+4. Use a sliding window approach to efficiently search for the minimum window substring.
+5. Create a dictionary `t_count` to store the frequency of characters in string `t`.
+6. Initialize variables `left` and `right` to keep track of the window boundaries.
+7. Initialize variables `min_window_start` and `min_window_length` to store the starting index and length of the minimum window substring found so far.
+8. Iterate through string `s` using the right pointer (`right`), and update the character frequencies in a temporary dictionary `window_count`.
+9. When all characters of `t` are found in the current window, update `min_window_start` and `min_window_length` if the current window is smaller than the minimum window found so far.
+10. Move the left pointer (`left`) to shrink the window until the window no longer contains all characters of `t`.
+11. Repeat steps 8-10 until the right pointer reaches the end of `s`.
+12. Return the minimum window substring found, or an empty string if no such substring exists.
+
+Here's the implementation:
 
 ```python
 class Solution:
     def minWindow(self, s: str, t: str) -> str:
-        from collections import Counter
-
-        map = [0] * 128
+        t_count = {}
         for char in t:
-            map[ord(char) - ord('A')] += 1
-
-        count = len(t)
-        begin = 0
-        end = 0
-        d = float('inf')
-        head = 0
-
-        while end < len(s):
-            if map[ord(s[end]) - ord('A')] > 0:
-                count -= 1
-            map[ord(s[end]) - ord('A')] -= 1
-            end += 1
-
-            while count == 0:
-                if end - begin < d:
-                    d = end - begin
-                    head = begin
-                map[ord(s[begin]) - ord('A')] += 1
-                if map[ord(s[begin]) - ord('A')] > 0:
-                    count += 1
-                begin += 1
-
-        return "" if d == float('inf') else s[head:head + d]
+            t_count[char] = t_count.get(char, 0) + 1
+        
+        left, right = 0, 0
+        min_window_start = 0
+        min_window_length = float('inf')
+        required_chars = len(t)
+        
+        while right < len(s):
+            if s[right] in t_count:
+                if t_count[s[right]] > 0:
+                    required_chars -= 1
+                t_count[s[right]] -= 1
+            
+            while required_chars == 0:
+                if right - left + 1 < min_window_length:
+                    min_window_length = right - left + 1
+                    min_window_start = left
+                
+                if s[left] in t_count:
+                    t_count[s[left]] += 1
+                    if t_count[s[left]] > 0:
+                        required_chars += 1
+                left += 1
+            
+            right += 1
 
-# Example usage:
-# sol = Solution()
-# result = sol.minWindow("ADOBECODEBANC", "ABC")
-# print(result)  # Output should be "BANC"
+        return s[min_window_start:min_window_start + min_window_length] if min_window_length != float('inf') else ""
 ```
 
-This implementation finds the minimum window substring in `O(m + n)` time complexity, where `m` is the length of string `s` and `n` is the length of string `t`. It uses two frequency maps to keep track of character frequencies and adjusts the window boundaries to find the minimum window containing all characters from `t`.
+This solution uses a sliding window approach to efficiently search for the minimum window substring. It iterates through the string `s` only once, so the time complexity is O(m + n), where m is the length of `s` and n is the length of `t`.