Added tasks 11-25

Author: ThanhNIT

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

@@ -0,0 +1,17 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Greedy #Two_Pointers
+# #Algorithm_II_Day_4_Two_Pointers #Big_O_Time_O(n)_Space_O(1)
+# #2024_06_04_Time_488_ms_(91.81%)_Space_29.5_MB_(60.76%)
+
+class Solution:
+    def maxArea(self, height):
+        max_area = -1
+        left = 0
+        right = len(height) - 1
+        while left < right:
+            if height[left] < height[right]:
+                max_area = max(max_area, height[left] * (right - left))
+                left += 1
+            else:
+                max_area = max(max_area, height[right] * (right - left))
+                right -= 1
+        return max_area

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

@@ -0,0 +1,97 @@
+11\. Container With Most Water
+
+Medium
+
+Given `n` non-negative integers <code>a<sub>1</sub>, a<sub>2</sub>, ..., a<sub>n</sub></code> , where each represents a point at coordinate <code>(i, a<sub>i</sub>)</code>. `n` vertical lines are drawn such that the two endpoints of the line `i` is at <code>(i, a<sub>i</sub>)</code> and `(i, 0)`. Find two lines, which, together with the x-axis forms a container, such that the container contains the most water.
+
+**Notice** that you may not slant the container.
+
+**Example 1:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/07/17/question_11.jpg)
+
+**Input:** height = [1,8,6,2,5,4,8,3,7]
+
+**Output:** 49
+
+**Explanation:** The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49. 
+
+**Example 2:**
+
+**Input:** height = [1,1]
+
+**Output:** 1 
+
+**Example 3:**
+
+**Input:** height = [4,3,2,1,4]
+
+**Output:** 16 
+
+**Example 4:**
+
+**Input:** height = [1,2,1]
+
+**Output:** 2 
+
+**Constraints:**
+
+*   `n == height.length`
+*   <code>2 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= height[i] <= 10<sup>4</sup></code>
+
+To solve the Container With Most Water problem in Java using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `maxArea` that takes an array of integers `height` as input and returns the maximum area of water that can be contained.
+2. Initialize two pointers, `left` pointing to the start of the array and `right` pointing to the end of the array.
+3. Initialize a variable `maxArea` to store the maximum area encountered so far, initially set to 0.
+4. Iterate while `left` is less than `right`.
+5. Calculate the current area using the formula: `(right - left) * min(height[left], height[right])`.
+6. Update `maxArea` if the current area is greater than `maxArea`.
+7. Move the pointer pointing to the smaller height towards the other pointer. If `height[left] < height[right]`, increment `left`, otherwise decrement `right`.
+8. Continue the iteration until `left` becomes greater than or equal to `right`.
+9. Return `maxArea`.
+
+Here's the implementation:
+
+```java
+public class Solution {
+    public int maxArea(int[] height) {
+        int left = 0;
+        int right = height.length - 1;
+        int maxArea = 0;
+
+        while (left < right) {
+            int currentArea = (right - left) * Math.min(height[left], height[right]);
+            maxArea = Math.max(maxArea, currentArea);
+
+            if (height[left] < height[right]) {
+                left++;
+            } else {
+                right--;
+            }
+        }
+
+        return maxArea;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+
+        // Test cases
+        int[] height1 = {1, 8, 6, 2, 5, 4, 8, 3, 7};
+        System.out.println("Example 1 Output: " + solution.maxArea(height1));
+
+        int[] height2 = {1, 1};
+        System.out.println("Example 2 Output: " + solution.maxArea(height2));
+
+        int[] height3 = {4, 3, 2, 1, 4};
+        System.out.println("Example 3 Output: " + solution.maxArea(height3));
+
+        int[] height4 = {1, 2, 1};
+        System.out.println("Example 4 Output: " + solution.maxArea(height4));
+    }
+}
+```
+
+This implementation provides a solution to the Container With Most Water problem in Java.

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

