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.