add tests and new problem

Author: tarolling

pyproject.toml

@@ -4,7 +4,7 @@ version = "0.0.1"
 authors = [{ name = "tarolling", email = "benitojoens@gmail.com" }]
 description = "Implementations of LeetCode problem solutions in Python"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.12"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

src/leetcodepy/__init__.py

@@ -0,0 +1,4 @@
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next

src/leetcodepy/easy.py

@@ -27,16 +27,16 @@ def two_sum(nums: list[int], target: int) -> list[int]:
 
     Constraints:
 
-        2 <= nums.length <= 104
-        -109 <= nums[i] <= 109
-        -109 <= target <= 109
+        2 <= nums.length <= 10^4
+        -10^9 <= nums[i] <= 10^9
+        -10^9 <= target <= 10^9
         Only one valid answer exists.
 
     """
     # Constraints
-    assert 2 <= len(nums) <= 104
-    assert all(map(lambda x: -109 <= x <= 109, nums))
-    assert -109 <= target <= 109
+    assert 2 <= len(nums) <= 10**4
+    assert all(map(lambda x: -(10**9) <= x <= 10**9, nums))
+    assert -(10**9) <= target <= 10**9
 
     # Implementation
     hashmap = {}

src/leetcodepy/medium.py

@@ -1,7 +1,6 @@
-class ListNode:
-    def __init__(self, x):
-        self.val = x
-        self.next = None
+import re
+
+from . import ListNode
 
 
 def add_two_numbers(l1: ListNode | None, l2: ListNode | None) -> ListNode | None:
@@ -49,3 +48,53 @@ def add_two_numbers(l1: ListNode | None, l2: ListNode | None) -> ListNode | None
         l1 = l1.next if l1 else None
         l2 = l2.next if l2 else None
     return dummy_head.next
+
+
+def longest_substring_without_repeating_characters(s: str) -> int:
+    """
+    Given a string s, find the length of the longest substring
+    without repeating characters.
+
+
+    Example 1:
+
+    Input: s = "abcabcbb"
+    Output: 3
+    Explanation: The answer is "abc", with the length of 3.
+
+    Example 2:
+
+    Input: s = "bbbbb"
+    Output: 1
+    Explanation: The answer is "b", with the length of 1.
+
+    Example 3:
+
+    Input: s = "pwwkew"
+    Output: 3
+    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.
+
+
+
+    Constraints:
+
+        0 <= s.length <= 5 * 10^4
+        s consists of English letters, digits, symbols and spaces.
+    """
+    pattern = r'^[A-Za-z0-9\s!@#$%^&*()_+\-=\[\]{};:\'",.<>/?\\|`~]+$'
+    assert re.match(pattern, s)
+    assert 0 <= len(s) <= 5 * 10**4
+
+    max_length = left = 0
+    count = {}
+
+    for right, c in enumerate(s):
+        count[c] = 1 + count.get(c, 0)
+        while count[c] > 1:
+            count[s[left]] -= 1
+            left += 1
+
+        max_length = max(max_length, right - left + 1)
+
+    return max_length

tests/__init__.py

@@ -1,7 +1,25 @@
-from leetcodepy.easy import two_sum
+from src.leetcodepy.easy import *
+import pytest
 
 
 def test_two_sum():
-    assert two_sum([2, 7, 11, 15], 9) == [0, 1]
-    assert two_sum([3, 2, 4], 6) == [1, 2]
-    assert two_sum([3, 3], 6) == [0, 1]
+    # Invalid inputs
+    with pytest.raises(AssertionError):
+        two_sum([1], 1)
+    with pytest.raises(AssertionError):
+        two_sum([1 for _ in range(10**5 + 1)], 1)
+    with pytest.raises(AssertionError):
+        two_sum([-(10**9) - 1, 2, 3, 4], 1)
+    with pytest.raises(AssertionError):
+        two_sum([2, 3, 4, 10**9 + 1], 2)
+    with pytest.raises(AssertionError):
+        two_sum([1, 2, 4, 5, 6], -(10**9) - 1)
+    with pytest.raises(AssertionError):
+        two_sum([1, 2, 4, 5, 6], 10**9 + 1)
+    with pytest.raises(AssertionError):
+        two_sum([1, 2, 13289, 10**9 + 9, 12312], 10**9 + 2)
+
+    # Valid inputs
+    assert set(two_sum([2, 7, 11, 15], 9)) == set([0, 1])
+    assert set(two_sum([3, 2, 4], 6)) == set([1, 2])
+    assert set(two_sum([3, 3], 6)) == set([0, 1])

tests/test_easy.py

@@ -0,0 +1,45 @@
+from src.leetcodepy.medium import *
+from src.leetcodepy import ListNode
+
+
+def test_add_two_numbers():
+    def list_node_to_list(l: ListNode) -> list:
+        result = []
+        current_node = l
+        while current_node.next is not None:
+            result.append(current_node.val)
+            current_node = current_node.next
+        result.append(current_node.val)
+        return result
+
+    assert list_node_to_list(
+        add_two_numbers(
+            ListNode(2, ListNode(4, ListNode(3))), ListNode(5, ListNode(6, ListNode(4)))
+        )
+    ) == [7, 0, 8]
+    assert list_node_to_list(add_two_numbers(ListNode(0), ListNode(0))) == [0]
+    assert list_node_to_list(
+        add_two_numbers(
+            ListNode(
+                9,
+                ListNode(
+                    9,
+                    ListNode(
+                        9,
+                        ListNode(
+                            9,
+                            ListNode(9, ListNode(9, ListNode(9))),
+                        ),
+                    ),
+                ),
+            ),
+            ListNode(9, ListNode(9, ListNode(9, ListNode(9)))),
+        )
+    ) == [8, 9, 9, 9, 0, 0, 0, 1]
+
+
+def test_longest_substring_without_repeating_characters():
+    # Valid inputs
+    assert longest_substring_without_repeating_characters("abcabcbb") == 3
+    assert longest_substring_without_repeating_characters("bbbbb") == 1
+    assert longest_substring_without_repeating_characters("pwwkew") == 3