Improved readmes

Author: javadev

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

@@ -101,18 +101,4 @@ 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
-class Solution:
-    def twoSum(self, numbers: List[int], target: int) -> List[int]:
-        index_map = {}
-        for i, num in enumerate(numbers):
-            required_num = target - num
-            if required_num in index_map:
-                return [index_map[required_num], i]
-            index_map[num] = i
-        return [-1, -1]
-```
+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.

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

@@ -127,36 +127,4 @@ 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
-# 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(0)
-        p, q, curr = l1, l2, dummy_head
-        carry = 0
-        
-        while p is not None or q is not None:
-            x = p.val if p is not None else 0
-            y = q.val if q is not None else 0
-            sum = carry + x + y
-            carry = sum // 10
-            curr.next = ListNode(sum % 10)
-            curr = curr.next
-            if p is not None:
-                p = p.next
-            if q is not None:
-                q = q.next
-        
-        if carry > 0:
-            curr.next = ListNode(carry)
-        
-        return dummy_head.next
-```
+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.

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

@@ -120,30 +120,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
-class Solution:
-    def lengthOfLongestSubstring(self, s: str) -> int:
-        last_indices = [-1] * 256
-        max_len = 0
-        cur_len = 0
-        start = 0
-
-        for i, char in enumerate(s):
-            if last_indices[ord(char)] < start:
-                last_indices[ord(char)] = i
-                cur_len += 1
-            else:
-                last_index = last_indices[ord(char)]
-                start = last_index + 1
-                cur_len = i - start + 1
-                last_indices[ord(char)] = i
-
-            if cur_len > max_len:
-                max_len = cur_len
-
-        return max_len
-```
+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.

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

@@ -116,36 +116,4 @@ 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
-class Solution:
-    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
-        if len(nums2) < len(nums1):
-            return self.findMedianSortedArrays(nums2, nums1)
-
-        n1, n2 = len(nums1), len(nums2)
-        low, high = 0, n1
-
-        while low <= high:
-            cut1 = (low + high) // 2
-            cut2 = (n1 + n2 + 1) // 2 - cut1
-
-            l1 = float('-inf') if cut1 == 0 else nums1[cut1 - 1]
-            l2 = float('-inf') if cut2 == 0 else nums2[cut2 - 1]
-            r1 = float('inf') if cut1 == n1 else nums1[cut1]
-            r2 = float('inf') if cut2 == n2 else nums2[cut2]
-
-            if l1 <= r2 and l2 <= r1:
-                if (n1 + n2) % 2 == 0:
-                    return (max(l1, l2) + min(r1, r2)) / 2.0
-                return max(l1, l2)
-            elif l1 > r2:
-                high = cut1 - 1
-            else:
-                low = cut1 + 1
-
-        return 0.0
-```
+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.

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

@@ -117,42 +117,4 @@ s4 = "ac"
 print(solution.longestPalindrome(s4))  # Output: "a"
 ```
 
-This code defines a `Solution` class with a method `longestPalindrome` that takes a string `s` as input and returns the longest palindromic substring. The example usage demonstrates how to create an instance of the `Solution` class and call the `longestPalindrome` method with different inputs.
-
-## Solution
-
-```python
-class Solution:
-    def longestPalindrome(self, s: str) -> str:
-        # Create a new string with separators
-        new_str = ['#'] * (2 * len(s) + 1)
-        for i in range(len(s)):
-            new_str[2 * i + 1] = s[i]
-
-        dp = [0] * len(new_str)
-        friend_center = 0
-        friend_radius = 0
-        lps_center = 0
-        lps_radius = 0
-
-        for i in range(len(new_str)):
-            if friend_center + friend_radius > i:
-                dp[i] = min(dp[2 * friend_center - i], (friend_center + friend_radius) - i)
-            else:
-                dp[i] = 1
-
-            while i + dp[i] < len(new_str) and i - dp[i] >= 0 and new_str[i + dp[i]] == new_str[i - dp[i]]:
-                dp[i] += 1
-
-            if friend_center + friend_radius < i + dp[i]:
-                friend_center = i
-                friend_radius = dp[i]
-
-            if lps_radius < dp[i]:
-                lps_center = i
-                lps_radius = dp[i]
-
-        start = (lps_center - lps_radius + 1) // 2
-        end = (lps_center + lps_radius - 1) // 2
-        return s[start:end]
-```
+This code defines a `Solution` class with a method `longestPalindrome` that takes a string `s` as input and returns the longest palindromic substring. The example usage demonstrates how to create an instance of the `Solution` class and call the `longestPalindrome` method with different inputs.

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

@@ -118,33 +118,4 @@ numRows3 = 1
 print(solution.convert(s3, numRows3))  # Output: "A"
 ```
 
-This code defines a `Solution` class with a method `convert` that takes a string `s` and the number of rows `numRows` as input and returns the zigzag conversion of the string. The example usage demonstrates how to create an instance of the `Solution` class and call the `convert` method with different inputs.
-
-## Solution
-
-```python
-class Solution:
-    def convert(self, s: str, numRows: int) -> str:
-        s_len = len(s)
-        if numRows == 1:
-            return s
-
-        max_dist = numRows * 2 - 2
-        buf = []
-
-        for i in range(numRows):
-            index = i
-            if i == 0 or i == numRows - 1:
-                while index < s_len:
-                    buf.append(s[index])
-                    index += max_dist
-            else:
-                while index < s_len:
-                    buf.append(s[index])
-                    index += max_dist - i * 2
-                    if index >= s_len:
-                        break
-                    buf.append(s[index])
-                    index += i * 2
-        return ''.join(buf)
-```
+This code defines a `Solution` class with a method `convert` that takes a string `s` and the number of rows `numRows` as input and returns the zigzag conversion of the string. The example usage demonstrates how to create an instance of the `Solution` class and call the `convert` method with different inputs.

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

