Updated readmes

Author: javadev

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

@@ -40,6 +40,69 @@ 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?
 
+Here are the steps to solve the Two Sum problem:
+
+### Approach:
+
+1. **Create a Dictionary/HashMap:**
+   - Initialize an empty dictionary to store the elements of the array and their corresponding indices.
+
+2. **Iterate through the Array:**
+   - Traverse through the given array `nums` using a loop.
+
+3. **Check Complement:**
+   - For each element `nums[i]`, calculate its complement (i.e., `target - nums[i]`).
+
+4. **Check if Complement exists:**
+   - Check if the complement is already in the dictionary.
+     - If it is, return the indices `[dictionary[complement], i]`.
+     - If not, add the current element and its index to the dictionary.
+
+### Python Code:
+
+```python
+from typing import List
+
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        # Create a dictionary to store elements and their indices
+        num_dict = {}
+        
+        # Iterate through the array
+        for i in range(len(nums)):
+            # Check complement
+            complement = target - nums[i]
+            
+            # Check if complement exists in the dictionary
+            if complement in num_dict:
+                # Return the indices if complement is found
+                return [num_dict[complement], i]
+            
+            # Add the current element and its index to the dictionary
+            num_dict[nums[i]] = i
+        
+        # If no solution is found
+        return None
+
+# Example Usage:
+solution = Solution()
+
+nums1 = [2, 7, 11, 15]
+target1 = 9
+print(solution.twoSum(nums1, target1))  # Output: [0, 1]
+
+nums2 = [3, 2, 4]
+target2 = 6
+print(solution.twoSum(nums2, target2))  # Output: [1, 2]
+
+nums3 = [3, 3]
+target3 = 6
+print(solution.twoSum(nums3, target3))  # Output: [0, 1]
+```
+
+### Time Complexity:
+The time complexity of this algorithm is O(n), where n is the number of elements in the array. The dictionary lookup operation is constant time.
+
 ## Solution
 
 ```python

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

@@ -37,6 +37,98 @@ 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.
 
+Here are the steps to solve the "Add Two Numbers" problem:
+
+### Approach:
+
+1. **Initialize Pointers and Carry:**
+   - Initialize three pointers, `p1` for the first linked list (`l1`), `p2` for the second linked list (`l2`), and `dummy_head` for the dummy node of the result linked list.
+   - Initialize `carry` to 0.
+
+2. **Traverse Both Linked Lists:**
+   - Traverse both linked lists until both pointers (`p1` and `p2`) reach the end.
+
+3. **Calculate Sum and Carry:**
+   - At each step, calculate the sum of the current digits and the carry from the previous step.
+   - Update `carry` for the next iteration.
+
+4. **Create New Node:**
+   - Create a new node with the value as the sum % 10 and add it to the result linked list.
+
+5. **Move Pointers:**
+   - Move both pointers (`p1` and `p2`) to the next nodes in their respective linked lists.
+
+6. **Handle Remaining Digits:**
+   - After both linked lists are traversed, check if there is any remaining carry.
+   - If there is, create a new node with the value of the carry and add it to the result linked list.
+
+7. **Return Result:**
+   - Return the next node of `dummy_head` as the head of the result linked list.
+
+### Python Code:
+
+```python
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        dummy_head = ListNode()
+        p1, p2, current = l1, l2, dummy_head
+        carry = 0
+
+        while p1 or p2:
+            # Get values and handle None cases
+            x = p1.val if p1 else 0
+            y = p2.val if p2 else 0
+
+            # Calculate sum and carry
+            _sum = x + y + carry
+            carry = _sum // 10
+
+            # Create new node with the sum % 10
+            current.next = ListNode(_sum % 10)
+            current = current.next
+
+            # Move pointers to the next nodes
+            if p1:
+                p1 = p1.next
+            if p2:
+                p2 = p2.next
+
+        # Handle remaining carry
+        if carry > 0:
+            current.next = ListNode(carry)
+
+        return dummy_head.next
+
+# Example Usage:
+solution = Solution()
+
+# Example 1:
+l1 = ListNode(2, ListNode(4, ListNode(3)))
+l2 = ListNode(5, ListNode(6, ListNode(4)))
+result = solution.addTwoNumbers(l1, l2)
+# Output: [7, 0, 8]
+
+# Example 2:
+l1 = ListNode(0)
+l2 = ListNode(0)
+result = solution.addTwoNumbers(l1, l2)
+# Output: [0]
+
+# Example 3:
+l1 = ListNode(9, ListNode(9, ListNode(9, ListNode(9, ListNode(9, ListNode(9, ListNode(9)))))))
+l2 = ListNode(9, ListNode(9, ListNode(9, ListNode(9))))
+result = solution.addTwoNumbers(l1, l2)
+# Output: [8, 9, 9, 9, 0, 0, 0, 1]
+```
+
+This code defines a `ListNode` class for the singly-linked list and a `Solution` class with a method `addTwoNumbers` that takes two linked lists as input and returns the result as a linked list. The example usage demonstrates how to create instances of the `ListNode` class and call the `addTwoNumbers` method with different inputs.
+
 ## Solution
 
 ```python

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

@@ -42,6 +42,86 @@ 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.
 
