Improved tasks 48-72

Author: javadev

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

@@ -41,48 +41,66 @@ You have to rotate the image [**in-place**](https://en.wikipedia.org/wiki/In-pla
 *   `1 <= n <= 20`
 *   `-1000 <= matrix[i][j] <= 1000`
 
-To solve the "Rotate Image" problem in Java with a `Solution` class, we can follow these steps:
-
-1. Define a `Solution` class.
-2. Define a method named `rotate` that takes a 2D array `matrix` representing an image as input and rotates the image by 90 degrees clockwise.
-3. Determine the number of layers in the matrix, which is equal to half of the matrix's size.
-4. Iterate through each layer from outer to inner layers.
-5. For each layer:
-   - Iterate through each element in the current layer.
-   - Swap the elements of the current layer in a clockwise manner.
-6. Return the rotated matrix.
-
-Here's the implementation:
-
-```java
-public class Solution {
-    public void rotate(int[][] matrix) {
-        int n = matrix.length;
-        int layers = n / 2;
-
-        for (int layer = 0; layer < layers; layer++) {
-            int first = layer;
-            int last = n - 1 - layer;
-            
-            for (int i = first; i < last; i++) {
-                int offset = i - first;
-                int top = matrix[first][i];
-                
-                // Move left to top
-                matrix[first][i] = matrix[last - offset][first];
-                
-                // Move bottom to left
-                matrix[last - offset][first] = matrix[last][last - offset];
-                
-                // Move right to bottom
-                matrix[last][last - offset] = matrix[i][last];
-                
-                // Move top to right
-                matrix[i][last] = top;
-            }
-        }
-    }
-}
+To solve the "Rotate Image" problem, you can perform the rotation in-place by swapping elements of the matrix. Here are the steps to solve the problem:
+
+### Approach:
+
+1. **Transpose the Matrix:**
+   - Transpose the matrix by swapping `matrix[i][j]` with `matrix[j][i]` for all `i` and `j` where `i < j`.
+
+2. **Reverse Each Row:**
+   - Reverse each row of the transposed matrix to get the final rotated matrix.
+
+### Python Code:
+
+```python
+class Solution:
+    def rotate(self, matrix):
+        n = len(matrix)
+        
+        # Transpose the matrix
+        for i in range(n):
+            for j in range(i + 1, n):
+                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
+        
+        # Reverse each row
+        for i in range(n):
+            matrix[i] = matrix[i][::-1]
+
+# Example Usage:
+solution = Solution()
+
+# Example 1:
+matrix1 = [
+    [1,2,3],
+    [4,5,6],
+    [7,8,9]
+]
+solution.rotate(matrix1)
+print(matrix1)  # Output: [[7,4,1],[8,5,2],[9,6,3]]
+
+# Example 2:
+matrix2 = [
+    [5,1,9,11],
+    [2,4,8,10],
+    [13,3,6,7],
+    [15,14,12,16]
+]
+solution.rotate(matrix2)
+print(matrix2)  # Output: [[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
+
+# Example 3:
+matrix3 = [[1]]
+solution.rotate(matrix3)
+print(matrix3)  # Output: [[1]]
+
+# Example 4:
+matrix4 = [
+    [1,2],
+    [3,4]
+]
+solution.rotate(matrix4)
+print(matrix4)  # Output: [[3,1],[4,2]]
 ```
 
-This implementation provides a solution to the "Rotate Image" problem in Java. It rotates the given 2D matrix representing an image by 90 degrees clockwise in-place.
+This code defines a `Solution` class with a `rotate` method to rotate the given matrix by 90 degrees clockwise. The example usage demonstrates how to create an instance of the `Solution` class and call the `rotate` method with different input matrices.

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

@@ -30,50 +30,57 @@ An **Anagram** is a word or phrase formed by rearranging the letters of a differ
 *   `0 <= strs[i].length <= 100`
 *   `strs[i]` consists of lowercase English letters.
 
-To solve the "Group Anagrams" problem in Java with the Solution class, follow these steps:
-
-1. Define a method `groupAnagrams` in the `Solution` class that takes an array of strings `strs` as input and returns a list of lists of strings.
-2. Initialize an empty HashMap to store the groups of anagrams. The key will be the sorted string, and the value will be a list of strings.
-3. Iterate through each string `str` in the input array `strs`.
-4. Sort the characters of the current string `str` to create a key for the HashMap.
-5. Check if the sorted string exists as a key in the HashMap:
-   - If it does, add the original string `str` to the corresponding list of strings.
-   - If it doesn't, create a new entry in the HashMap with the sorted string as the key and a new list containing `str` as the value.
-6. After iterating through all strings, return the values of the HashMap as the result.
-
-Here's the implementation of the `groupAnagrams` method in Java:
-
-```java
-import java.util.*;
-
-class Solution {
-    public List<List<String>> groupAnagrams(String[] strs) {
-        // Initialize a HashMap to store the groups of anagrams
-        Map<String, List<String>> anagramGroups = new HashMap<>();
+To solve the "Group Anagrams" problem, you can use a hash table to group the anagrams together based on their sorted representations. Here are the steps to solve the problem:
+
+### Approach:
+
+1. **Initialize a Hash Table:**
+   - Initialize an empty dictionary to store the groups of anagrams. The keys of the dictionary will be the sorted representations of the words, and the values will be lists containing the original words.
+
+2. **Iterate Through the Strings:**
+   - Iterate through each string in the given array `strs`.
+
+3. **Sort Each String:**
+   - For each string, sort its characters alphabetically to get its sorted representation.
+
+4. **Group Anagrams:**
+   - Use the sorted representation as the key in the dictionary and append the original word to the corresponding list in the dictionary.
+
+5. **Return the Groups:**
+   - Return the values of the dictionary, which contain the groups of anagrams.
+
+### Python Code:
+
+```python
+from collections import defaultdict
+
+class Solution:
+    def groupAnagrams(self, strs):
+        # Initialize a dictionary to store groups of anagrams
+        groups = defaultdict(list)
 
-        // Iterate through each string in the input array
-        for (String str : strs) {
-            // Sort the characters of the current string
-            char[] chars = str.toCharArray();
-            Arrays.sort(chars);
-            String sortedStr = new String(chars);
-            
-            // Check if the sorted string exists as a key in the HashMap
-            if (anagramGroups.containsKey(sortedStr)) {
-                // If it does, add the original string to the corresponding list
-                anagramGroups.get(sortedStr).add(str);
-            } else {
-                // If it doesn't, create a new entry in the HashMap
-                List<String> group = new ArrayList<>();
-                group.add(str);
-                anagramGroups.put(sortedStr, group);
-            }
-        }
+        # Group anagrams based on their sorted representations
+        for word in strs:
+            sorted_word = ''.join(sorted(word))
+            groups[sorted_word].append(word)
 
-        // Return the values of the HashMap as the result
-        return new ArrayList<>(anagramGroups.values());
-    }
-}
+        # Return the groups of anagrams
+        return list(groups.values())
+
+# Example Usage:
+solution = Solution()
+
+# Example 1:
+strs1 = ["eat","tea","tan","ate","nat","bat"]
+print(solution.groupAnagrams(strs1))  # Output: [["eat","tea","ate"],["tan","nat"],["bat"]]
+
+# Example 2:
+strs2 = [""]
+print(solution.groupAnagrams(strs2))  # Output: [[""]]
+
+# Example 3:
+strs3 = ["a"]
+print(solution.groupAnagrams(strs3))  # Output: [["a"]]
 ```
 
-This implementation ensures that all anagrams are grouped together efficiently using a HashMap.
+This code defines a `Solution` class with a `groupAnagrams` method to group the anagrams together. The example usage demonstrates how to create an instance of the `Solution` class and call the `groupAnagrams` method with different input arrays of strings.

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

@@ -28,81 +28,72 @@ Each solution contains a distinct board configuration of the n-queens' placement
 
 *   `1 <= n <= 9`
 
-To solve the "N-Queens" problem in Java with the Solution class, follow these steps:
-
-1. Define a method `solveNQueens` in the `Solution` class that takes an integer `n` as input and returns a list of lists of strings.
-2. Initialize a board represented as a 2D character array of size `n x n`. Initialize all cells to `'.'`, indicating an empty space.
-3. Define a recursive backtracking function `backtrack` to explore all possible configurations of queens on the board.
-4. In the `backtrack` function:
-   - Base case: If the current row index `row` is equal to `n`, it means we have successfully placed `n` queens on the board. Add the current board configuration to the result.
-   - Iterate through each column index `col` from `0` to `n - 1`:
-     - Check if it's safe to place a queen at position `(row, col)` by calling a helper function `isSafe`.
-     - If it's safe, place a queen at position `(row, col)` on the board, mark it as `'Q'`.
-     - Recur to the next row by calling `backtrack(row + 1)`.
-     - Backtrack: After exploring all possibilities, remove the queen from position `(row, col)` by marking it as `'.'`.
-5. In the `solveNQueens` method, initialize an empty list `result` to store the solutions.
-6. Call the `backtrack` function with initial parameters `0` for the row index.
-7. Return the `result` list containing all distinct solutions.
-
-Here's the implementation of the `solveNQueens` method in Java:
-
-```java
-import java.util.*;
-
-class Solution {
-    public List<List<String>> solveNQueens(int n) {
-        List<List<String>> result = new ArrayList<>();
-        char[][] board = new char[n][n];
-        for (int i = 0; i < n; i++) {
-            Arrays.fill(board[i], '.');
-        }
-        backtrack(board, 0, result);
-        return result;
-    }
-    
-    private void backtrack(char[][] board, int row, List<List<String>> result) {
-        int n = board.length;
-        if (row == n) {
-            result.add(constructBoard(board));
-            return;
-        }
-        for (int col = 0; col < n; col++) {
-            if (isSafe(board, row, col)) {
-                board[row][col] = 'Q';
-                backtrack(board, row + 1, result);
-                board[row][col] = '.';
-            }
-        }
-    }
-    
-    private boolean isSafe(char[][] board, int row, int col) {
-        int n = board.length;
-        for (int i = 0; i < row; i++) {
-            if (board[i][col] == 'Q') {
-                return false;
-            }
-        }
-        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
-            if (board[i][j] == 'Q') {
-                return false;
-            }
-        }
-        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
-            if (board[i][j] == 'Q') {
-                return false;
-            }
-        }
-        return true;
-    }
-    
-    private List<String> constructBoard(char[][] board) {
-        List<String> solution = new ArrayList<>();
-        for (char[] row : board) {
-            solution.add(new String(row));
-        }
-        return solution;
-    }
-}
+To solve the N-Queens problem, which involves placing N queens on an N x N chessboard without attacking each other, you can use backtracking. Here are the steps to solve the problem:
+
+### Approach:
+
+1. **Initialize the Chessboard:**
+   - Initialize an empty N x N chessboard grid.
+
+2. **Backtracking Function:**
+   - Define a backtracking function to recursively explore all possible queen placements.
+
+3. **Base Case:**
+   - If all queens are placed (i.e., row index equals N), add the current configuration to the list of solutions.
+
+4. **Try Placing Queen:**
+   - For the current row, try placing the queen in each column (0 to N-1).
+   - If placing the queen at the current position is safe (i.e., not attacking any other queen), mark the cell as a queen ('Q') and recursively move to the next row.
+
+5. **Backtrack:**
+   - After exploring all possibilities from the current position, backtrack by removing the queen from the current position and try the next column.
+
+6. **Return Solutions:**
+   - Return the list of all distinct solutions found.
+
+### Python Code:
+
+```python
+class Solution:
+    def solveNQueens(self, n):
+        def is_safe(row, col):
+            # Check for queens in the same column
+            for i in range(row):
+                if board[i][col] == 'Q':
+                    return False
+            
+            # Check for queens in the upper-left diagonal
+            for i, j in zip(range(row-1, -1, -1), range(col-1, -1, -1)):
+                if board[i][j] == 'Q':
+                    return False
+            
+            # Check for queens in the upper-right diagonal
+            for i, j in zip(range(row-1, -1, -1), range(col+1, n)):
+                if board[i][j] == 'Q':
+                    return False
+            
+            return True
+        
+        def backtrack(row):
+            if row == n:
+                solutions.append([''.join(row) for row in board])
+                return
+            
+            for col in range(n):
+                if is_safe(row, col):
+                    board[row][col] = 'Q'
+                    backtrack(row + 1)
+                    board[row][col] = '.'
+        
+        board = [['.' for _ in range(n)] for _ in range(n)]
+        solutions = []
+        backtrack(0)
+        return solutions
+
+# Example Usage:
+solution = Solution()
+print(solution.solveNQueens(4))  # Output: [[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
+print(solution.solveNQueens(1))  # Output: [["Q"]]
 ```
 
-This implementation efficiently finds all distinct solutions to the N-Queens problem using backtracking.
+This code defines a `Solution` class with a `solveNQueens` method to find all distinct solutions to the N-Queens puzzle. The example usage demonstrates how to create an instance of the `Solution` class and call the `solveNQueens` method with different values of `n`.