@@ -124,25 +124,4 @@ x4 = 0
 print(solution.reverse(x4))  # Output: 0
 ```
 
-This code defines a `Solution` class with a method `reverse` that takes an integer `x` as input and returns the reversed integer. The example usage demonstrates how to create an instance of the `Solution` class and call the `reverse` method with different inputs.
-
-## Solution
-
-```python
-class Solution:
-    def reverse(self, x: int) -> int:
-        rev = 0
-        sign = -1 if x < 0 else 1
-        x = abs(x)
-
-        while x != 0:
-            rev = rev * 10 + x % 10
-            x //= 10
-
-        rev *= sign
-
-        if rev > 2**31 - 1 or rev < -2**31:
-            return 0
-
-        return rev
-```
+This code defines a `Solution` class with a method `reverse` that takes an integer `x` as input and returns the reversed integer. The example usage demonstrates how to create an instance of the `Solution` class and call the `reverse` method with different inputs.

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

@@ -206,37 +206,4 @@ s5 = "-91283472332"
 print(solution.myAtoi(s5))  # Output: -2147483648
 ```
 
-This code defines a `Solution` class with a method `myAtoi` that takes a string `s` as input and returns the 32-bit signed integer. The example usage demonstrates how to create an instance of the `Solution` class and call the `myAtoi` method with different inputs.
-
-## Solution
-
-```python
-class Solution:
-    def myAtoi(self, s: str) -> int:
-        s = s.lstrip()
-        if s == '':
-            return 0
-
-        result = ''
-        i = 0
-
-        negative = False
-        if s[0] == '-':
-            negative = True
-            i += 1
-        elif s[0] == '+':
-            i += 1
-
-        while i < len(s) and s[i].isnumeric():
-            result += s[i]
-            i += 1
-
-        if result:
-            result = -1*int(result) if negative else int(result)
-            if result < -2**31:
-                return -2**31
-            elif result > 2**31 - 1:
-                return 2**31 - 1
-            return result
-        return 0
-```
+This code defines a `Solution` class with a method `myAtoi` that takes a string `s` as input and returns the 32-bit signed integer. The example usage demonstrates how to create an instance of the `Solution` class and call the `myAtoi` method with different inputs.

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

@@ -103,12 +103,4 @@ x4 = -101
 print(solution.isPalindrome(x4))  # Output: False
 ```
 
-This code defines a `Solution` class with a method `isPalindrome` that takes an integer `x` as input and returns `True` if it is a palindrome and `False` otherwise. The example usage demonstrates how to create an instance of the `Solution` class and call the `isPalindrome` method with different inputs. The `reverse` method is used to reverse the digits of a positive integer.
-
-## Solution
-
-```python
-class Solution:
-    def isPalindrome(self, x: int) -> bool:
-        return str(x) == str(x)[::-1]
-```
+This code defines a `Solution` class with a method `isPalindrome` that takes an integer `x` as input and returns `True` if it is a palindrome and `False` otherwise. The example usage demonstrates how to create an instance of the `Solution` class and call the `isPalindrome` method with different inputs. The `reverse` method is used to reverse the digits of a positive integer.

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

@@ -119,33 +119,4 @@ s5, p5 = "mississippi", "mis*is*p*."
 print(solution.isMatch(s5, p5))  # Output: False
 ```
 
-This code defines a `Solution` class with a method `isMatch` that takes a string `s` and a pattern `p` as input and returns `True` if they match and `False` otherwise. The example usage demonstrates how to create an instance of the `Solution` class and call the `isMatch` method with different inputs using the recursive approach.
-
-## Solution
-
-```python
-class Solution:
-    def __init__(self):
-        self.cache = None
-
-    def isMatch(self, s: str, p: str) -> bool:
-        self.cache = [[None] * (len(p) + 1) for _ in range(len(s) + 1)]
-        return self._isMatch(s, p, 0, 0)
-
-    def _isMatch(self, s: str, p: str, i: int, j: int) -> bool:
-        if j == len(p):
-            return i == len(s)
-
-        if self.cache[i][j] is not None:
-            return self.cache[i][j]
-
-        first_match = i < len(s) and (s[i] == p[j] or p[j] == '.')
-
-        if j + 1 < len(p) and p[j + 1] == '*':
-            result = (first_match and self._isMatch(s, p, i + 1, j)) or self._isMatch(s, p, i, j + 2)
-        else:
-            result = first_match and self._isMatch(s, p, i + 1, j + 1)
-
-        self.cache[i][j] = result
-        return result
-```
+This code defines a `Solution` class with a method `isMatch` that takes a string `s` and a pattern `p` as input and returns `True` if they match and `False` otherwise. The example usage demonstrates how to create an instance of the `Solution` class and call the `isMatch` method with different inputs using the recursive approach.

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

@@ -114,22 +114,4 @@ height4 = [1, 2, 1]
 print(solution.maxArea(height4))  # Output: 2
 ```
 
-This code defines a `Solution` class with a method `maxArea` that takes an array of heights as input and returns the maximum area that can be formed by a container. The example usage demonstrates how to create an instance of the `Solution` class and call the `maxArea` method with different inputs.
-
-## Solution
-
-```python
-class Solution:
-    def maxArea(self, height: List[int]) -> int:
-        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
-```
+This code defines a `Solution` class with a method `maxArea` that takes an array of heights as input and returns the maximum area that can be formed by a container. The example usage demonstrates how to create an instance of the `Solution` class and call the `maxArea` method with different inputs.