+Here are the steps to solve the "Longest Substring Without Repeating Characters" problem:
+
+### Approach:
+
+1. **Initialize Pointers and Variables:**
+   - Initialize two pointers, `start` and `end`, to define the current substring.
+   - Initialize a dictionary `char_index` to store the last index of each character in the substring.
+   - Initialize the variable `max_length` to track the length of the longest substring.
+
+2. **Traverse the String:**
+   - Use the `end` pointer to traverse through the string `s`.
+
+3. **Check for Repeating Characters:**
+   - If the character at the current `end` pointer is not in the substring (not in `char_index`), add it to the substring.
+   - Update `max_length` if the length of the current substring is greater than the previous maximum.
+
+4. **Adjust Start Pointer:**
+   - If the character is already in the substring, move the `start` pointer to the right of the last occurrence of that character.
+   - This ensures that the substring does not contain repeating characters.
+
+5. **Update Character Index:**
+   - Update the index of the current character in the `char_index` dictionary.
+
+6. **Repeat Until End of String:**
+   - Repeat steps 3-5 until the `end` pointer reaches the end of the string.
+
+7. **Return Maximum Length:**
+   - The maximum length of the substring without repeating characters is stored in the variable `max_length`.
+
+### Python Code:
+
+```python
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        # Initialize pointers and variables
+        start, end = 0, 0
+        char_index = {}  # Dictionary to store the last index of each character
+        max_length = 0
+
+        # Traverse the string
+        while end < len(s):
+            # Check for repeating characters
+            if s[end] not in char_index or char_index[s[end]] < start:
+                # Update max_length
+                max_length = max(max_length, end - start + 1)
+            else:
+                # Adjust start pointer
+                start = char_index[s[end]] + 1
+
+            # Update character index
+            char_index[s[end]] = end
+
+            # Move end pointer to the next character
+            end += 1
+
+        # Return the maximum length of the substring
+        return max_length
+
+# Example Usage:
+solution = Solution()
+
+# Example 1:
+s1 = "abcabcbb"
+gprint(solution.lengthOfLongestSubstring(s1))  # Output: 3
+
+# Example 2:
+s2 = "bbbbb"
+print(solution.lengthOfLongestSubstring(s2))  # Output: 1
+
+# Example 3:
+s3 = "pwwkew"
+print(solution.lengthOfLongestSubstring(s3))  # Output: 3
+
+# Example 4:
+s4 = ""
+print(solution.lengthOfLongestSubstring(s4))  # Output: 0
+```
+
+This code defines a `Solution` class with a method `lengthOfLongestSubstring` that takes a string `s` as input and returns the length of the longest substring without repeating characters. The example usage demonstrates how to create an instance of the `Solution` class and call the `lengthOfLongestSubstring` method with different inputs.
+
 ## Solution
 
 ```python

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

@@ -52,6 +52,72 @@ 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>
 
+Here are the steps to solve the "Median of Two Sorted Arrays" problem:
+
+### Approach:
+
+1. **Combine Arrays:**
+   - Combine the two sorted arrays (`nums1` and `nums2`) into a single sorted array (`merged`).
+   - This can be done by merging the arrays while maintaining the sorted order.
+
+2. **Find Median:**
+   - If the length of the combined array is odd, the median is the middle element.
+   - If the length is even, the median is the average of the two middle elements.
+
+3. **Handle Empty Arrays:**
+   - If one of the arrays is empty, find the median of the non-empty array.
+   - If both arrays are empty, return 0.
+
+### Python Code:
+
+```python
+class Solution:
+    def findMedianSortedArrays(self, nums1, nums2):
+        # Combine arrays
+        merged = sorted(nums1 + nums2)
+
+        # Find median
+        length = len(merged)
+        if length % 2 == 1:
+            # Odd length
+            return float(merged[length // 2])
+        else:
+            # Even length
+            mid1 = merged[length // 2 - 1]
+            mid2 = merged[length // 2]
+            return (mid1 + mid2) / 2.0
+
+# Example Usage:
+solution = Solution()
+
+# Example 1:
+nums1_1 = [1, 3]
+nums2_1 = [2]
+print(solution.findMedianSortedArrays(nums1_1, nums2_1))  # Output: 2.00000
+
+# Example 2:
+nums1_2 = [1, 2]
+nums2_2 = [3, 4]
+print(solution.findMedianSortedArrays(nums1_2, nums2_2))  # Output: 2.50000
+
+# Example 3:
+nums1_3 = [0, 0]
+nums2_3 = [0, 0]
+print(solution.findMedianSortedArrays(nums1_3, nums2_3))  # Output: 0.00000
+
+# Example 4:
+nums1_4 = []
+nums2_4 = [1]
+print(solution.findMedianSortedArrays(nums1_4, nums2_4))  # Output: 1.00000
+
+# Example 5:
+nums1_5 = [2]
+nums2_5 = []
+print(solution.findMedianSortedArrays(nums1_5, nums2_5))  # Output: 2.00000
+```
+
+This code defines a `Solution` class with a method `findMedianSortedArrays` that takes two sorted arrays (`nums1` and `nums2`) as input and returns the median of the combined sorted array. The example usage demonstrates how to create an instance of the `Solution` class and call the `findMedianSortedArrays` method with different inputs.
+
 ## Solution
 
 ```python