updated tasks 1-22

Author: ThanhNIT

src/main/java/g0001_0100/s0001_two_sum/readme.md

@@ -35,66 +35,4 @@ You can return the answer in any order.
 *   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
 *   **Only one valid answer exists.**
 
-**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code> time complexity?
-
-To solve the Two Sum problem in Java using a `Solution` class, we'll follow these steps:
-
-1. Define a `Solution` class with a method named `twoSum`.
-2. Inside the `twoSum` method, create a hashmap to store elements and their indices.
-3. Iterate through the array:
-   - For each element, calculate the complement required to reach the target sum.
-   - Check if the complement exists in the hashmap.
-   - If found, return the indices of the current element and the complement.
-   - If not found, add the current element and its index to the hashmap.
-4. Handle edge cases:
-   - If no solution is found, return an empty array or null (depending on the problem requirements).
-
-Here's the implementation:
-
-```java
-import java.util.HashMap;
-
-public class Solution {
-
-    public int[] twoSum(int[] nums, int target) {
-        // Create a hashmap to store elements and their indices
-        HashMap<Integer, Integer> map = new HashMap<>();
-
-        // Iterate through the array
-        for (int i = 0; i < nums.length; i++) {
-            int complement = target - nums[i];
-            // Check if the complement exists in the hashmap
-            if (map.containsKey(complement)) {
-                // Return the indices of the current element and the complement
-                return new int[]{map.get(complement), i};
-            }
-            // Add the current element and its index to the hashmap
-            map.put(nums[i], i);
-        }
-        // If no solution is found, return an empty array or null
-        return new int[]{};
-    }
-
-    public static void main(String[] args) {
-        Solution solution = new Solution();
-        
-        // Test cases
-        int[] nums1 = {2, 7, 11, 15};
-        int target1 = 9;
-        int[] result1 = solution.twoSum(nums1, target1);
-        System.out.println("Example 1 Output: [" + result1[0] + ", " + result1[1] + "]");
-
-        int[] nums2 = {3, 2, 4};
-        int target2 = 6;
-        int[] result2 = solution.twoSum(nums2, target2);
-        System.out.println("Example 2 Output: [" + result2[0] + ", " + result2[1] + "]");
-
-        int[] nums3 = {3, 3};
-        int target3 = 6;
-        int[] result3 = solution.twoSum(nums3, target3);
-        System.out.println("Example 3 Output: [" + result3[0] + ", " + result3[1] + "]");
-    }
-}
-```
-
-This implementation provides a solution to the Two Sum problem with a time complexity of O(n), where n is the number of elements in the input array.
+**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code> time complexity?

src/main/java/g0001_0100/s0002_add_two_numbers/readme.md

@@ -32,102 +32,4 @@ You may assume the two numbers do not contain any leading zero, except the numbe
 
 *   The number of nodes in each linked list is in the range `[1, 100]`.
 *   `0 <= Node.val <= 9`
-*   It is guaranteed that the list represents a number that does not have leading zeros.
-
-To solve the Add Two Numbers problem in Java using a `Solution` class, we'll follow these steps:
-
-1. Define a `ListNode` class to represent nodes in a linked list.
-2. Define a `Solution` class with a method named `addTwoNumbers`.
-3. Inside the `addTwoNumbers` method, traverse both input linked lists simultaneously:
-   - Keep track of a carry variable to handle cases where the sum of two digits exceeds 9.
-   - Calculate the sum of the current nodes' values along with the carry.
-   - Update the carry for the next iteration.
-   - Create a new node with the sum % 10 and attach it to the result linked list.
-   - Move to the next nodes in both input lists.
-4. After finishing the traversal, check if there is any remaining carry. If so, add a new node with the carry to the result.
-5. Return the head of the result linked list.
-
-Here's the implementation:
-
-```java
-class ListNode {
-    int val;
-    ListNode next;
-    
-    ListNode() {}
-    
-    ListNode(int val) {
-        this.val = val;
-    }
-    
-    ListNode(int val, ListNode next) {
-        this.val = val;
-        this.next = next;
-    }
-}
-
-public class Solution {
-    
-    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
-        ListNode dummyHead = new ListNode();
-        ListNode curr = dummyHead;
-        int carry = 0;
-        
-        while (l1 != null || l2 != null) {
-            int sum = carry;
-            if (l1 != null) {
-                sum += l1.val;
-                l1 = l1.next;
-            }
-            if (l2 != null) {
-                sum += l2.val;
-                l2 = l2.next;
-            }
-            curr.next = new ListNode(sum % 10);
-            curr = curr.next;
-            carry = sum / 10;
-        }
-        
-        if (carry > 0) {
-            curr.next = new ListNode(carry);
-        }
-        
-        return dummyHead.next;
-    }
-
-    // Helper method to print a linked list
-    public void printList(ListNode head) {
-        ListNode curr = head;
-        while (curr != null) {
-            System.out.print(curr.val + " ");
-            curr = curr.next;
-        }
-        System.out.println();
-    }
-
-    public static void main(String[] args) {
-        Solution solution = new Solution();
-
-        // Test cases
-        ListNode l1 = new ListNode(2, new ListNode(4, new ListNode(3)));
-        ListNode l2 = new ListNode(5, new ListNode(6, new ListNode(4)));
-        ListNode result1 = solution.addTwoNumbers(l1, l2);
-        System.out.print("Example 1 Output: ");
-        solution.printList(result1);
-
-        ListNode l3 = new ListNode(0);
-        ListNode l4 = new ListNode(0);
-        ListNode result2 = solution.addTwoNumbers(l3, l4);
-        System.out.print("Example 2 Output: ");
-        solution.printList(result2);
-
-        ListNode l5 = new ListNode(9, new ListNode(9, new ListNode(9, new ListNode(9, new ListNode(9, new ListNode(9, new ListNode(9)))))));
-        ListNode l6 = new ListNode(9, new ListNode(9, new ListNode(9, new ListNode(9))));
-        ListNode result3 = solution.addTwoNumbers(l5, l6);
-        System.out.print("Example 3 Output: ");
-        solution.printList(result3);
-    }
-}
-```
-
-This implementation provides a solution to the Add Two Numbers problem using linked lists in Java.
+*   It is guaranteed that the list represents a number that does not have leading zeros.

