Added tasks 73-98

Author: ThanhNIT

README.md

@@ -0,0 +1,48 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table #Matrix
+# #Udemy_2D_Arrays/Matrix #Big_O_Time_O(m*n)_Space_O(1)
+# #2024_06_09_Time_93_ms_(94.48%)_Space_17.4_MB_(67.69%)
+
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        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
+        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):
+                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:
+            for j in range(n):
+                matrix[0][j] = 0

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

@@ -0,0 +1,107 @@
+73\. Set Matrix Zeroes
+
+Medium
+
+Given an `m x n` integer matrix `matrix`, if an element is `0`, set its entire row and column to `0`'s, and return _the matrix_.
+
+You must do it [in place](https://en.wikipedia.org/wiki/In-place_algorithm).
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/17/mat1.jpg)
+
+**Input:** matrix = [[1,1,1],[1,0,1],[1,1,1]]
+
+**Output:** [[1,0,1],[0,0,0],[1,0,1]] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/08/17/mat2.jpg)
+
+**Input:** matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+
+**Output:** [[0,0,0,0],[0,4,5,0],[0,3,1,0]] 
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[0].length`
+*   `1 <= m, n <= 200`
+*   <code>-2<sup>31</sup> <= matrix[i][j] <= 2<sup>31</sup> - 1</code>
+
+**Follow up:**
+
+*   A straightforward solution using `O(mn)` space is probably a bad idea.
+*   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:
+
+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.
+
+Here's the implementation of the `setZeroes` method in Python:
+
+```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
+        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):
+                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:
+            for j in range(n):
+                matrix[0][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]]
+
+```
+
+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.

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

@@ -0,0 +1,23 @@
+# #Medium #Top_100_Liked_Questions #Array #Binary_Search #Matrix #Data_Structure_I_Day_5_Array
+# #Algorithm_II_Day_1_Binary_Search #Binary_Search_I_Day_8 #Level_2_Day_8_Binary_Search
+# #Udemy_2D_Arrays/Matrix #Big_O_Time_O(endRow+endCol)_Space_O(1)
+# #2024_06_09_Time_35_ms_(97.66%)_Space_17_MB_(69.27%)
+
+class Solution:
+    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
+        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

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

@@ -0,0 +1,76 @@
+74\. Search a 2D Matrix
+
+Medium
+
+Write an efficient algorithm that searches for a value in an `m x n` matrix. This matrix has the following properties:
+
+*   Integers in each row are sorted from left to right.
+*   The first integer of each row is greater than the last integer of the previous row.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/05/mat.jpg)
+
+**Input:** matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
+
+**Output:** true 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/10/05/mat2.jpg)
+
+**Input:** matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
+
+**Output:** false 
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `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:
+
+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`.
+
+Here's the implementation of the `searchMatrix` method in Python:
+
+```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
+
+# 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
+```
+
+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.

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

@@ -0,0 +1,24 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting #Two_Pointers
+# #Data_Structure_II_Day_2_Array #Udemy_Arrays #Big_O_Time_O(n)_Space_O(1)
+# #2024_06_09_Time_31_ms_(90.70%)_Space_16.4_MB_(80.54%)
+
+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

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

@@ -0,0 +1,84 @@
+75\. Sort Colors
+
+Medium
+
+Given an array `nums` with `n` objects colored red, white, or blue, sort them **[in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** so that objects of the same color are adjacent, with the colors in the order red, white, and blue.
+
+We will use the integers `0`, `1`, and `2` to represent the color red, white, and blue, respectively.
+
+You must solve this problem without using the library's sort function.
+
+**Example 1:**
+
+**Input:** nums = [2,0,2,1,1,0]
+
+**Output:** [0,0,1,1,2,2] 
+
+**Example 2:**
+
+**Input:** nums = [2,0,1]
+
+**Output:** [0,1,2] 
+
+**Example 3:**
+
+**Input:** nums = [0]
+
+**Output:** [0] 
+
+**Example 4:**
+
+**Input:** nums = [1]
+
+**Output:** [1] 
+
+**Constraints:**
+
+*   `n == nums.length`
+*   `1 <= n <= 300`
+*   `nums[i]` is `0`, `1`, or `2`.
+
+**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:
+
+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.
+
+Here's the implementation of the `sortColors` method in Python:
+
+```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
+            
+# 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]
+```
+
+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.