@@ -0,0 +1,36 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting #Two_Pointers
+# #Data_Structure_II_Day_1_Array #Algorithm_II_Day_3_Two_Pointers #Udemy_Two_Pointers
+# #Big_O_Time_O(n*log(n))_Space_O(n^2) #2024_06_04_Time_683_ms_(63.27%)_Space_20.8_MB_(49.61%)
+
+class Solution:
+    def threeSum(self, nums):
+        nums.sort()
+        result = []
+        length = len(nums)
+
+        for i in range(length - 2):
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left = i + 1
+            right = length - 1
+
+            while left < right:
+                total = nums[i] + nums[left] + nums[right]
+
+                if total < 0:
+                    left += 1
+                elif total > 0:
+                    right -= 1
+                else:
+                    result.append([nums[i], nums[left], nums[right]])
+
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+
+                    left += 1
+                    right -= 1
+
+        return result

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

@@ -0,0 +1,109 @@
+15\. 3Sum
+
+Medium
+
+Given an integer array nums, return all the triplets `[nums[i], nums[j], nums[k]]` such that `i != j`, `i != k`, and `j != k`, and `nums[i] + nums[j] + nums[k] == 0`.
+
+Notice that the solution set must not contain duplicate triplets.
+
+**Example 1:**
+
+**Input:** nums = [-1,0,1,2,-1,-4]
+
+**Output:** [[-1,-1,2],[-1,0,1]] 
+
+**Example 2:**
+
+**Input:** nums = []
+
+**Output:** [] 
+
+**Example 3:**
+
+**Input:** nums = [0]
+
+**Output:** [] 
+
+**Constraints:**
+
+*   `0 <= nums.length <= 3000`
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>
+
+To solve the 3Sum problem in Java using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `threeSum` that takes an array of integers `nums` as input and returns a list of lists representing the triplets that sum up to zero.
+2. Sort the input array `nums` to ensure that duplicate triplets are avoided.
+3. Initialize an empty list `result` to store the triplets.
+4. Iterate over the elements of the sorted array `nums` up to the second to last element.
+5. Within the outer loop, initialize two pointers, `left` and `right`, where `left` starts at the next element after the current element and `right` starts at the last element of the array.
+6. While `left` is less than `right`, check if the sum of the current element (`nums[i]`), `nums[left]`, and `nums[right]` equals zero.
+7. If the sum is zero, add `[nums[i], nums[left], nums[right]]` to the `result` list.
+8. Move the `left` pointer to the right (increment `left`) and the `right` pointer to the left (decrement `right`).
+9. If the sum is less than zero, increment `left`.
+10. If the sum is greater than zero, decrement `right`.
+11. After the inner loop finishes, increment the outer loop index while skipping duplicates.
+12. Return the `result` list containing all the valid triplets.
+
+Here's the implementation:
+
+```java
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution {
+    public List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> result = new ArrayList<>();
+
+        for (int i = 0; i < nums.length - 2; i++) {
+            if (i > 0 && nums[i] == nums[i - 1]) {
+                continue; // Skip duplicates
+            }
+
+            int left = i + 1;
+            int right = nums.length - 1;
+
+            while (left < right) {
+                int sum = nums[i] + nums[left] + nums[right];
+                if (sum == 0) {
+                    result.add(Arrays.asList(nums[i], nums[left], nums[right]));
+
+                    // Skip duplicates
+                    while (left < right && nums[left] == nums[left + 1]) {
+                        left++;
+                    }
+                    while (left < right && nums[right] == nums[right - 1]) {
+                        right--;
+                    }
+
+                    left++;
+                    right--;
+                } else if (sum < 0) {
+                    left++;
+                } else {
+                    right--;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+
+        // Test cases
+        int[] nums1 = {-1, 0, 1, 2, -1, -4};
+        System.out.println("Example 1 Output: " + solution.threeSum(nums1));
+
+        int[] nums2 = {};
+        System.out.println("Example 2 Output: " + solution.threeSum(nums2));
+
+        int[] nums3 = {0};
+        System.out.println("Example 3 Output: " + solution.threeSum(nums3));
+    }
+}
+```
+
+This implementation provides a solution to the 3Sum problem in Java.

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

