Added tasks 48-72

Author: ThanhNIT

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

@@ -0,0 +1,24 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Math #Matrix
+# #Data_Structure_II_Day_3_Array #Programming_Skills_II_Day_7 #Udemy_2D_Arrays/Matrix
+# #Big_O_Time_O(n^2)_Space_O(1) #2024_06_08_Time_26_ms_(98.93%)_Space_16.5_MB_(91.88%)
+
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        n = len(matrix)
+        for i in range(n // 2):
+            for j in range(i, n - i - 1):
+                positions = [
+                    [i, j],
+                    [j, n - 1 - i],
+                    [n - 1 - i, n - 1 - j],
+                    [n - 1 - j, i]
+                ]
+                t = matrix[positions[0][0]][positions[0][1]]
+                for k in range(1, len(positions)):
+                    temp = matrix[positions[k][0]][positions[k][1]]
+                    matrix[positions[k][0]][positions[k][1]] = t
+                    t = temp
+                matrix[positions[0][0]][positions[0][1]] = t

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

@@ -0,0 +1,88 @@
+48\. Rotate Image
+
+Medium
+
+You are given an `n x n` 2D `matrix` representing an image, rotate the image by **90** degrees (clockwise).
+
+You have to rotate the image [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm), which means you have to modify the input 2D matrix directly. **DO NOT** allocate another 2D matrix and do the rotation.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/08/28/mat1.jpg)
+
+**Input:** matrix = [[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** [[7,4,1],[8,5,2],[9,6,3]] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/08/28/mat2.jpg)
+
+**Input:** matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+
+**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`
+*   `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;
+            }
+        }
+    }
+}
+```
+
+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.

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

@@ -0,0 +1,13 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #String #Hash_Table #Sorting
+# #Data_Structure_II_Day_8_String #Programming_Skills_II_Day_11 #Udemy_Strings
+# #Big_O_Time_O(n*k_log_k)_Space_O(n) #2024_06_08_Time_79_ms_(93.60%)_Space_19.6_MB_(76.55%)
+
+from collections import defaultdict
+
+class Solution:
+    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
+        anagram_groups = defaultdict(list)
+        for s in strs:
+            sorted_str = ''.join(sorted(s))
+            anagram_groups[sorted_str].append(s)
+        return list(anagram_groups.values())

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

@@ -0,0 +1,79 @@
+49\. Group Anagrams
+
+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.
+
+**Example 1:**
+
+**Input:** strs = ["eat","tea","tan","ate","nat","bat"]
+
+**Output:** [["bat"],["nat","tan"],["ate","eat","tea"]] 
+
+**Example 2:**
+
+**Input:** strs = [""]
+
+**Output:** [[""]] 
+
+**Example 3:**
+
+**Input:** strs = ["a"]
+
+**Output:** [["a"]] 
+
+**Constraints:**
+
+*   <code>1 <= strs.length <= 10<sup>4</sup></code>
+*   `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<>();
+        
+        // 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);
+            }
+        }
+        
+        // Return the values of the HashMap as the result
+        return new ArrayList<>(anagramGroups.values());
+    }
+}
+```
+
+This implementation ensures that all anagrams are grouped together efficiently using a HashMap.

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

@@ -0,0 +1,35 @@
+# #Hard #Top_100_Liked_Questions #Array #Backtracking #Big_O_Time_O(N!)_Space_O(N)
+# #2024_06_08_Time_31_ms_(99.90%)_Space_16.9_MB_(70.82%)
+
+class Solution:
+    def solveNQueens(self, n: int) -> List[List[str]]:
+        pos = [False] * (n + 2 * n - 1 + 2 * n - 1)
+        pos2 = [0] * n
+        ans = []
+        self.helper(n, 0, pos, pos2, ans)
+        return ans
+
+    def helper(self, n: int, row: int, pos: List[bool], pos2: List[int], ans: List[List[str]]):
+        if row == n:
+            self.construct(n, pos2, ans)
+            return
+        for i in range(n):
+            index = n + 2 * n - 1 + n - 1 + i - row
+            if pos[i] or pos[n + i + row] or pos[index]:
+                continue
+            pos[i] = True
+            pos[n + i + row] = True
+            pos[index] = True
+            pos2[row] = i
+            self.helper(n, row + 1, pos, pos2, ans)
+            pos[i] = False
+            pos[n + i + row] = False
+            pos[index] = False
+
+    def construct(self, n: int, pos: list[int], ans: list[list[str]]):
+        sol = []
+        for r in range(n):
+            queenRow = ['.'] * n
+            queenRow[pos[r]] = 'Q'
+            sol.append(''.join(queenRow))
+        ans.append(sol)

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

@@ -0,0 +1,108 @@
+51\. N-Queens
+
+Hard
+
+The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.
+
+Given an integer `n`, return _all distinct solutions to the **n-queens puzzle**_. You may return the answer in **any order**.
+
+Each solution contains a distinct board configuration of the n-queens' placement, where `'Q'` and `'.'` both indicate a queen and an empty space, respectively.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/queens.jpg)
+
+**Input:** n = 4
+
+**Output:** [[".Q..","...Q","Q...","..Q."],["..Q.","Q...","...Q",".Q.."]]
+
+**Explanation:** There exist two distinct solutions to the 4-queens puzzle as shown above 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** [["Q"]] 
+
+**Constraints:**
+
+*   `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;
+    }
+}
+```
+
+This implementation efficiently finds all distinct solutions to the N-Queens problem using backtracking.

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

@@ -0,0 +1,17 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming
+# #Divide_and_Conquer #Data_Structure_I_Day_1_Array #Dynamic_Programming_I_Day_5
+# #Udemy_Famous_Algorithm #Big_O_Time_O(n)_Space_O(1)
+# #2024_06_08_Time_501_ms_(83.84%)_Space_30.7_MB_(91.05%)
+
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        maxi = float('-inf')
+        sum_val = 0
+        for num in nums:
+            # calculating sub-array sum
+            sum_val += num
+            maxi = max(sum_val, maxi)
+            if sum_val < 0:
+                # there is no point to carry a -ve subarray sum. hence setting to 0
+                sum_val = 0
+        return maxi