add ten easy problems

Author: tarolling

.github/workflows/publish.yml

@@ -1,6 +1,9 @@
 name: Publish Python 🐍 distribution 📦 to PyPI and TestPyPI
 
-on: push
+on:
+  push:
+    branches:
+      - main
 
 jobs:
   build:
@@ -30,7 +33,7 @@ jobs:
   publish-to-pypi:
     name: >-
       Publish Python 🐍 distribution 📦 to PyPI
-    if: startsWith(github.ref, 'refs/tags/')  # only publish to PyPI on tag pushes
+    # if: startsWith(github.ref, 'refs/tags/')  # only publish to PyPI on tag pushes
     needs:
     - build
     runs-on: ubuntu-latest

.vscode/settings.json

@@ -3,5 +3,6 @@
         "tests"
     ],
     "python.testing.unittestEnabled": false,
-    "python.testing.pytestEnabled": true
+    "python.testing.pytestEnabled": true,
+    "python.analysis.typeCheckingMode": "strict"
 }

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "leetcodepy"
-version = "0.0.1"
+version = "0.0.2"
 authors = [{ name = "tarolling", email = "benitojoens@gmail.com" }]
 description = "Implementations of LeetCode problem solutions in Python"
 readme = "README.md"

src/leetcodepy/__init__.py

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

src/leetcodepy/easy.py

@@ -1,3 +1,7 @@
+from typing import Optional
+from .utils import ListNode
+
+
 def two_sum(nums: list[int], target: int) -> list[int]:
     """Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
 
@@ -33,16 +37,107 @@ def two_sum(nums: list[int], target: int) -> list[int]:
         Only one valid answer exists.
 
     """
-    # Constraints
-    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 = {}
     for i in range(len(nums)):
         complement = target - nums[i]
         if complement in hashmap:
             return [i, hashmap[complement]]
         hashmap[nums[i]] = i
     return []
+
+
+def palindrome_number(x: int) -> bool:
+    if x < 0:
+        return False
+    x_str = str(x)
+    return x_str == x_str[::-1]
+
+
+def roman_to_integer(s: str) -> int:
+    translations = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
+    number = 0
+    s = s.replace("IV", "IIII").replace("IX", "VIIII")
+    s = s.replace("XL", "XXXX").replace("XC", "LXXXX")
+    s = s.replace("CD", "CCCC").replace("CM", "DCCCC")
+    for char in s:
+        number += translations[char]
+    return number
+
+
+def longest_common_prefix(strs: list[str]) -> str:
+    ans = ""
+    v = sorted(strs)
+    first = v[0]
+    last = v[-1]
+    for i in range(min(len(first), len(last))):
+        if first[i] != last[i]:
+            return ans
+        ans += first[i]
+    return ans
+
+
+def valid_parentheses(s: str) -> bool:
+    d = {"(": ")", "{": "}", "[": "]"}
+    stack: list[str] = []
+    for i in s:
+        if i in d:
+            stack.append(i)
+        elif len(stack) == 0 or d[stack.pop()] != i:
+            return False
+    return len(stack) == 0
+
+
+def merge_two_sorted_lists(
+    list1: Optional[ListNode], list2: Optional[ListNode]
+) -> Optional[ListNode]:
+    if not list1 or not list2:
+        return list1 or list2
+    if list1.val <= list2.val:
+        list1.next = merge_two_sorted_lists(list1.next, list2)
+        return list1
+    else:
+        list2.next = merge_two_sorted_lists(list1, list2.next)
+        return list2
+
+
+def remove_duplicates_from_sorted_array(nums: list[int]) -> int:
+    j = 1
+    for i in range(1, len(nums)):
+        if nums[i] != nums[i - 1]:
+            nums[j] = nums[i]
+            j += 1
+    return j
+
+
+def remove_element(nums: list[int], val: int) -> int:
+    j = 0
+    for i in range(len(nums)):
+        if nums[i] != val:
+            nums[j] = nums[i]
+            j += 1
+    return j
+
+
+def find_the_index_of_the_first_occurrence_in_a_string(
+    haystack: str, needle: str
+) -> int:
+    if len(haystack) < len(needle):
+        return -1
+    for i in range(len(haystack)):
+        if haystack[i : i + len(needle)] == needle:
+            return i
+    return -1
+
+
+def search_insert_position(nums: list[int], target: int) -> int:
+    left = 0
+    right = len(nums) - 1
+    while left <= right:
+        mid = (left + right) // 2
+        if nums[mid] == target:
+            return mid
+        elif nums[mid] > target:
+            right = mid - 1
+        else:
+            left = mid + 1
+    return left