@@ -0,0 +1,25 @@
+# #Medium #Top_100_Liked_Questions #Top_Interview_Questions #String #Hash_Table #Backtracking
+# #Algorithm_II_Day_11_Recursion_Backtracking #Udemy_Backtracking/Recursion
+# #Big_O_Time_O(4^n)_Space_O(n) #2024_06_04_Time_28_ms_(91.85%)_Space_16.5_MB_(84.41%)
+
+class Solution:
+    def letterCombinations(self, digits):
+        if not digits:
+            return []
+
+        letters = ["", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"]
+        ans = []
+        self.findCombinations(0, digits, letters, [], ans)
+        return ans
+
+    def findCombinations(self, start, digits, letters, curr, ans):
+        if len(curr) == len(digits):
+            ans.append("".join(curr))
+            return
+
+        for i in range(start, len(digits)):
+            n = int(digits[i])
+            for ch in letters[n]:
+                curr.append(ch)
+                self.findCombinations(i + 1, digits, letters, curr, ans)
+                curr.pop()

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

@@ -0,0 +1,105 @@
+17\. Letter Combinations of a Phone Number
+
+Medium
+
+Given a string containing digits from `2-9` inclusive, return all possible letter combinations that the number could represent. Return the answer in **any order**.
+
+A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.
+
+![](https://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/200px-Telephone-keypad2.svg.png)
+
+**Example 1:**
+
+**Input:** digits = "23"
+
+**Output:** ["ad","ae","af","bd","be","bf","cd","ce","cf"] 
+
+**Example 2:**
+
+**Input:** digits = ""
+
+**Output:** [] 
+
+**Example 3:**
+
+**Input:** digits = "2"
+
+**Output:** ["a","b","c"] 
+
+**Constraints:**
+
+*   `0 <= digits.length <= 4`
+*   `digits[i]` is a digit in the range `['2', '9']`.
+
+To solve the Letter Combinations of a Phone Number problem in Java using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `letterCombinations` that takes a string `digits` as input and returns a list of all possible letter combinations.
+2. Create a mapping of digits to letters using a hashmap or an array.
+3. Initialize an empty list `result` to store the combinations.
+4. If the input string `digits` is empty, return an empty list `result`.
+5. Call a recursive function `generateCombinations` to generate combinations for each digit.
+6. Within the recursive function:
+   - Base case: If the current combination length equals the length of the input `digits`, add the combination to the `result` list.
+   - Recursive step: For the current digit, iterate over its corresponding letters and append each letter to the current combination, then recursively call the function with the next digit.
+7. Return the `result` list containing all possible combinations.
+
+Here's the implementation:
+
+```java
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution {
+    private static final Map<Character, String> digitToLetters = new HashMap<>();
+    static {
+        digitToLetters.put('2', "abc");
+        digitToLetters.put('3', "def");
+        digitToLetters.put('4', "ghi");
+        digitToLetters.put('5', "jkl");
+        digitToLetters.put('6', "mno");
+        digitToLetters.put('7', "pqrs");
+        digitToLetters.put('8', "tuv");
+        digitToLetters.put('9', "wxyz");
+    }
+
+    public List<String> letterCombinations(String digits) {
+        List<String> result = new ArrayList<>();
+        if (digits.length() == 0) {
+            return result;
+        }
+        generateCombinations(result, digits, "", 0);
+        return result;
+    }
+
+    private void generateCombinations(List<String> result, String digits, String combination, int index) {
+        if (index == digits.length()) {
+            result.add(combination);
+            return;
+        }
+
+        char digit = digits.charAt(index);
+        String letters = digitToLetters.get(digit);
+        for (char letter : letters.toCharArray()) {
+            generateCombinations(result, digits, combination + letter, index + 1);
+        }
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+
+        // Test cases
+        String digits1 = "23";
+        System.out.println("Example 1 Output: " + solution.letterCombinations(digits1));
+
+        String digits2 = "";
+        System.out.println("Example 2 Output: " + solution.letterCombinations(digits2));
+
+        String digits3 = "2";
+        System.out.println("Example 3 Output: " + solution.letterCombinations(digits3));
+    }
+}
+```
+
+This implementation provides a solution to the Letter Combinations of a Phone Number problem in Java.