src/main/java/g0001_0100/s0003_longest_substring_without_repeating_characters/readme.md

@@ -2,15 +2,15 @@
 
 Medium
 
-Given a string `s`, find the length of the **longest substring** without repeating characters.
+Given a string `s`, find the length of the **longest** **substring** without duplicate characters.
 
 **Example 1:**
 
 **Input:** s = "abcabcbb"
 
 **Output:** 3
 
-**Explanation:** The answer is "abc", with the length of 3. 
+**Explanation:** The answer is "abc", with the length of 3. Note that `"bca"` and `"cab"` are also correct answers. 
 
 **Example 2:**
 
@@ -28,76 +28,7 @@ Given a string `s`, find the length of the **longest substring** without repeati
 
 **Explanation:** The answer is "wke", with the length of 3. Notice that the answer must be a substring, "pwke" is a subsequence and not a substring. 
 
-**Example 4:**
-
-**Input:** s = ""
-
-**Output:** 0 
-
 **Constraints:**
 
 *   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
-*   `s` consists of English letters, digits, symbols and spaces.
-
-To solve the Longest Substring Without Repeating Characters problem in Java using a `Solution` class, we'll follow these steps:
-
-1. Define a `Solution` class with a method named `lengthOfLongestSubstring`.
-2. Initialize variables to keep track of the starting index of the substring (`start`), the maximum length (`maxLen`), and a hashmap to store characters and their indices.
-3. Iterate through the string `s`, and for each character:
-   - Check if the character exists in the hashmap and its index is greater than or equal to the `start` index.
-   - If found, update the `start` index to the index after the last occurrence of the character.
-   - Update the maximum length if necessary.
-   - Update the index of the current character in the hashmap.
-4. Return the maximum length found.
-5. Handle the edge case where the input string is empty.
-
-Here's the implementation:
-
-```java
-import java.util.HashMap;
-
-public class Solution {
-    
-    public int lengthOfLongestSubstring(String s) {
-        // Initialize variables
-        int start = 0;
-        int maxLen = 0;
-        HashMap<Character, Integer> map = new HashMap<>();
-        
-        // Iterate through the string
-        for (int end = 0; end < s.length(); end++) {
-            char ch = s.charAt(end);
-            // If the character exists in the hashmap and its index is greater than or equal to the start index
-            if (map.containsKey(ch) && map.get(ch) >= start) {
-                // Update the start index to the index after the last occurrence of the character
-                start = map.get(ch) + 1;
-            }
-            // Update the maximum length if necessary
-            maxLen = Math.max(maxLen, end - start + 1);
-            // Update the index of the current character in the hashmap
-            map.put(ch, end);
-        }
-        
-        return maxLen;
-    }
-
-    public static void main(String[] args) {
-        Solution solution = new Solution();
-
-        // Test cases
-        String s1 = "abcabcbb";
-        System.out.println("Example 1 Output: " + solution.lengthOfLongestSubstring(s1));
-
-        String s2 = "bbbbb";
-        System.out.println("Example 2 Output: " + solution.lengthOfLongestSubstring(s2));
-
-        String s3 = "pwwkew";
-        System.out.println("Example 3 Output: " + solution.lengthOfLongestSubstring(s3));
-
-        String s4 = "";
-        System.out.println("Example 4 Output: " + solution.lengthOfLongestSubstring(s4));
-    }
-}
-```
-
-This implementation provides a solution to the Longest Substring Without Repeating Characters problem in Java.
+*   `s` consists of English letters, digits, symbols and spaces.