src/leetcodepy/medium.py

@@ -1,6 +1,6 @@
 import re
 
-from . import ListNode
+from .utils import ListNode
 
 
 def add_two_numbers(l1: ListNode | None, l2: ListNode | None) -> ListNode | None:
@@ -87,7 +87,7 @@ def longest_substring_without_repeating_characters(s: str) -> int:
     assert 0 <= len(s) <= 5 * 10**4
 
     max_length = left = 0
-    count = {}
+    count: dict[str, int] = {}
 
     for right, c in enumerate(s):
         count[c] = 1 + count.get(c, 0)

src/leetcodepy/utils.py

@@ -0,0 +1,9 @@
+class ListNode:
+    def __init__(self, val: int = 0, next: "ListNode | None" = None):
+        self.val = val
+        self.next = next
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, ListNode):
+            return False
+        return self.val == value.val and self.next == value.next

tests/test_easy.py

@@ -23,3 +23,69 @@ def test_two_sum():
     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])
+
+
+def test_palindrome_number():
+    assert palindrome_number(121)
+    assert not palindrome_number(-121)
+    assert not palindrome_number(10)
+
+
+def test_roman_to_integer():
+    assert roman_to_integer("III") == 3
+    assert roman_to_integer("LVIII") == 58
+    assert roman_to_integer("MCMXCIV") == 1994
+
+
+def test_longest_common_prefix():
+    assert longest_common_prefix(["flower", "flow", "flight"]) == "fl"
+    assert longest_common_prefix(["dog", "racecar", "car"]) == ""
+
+
+def test_valid_parentheses():
+    assert valid_parentheses("()")
+    assert valid_parentheses("()[]{}")
+    assert not valid_parentheses("(]")
+    assert valid_parentheses("([])")
+
+
+def test_merge_two_sorted_lists():
+    list1 = ListNode(1, ListNode(2, ListNode(4)))
+    list2 = ListNode(1, ListNode(3, ListNode(4)))
+    assert merge_two_sorted_lists(list1, list2) == ListNode(
+        1, ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(4)))))
+    )
+
+    assert merge_two_sorted_lists(None, None) == None
+    assert merge_two_sorted_lists(None, ListNode(0)) == ListNode(0)
+
+
+def test_remove_duplicates_from_sorted_array():
+    nums = [1, 1, 2]
+    assert remove_duplicates_from_sorted_array(nums) == 2
+    assert nums[:2] == [1, 2]
+
+    nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
+    assert remove_duplicates_from_sorted_array(nums) == 5
+    assert nums[:5] == [0, 1, 2, 3, 4]
+
+
+def test_remove_element():
+    nums = [3, 2, 2, 3]
+    assert remove_element(nums, 3) == 2
+    assert set(nums[:2]) == set([2, 2])
+
+    nums = [0, 1, 2, 2, 3, 0, 4, 2]
+    assert remove_element(nums, 2) == 5
+    assert set(nums[:5]) == set([0, 1, 4, 0, 3])
+
+
+def test_find_the_index_of_the_first_occurrence_in_a_string():
+    assert find_the_index_of_the_first_occurrence_in_a_string("sadbutsad", "sad") == 0
+    assert find_the_index_of_the_first_occurrence_in_a_string("leetcode", "leeto") == -1
+
+
+def test_search_insert_position():
+    assert search_insert_position([1, 3, 5, 6], 5) == 2
+    assert search_insert_position([1, 3, 5, 6], 2) == 1
+    assert search_insert_position([1, 3, 5, 6], 7) == 4

tests/test_medium.py

@@ -1,10 +1,10 @@
 from src.leetcodepy.medium import *
-from src.leetcodepy import ListNode
+from src.leetcodepy.utils import ListNode
 
 
 def test_add_two_numbers():
-    def list_node_to_list(l: ListNode) -> list:
-        result = []
+    def list_node_to_list(l: ListNode) -> list[int]:
+        result: list[int] = []
         current_node = l
         while current_node.next is not None:
             result.append(current_node.val)