Improved java

Author: javadev

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

@@ -40,23 +40,64 @@ You can return the answer in any order.
 
 **Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code> time complexity?
 
-## Solution
+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;
-import java.util.Map;
 
 public class Solution {
-    public int[] twoSum(int[] numbers, int target) {
-        Map<Integer, Integer> indexMap = new HashMap<>();
-        for (int i = 0; i < numbers.length; i++) {
-            Integer requiredNum = target - numbers[i];
-            if (indexMap.containsKey(requiredNum)) {
-                return new int[] {indexMap.get(requiredNum), i};
+
+    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};
             }
-            indexMap.put(numbers[i], i);
+            // Add the current element and its index to the hashmap
+            map.put(nums[i], i);
         }
-        return new int[] {-1, -1};
+        // 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.

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

@@ -37,44 +37,100 @@ You may assume the two numbers do not contain any leading zero, except the numbe
 *   `0 <= Node.val <= 9`
 *   It is guaranteed that the list represents a number that does not have leading zeros.
 
-## Solution
+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
-import com_github_leetcode.ListNode;
-
-/*
- * Definition for singly-linked list.
- * public class ListNode {
- *     int val;
- *     ListNode next;
- *     ListNode(int x) { val = x; }
- * }
- */
+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(0);
-        ListNode p = l1;
-        ListNode q = l2;
+        ListNode dummyHead = new ListNode();
         ListNode curr = dummyHead;
         int carry = 0;
-        while (p != null || q != null) {
-            int x = (p != null) ? p.val : 0;
-            int y = (q != null) ? q.val : 0;
-            int sum = carry + x + y;
-            carry = sum / 10;
-            curr.next = new ListNode(sum % 10);
-            curr = curr.next;
-            if (p != null) {
-                p = p.next;
+        
+        while (l1 != null || l2 != null) {
+            int sum = carry;
+            if (l1 != null) {
+                sum += l1.val;
+                l1 = l1.next;
             }
-            if (q != null) {
-                q = q.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.

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

@@ -42,34 +42,65 @@ Given a string `s`, find the length of the **longest substring** without repeati
 *   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
 *   `s` consists of English letters, digits, symbols and spaces.
 
-## Solution
+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) {
-        int[] lastIndices = new int[256];
-        for (int i = 0; i < 256; i++) {
-            lastIndices[i] = -1;
-        }
-        int maxLen = 0;
-        int curLen = 0;
+        // Initialize variables
         int start = 0;
-        for (int i = 0; i < s.length(); i++) {
-            char cur = s.charAt(i);
-            if (lastIndices[cur] < start) {
-                lastIndices[cur] = i;
-                curLen++;
-            } else {
-                int lastIndex = lastIndices[cur];
-                start = lastIndex + 1;
-                curLen = i - start + 1;
-                lastIndices[cur] = i;
-            }
-            if (curLen > maxLen) {
-                maxLen = curLen;
+        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.

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

@@ -52,40 +52,70 @@ The overall run time complexity should be `O(log (m+n))`.
 *   `1 <= m + n <= 2000`
 *   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>
 
-## Solution
+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
-@SuppressWarnings("java:S2234")
 public class Solution {
+    
     public double findMedianSortedArrays(int[] nums1, int[] nums2) {
-        if (nums2.length < nums1.length) {
-            return findMedianSortedArrays(nums2, nums1);
-        }
-        int cut1;
-        int cut2;
-        int n1 = nums1.length;
-        int n2 = nums2.length;
-        int low = 0;
-        int high = n1;
-        while (low <= high) {
-            cut1 = (low + high) / 2;
-            cut2 = ((n1 + n2 + 1) / 2) - cut1;
-            int l1 = cut1 == 0 ? Integer.MIN_VALUE : nums1[cut1 - 1];
-            int l2 = cut2 == 0 ? Integer.MIN_VALUE : nums2[cut2 - 1];
-            int r1 = cut1 == n1 ? Integer.MAX_VALUE : nums1[cut1];
-            int r2 = cut2 == n2 ? Integer.MAX_VALUE : nums2[cut2];
-            if (l1 <= r2 && l2 <= r1) {
-                if ((n1 + n2) % 2 == 0) {
-                    return (Math.max(l1, l2) + Math.min(r1, r2)) / 2.0;
-                }
-                return Math.max(l1, l2);
-            } else if (l1 > r2) {
-                high = cut1 - 1;
-            } else {
-                low = cut1 + 1;
-            }
+        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);
         }
-        return 0.0f;
+    }
+
+    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))).