src/main/java/g0001_0100/s0004_median_of_two_sorted_arrays/readme.md

@@ -22,97 +22,11 @@ The overall run time complexity should be `O(log (m+n))`.
 
 **Explanation:** merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. 
 
-**Example 3:**
-
-**Input:** nums1 = [0,0], nums2 = [0,0]
-
-**Output:** 0.00000 
-
-**Example 4:**
-
-**Input:** nums1 = [], nums2 = [1]
-
-**Output:** 1.00000 
-
-**Example 5:**
-
-**Input:** nums1 = [2], nums2 = []
-
-**Output:** 2.00000 
-
 **Constraints:**
 
 *   `nums1.length == m`
 *   `nums2.length == n`
 *   `0 <= m <= 1000`
 *   `0 <= n <= 1000`
 *   `1 <= m + n <= 2000`
-*   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>
-
-To solve the Median of Two Sorted Arrays problem in Java using a `Solution` class, we'll follow these steps:
-
-1. Define a `Solution` class with a method named `findMedianSortedArrays`.
-2. Calculate the total length of the combined array (m + n).
-3. Determine the middle index or indices of the combined array based on its length (for both even and odd lengths).
-4. Implement a binary search algorithm to find the correct position for partitioning the two arrays such that elements to the left are less than or equal to elements on the right.
-5. Calculate the median based on the partitioned arrays.
-6. Handle edge cases where one or both arrays are empty or where the combined length is odd or even.
-7. Return the calculated median.
-
-Here's the implementation:
-
-```java
-public class Solution {
-    
-    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
-        int m = nums1.length;
-        int n = nums2.length;
-        int totalLength = m + n;
-        int left = (totalLength + 1) / 2;
-        int right = (totalLength + 2) / 2;
-        return (findKth(nums1, 0, nums2, 0, left) + findKth(nums1, 0, nums2, 0, right)) / 2.0;
-    }
-
-    private int findKth(int[] nums1, int i, int[] nums2, int j, int k) {
-        if (i >= nums1.length) return nums2[j + k - 1];
-        if (j >= nums2.length) return nums1[i + k - 1];
-        if (k == 1) return Math.min(nums1[i], nums2[j]);
-
-        int midVal1 = (i + k / 2 - 1 < nums1.length) ? nums1[i + k / 2 - 1] : Integer.MAX_VALUE;
-        int midVal2 = (j + k / 2 - 1 < nums2.length) ? nums2[j + k / 2 - 1] : Integer.MAX_VALUE;
-
-        if (midVal1 < midVal2) {
-            return findKth(nums1, i + k / 2, nums2, j, k - k / 2);
-        } else {
-            return findKth(nums1, i, nums2, j + k / 2, k - k / 2);
-        }
-    }
-
-    public static void main(String[] args) {
-        Solution solution = new Solution();
-
-        // Test cases
-        int[] nums1_1 = {1, 3};
-        int[] nums2_1 = {2};
-        System.out.println("Example 1 Output: " + solution.findMedianSortedArrays(nums1_1, nums2_1));
-
-        int[] nums1_2 = {1, 2};
-        int[] nums2_2 = {3, 4};
-        System.out.println("Example 2 Output: " + solution.findMedianSortedArrays(nums1_2, nums2_2));
-
-        int[] nums1_3 = {0, 0};
-        int[] nums2_3 = {0, 0};
-        System.out.println("Example 3 Output: " + solution.findMedianSortedArrays(nums1_3, nums2_3));
-
-        int[] nums1_4 = {};
-        int[] nums2_4 = {1};
-        System.out.println("Example 4 Output: " + solution.findMedianSortedArrays(nums1_4, nums2_4));
-
-        int[] nums1_5 = {2};
-        int[] nums2_5 = {};
-        System.out.println("Example 5 Output: " + solution.findMedianSortedArrays(nums1_5, nums2_5));
-    }
-}
-```
-
-This implementation provides a solution to the Median of Two Sorted Arrays problem in Java with a runtime complexity of O(log(min(m, n))).
+*   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>