feat: check solution with old version

Author: wislertt

leetcode/lru_cache/playground.ipynb

@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "imports",
    "metadata": {},
    "outputs": [],
@@ -13,7 +13,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "id": "setup",
    "metadata": {},
    "outputs": [],
@@ -26,22 +26,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "run",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[None, None, None, 1, None, -1, None, -1, 3, 4]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "OrderedDict([(3, 3), (4, 4)])"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "result, cache = run_lru_cache(LRUCache, operations, inputs)\n",
     "print(result)\n",
-    "cache"
+    "cache.cache"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "assert",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "assert_lru_cache(result, expected)"
    ]
@@ -61,7 +90,8 @@
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
-   "nbconvert_exporter": "python3",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
    "version": "3.13.7"
   }
  },

leetcode/maximum_profit_in_job_scheduling/solution.py

@@ -20,3 +20,31 @@ def job_scheduling(self, start_time: list[int], end_time: list[int], profit: lis
             dp[i] = max(take, skip)
 
         return dp[-1] if jobs else 0
+
+
+# bisect and insort Explanation:
+#
+# Etymology: "bisect" = bi (two) + sect (cut) = cut into two parts
+# Bisection method = binary search algorithm that repeatedly cuts search space in half
+#
+# bisect module provides binary search for SORTED lists (O(log n)):
+# - bisect_left(arr, x): leftmost insertion position
+# - bisect_right(arr, x): rightmost insertion position (default)
+# - bisect(arr, x): alias for bisect_right
+#
+# insort module maintains sorted order while inserting:
+# - insort_left(arr, x): insert at leftmost position
+# - insort_right(arr, x): insert at rightmost position (default)
+# - insort(arr, x): alias for insort_right
+#
+# Examples:
+# arr = [1, 3, 3, 5]
+# bisect_left(arr, 3) → 1   (before existing 3s)
+# bisect_right(arr, 3) → 3  (after existing 3s)
+# bisect_right(arr, 4) → 3  (between 3 and 5)
+#
+# insort(arr, 4) → arr becomes [1, 3, 3, 4, 5]
+#
+# In our solution:
+# bisect_right([2,4,6], 5) = 2 (insertion position)
+# j = 2 - 1 = 1 (index of latest job ending ≤ start_time)

leetcode/partition_equal_subset_sum/solution.py

@@ -3,6 +3,23 @@ class Solution:
     # Time: O(n * sum)
     # Space: O(sum)
     def can_partition(self, nums: list[int]) -> bool:
+        """
+        Example: nums = [1, 5, 11, 5], target = 11
+
+        Initial: dp = [T, F, F, F, F, F, F, F, F, F, F, F]
+                      0  1  2  3  4  5  6  7  8  9 10 11
+
+        After num=1: [T, T, F, F, F, F, F, F, F, F, F, F]
+                      └─┘ (can make sum 1)
+
+        After num=5: [T, T, F, F, F, T, T, F, F, F, F, F]
+                      └─┘          └─┘ └─┘ (can make sums 5,6)
+
+        After num=11:[T, T, F, F, F, T, T, F, F, F, F, T]
+                                                        └─┘ (target!)
+
+        Backward iteration prevents using same number twice
+        """
         total = sum(nums)
         if total % 2:
             return False
@@ -20,3 +37,57 @@ def can_partition(self, nums: list[int]) -> bool:
                 return True
 
         return False
+
+
+class SolutionBitset:
+    # Time: O(n * sum)
+    # Space: O(1)
+    def can_partition(self, nums: list[int]) -> bool:
+        """
+        Example: nums = [1, 5, 11, 5], target = 11
+
+        Bitset representation (bit position = achievable sum):
+
+        Initial:     dp = 1 (binary: 1)
+                     Bits: ...0001
+                     Sums: {0}
+
+        After num=1: dp |= dp << 1
+                     a = dp = 1 (bin: 0001)
+                     b = dp << 1 = 2 (bin: 0010)
+                     c = a | b = 3 (bin: 0011)
+                     Sums: {0, 1}
+
+        After num=5: dp |= dp << 5
+                     a = dp = 3 (bin: 0000011)
+                     b = dp << 5 = 96 (bin: 1100000)
+                     c = a | b = 99 (bin: 1100011)
+                     Sums: {0, 1, 5, 6}
+
+        After num=11: dp |= dp << 11
+                      a = dp = 99 (bin: 00000001100011)
+                      b = dp << 11 = 202752 (bin: 110001100000000)
+                      c = a | b = 202851 (bin: 110001101100011)
+                      Sums: {0, 1, 5, 6, 11, 12, 16, 17}
+
+        Check: (dp & (1 << 11)) != 0
+               a = dp = 202851 (bin: 110001101100011)
+               b = 1 << 11 = 2048 (bin: 100000000000)
+               c = a & b = 2048 (bin: 100000000000)
+               c != 0 → bit 11 is set → True!
+        """
+        total = sum(nums)
+        if total % 2 != 0:
+            return False
+
+        target = total // 2
+        dp = 1
+
+        for num in nums:
+            dp |= dp << num
+
+            # Early termination: found target sum!
+            if (dp & (1 << target)) != 0:
+                return True
+
+        return False

leetcode/partition_equal_subset_sum/test_solution.py

@@ -3,14 +3,13 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_can_partition, run_can_partition
-from .solution import Solution
+from .solution import Solution, SolutionBitset
 
 
 class TestPartitionEqualSubsetSum:
-    def setup_method(self):
-        self.solution = Solution()
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionBitset])
     @pytest.mark.parametrize(
         "nums, expected",
         [
@@ -23,6 +22,6 @@ def setup_method(self):
             ([1, 2, 5], False),
         ],
     )
-    def test_can_partition(self, nums: list[int], expected: bool):
-        result = run_can_partition(Solution, nums)
+    def test_can_partition(self, nums: list[int], expected: bool, solution_class: type):
+        result = run_can_partition(solution_class, nums)
         assert_can_partition(result, expected)

leetcode/task_scheduler/solution.py

@@ -1,10 +1,38 @@
+import heapq
+from collections import Counter, deque
+
+
 class Solution:
+    # Time: O(T * n + m log m) where T = len(tasks), worst case with many idle periods
+    # Space: O(m) where m ≤ 26, so O(1)
+    def least_interval(self, tasks: list[str], n: int) -> int:
+        counts = Counter(tasks)
+        max_heap = [-count for count in counts.values()]
+        heapq.heapify(max_heap)
+
+        step_num = 0
+        queue: deque[tuple[int, int]] = deque()  # (count, available_time)
 
+        while max_heap or queue:
+            step_num += 1
+
+            while queue and queue[0][1] <= step_num:
+                count, _ = queue.popleft()
+                heapq.heappush(max_heap, count)
+
+            if max_heap:
+                count = heapq.heappop(max_heap)
+                count += 1  # Decrease count (was negative)
+                if count < 0:  # Still has tasks left
+                    queue.append((count, step_num + n + 1))
+
+        return step_num
+
+
+class SolutionGreedy:
     # Time: O(T + m) where T = len(tasks), m = unique tasks ≤ 26, so O(T)
     # Space: O(m) where m ≤ 26, so O(1)
     def least_interval(self, tasks: list[str], n: int) -> int:
-        from collections import Counter
-
         """
         Mathematical approach:
 

leetcode/task_scheduler/test_solution.py

@@ -3,14 +3,13 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_least_interval, run_least_interval
-from .solution import Solution
+from .solution import Solution, SolutionGreedy
 
 
 class TestTaskScheduler:
-    def setup_method(self):
-        self.solution = Solution()
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionGreedy])
     @pytest.mark.parametrize(
         "tasks, n, expected",
         [
@@ -22,6 +21,6 @@ def setup_method(self):
             (["A", "B"], 0, 2),
         ],
     )
-    def test_least_interval(self, tasks: list[str], n: int, expected: int):
-        result = run_least_interval(Solution, tasks, n)
+    def test_least_interval(self, tasks: list[str], n: int, expected: int, solution_class: type):
+        result = run_least_interval(solution_class, tasks, n)
         assert_least_interval(result, expected)

leetcode/validate_binary_search_tree/solution.py

@@ -1,3 +1,5 @@
+from collections import deque
+
 from leetcode_py import TreeNode
 
 
@@ -15,3 +17,45 @@ def validate(cls, node: TreeNode[int] | None, min_val: float, max_val: float) ->
     # Space: O(h)
     def is_valid_bst(self, root: TreeNode[int] | None) -> bool:
         return self.validate(root, float("-inf"), float("inf"))
+
+
+class SolutionDFS:
+    # Time: O(n)
+    # Space: O(h)
+    def is_valid_bst(self, root: TreeNode[int] | None) -> bool:
+        if not root:
+            return True
+
+        stack = [(root, float("-inf"), float("inf"))]
+
+        while stack:
+            node, min_val, max_val = stack.pop()
+            if node.val <= min_val or node.val >= max_val:
+                return False
+            if node.right:
+                stack.append((node.right, node.val, max_val))
+            if node.left:
+                stack.append((node.left, min_val, node.val))
+
+        return True
+
+
+class SolutionBFS:
+    # Time: O(n)
+    # Space: O(w) where w is max width
+    def is_valid_bst(self, root: TreeNode[int] | None) -> bool:
+        if not root:
+            return True
+
+        queue = deque([(root, float("-inf"), float("inf"))])
+
+        while queue:
+            node, min_val, max_val = queue.popleft()
+            if node.val <= min_val or node.val >= max_val:
+                return False
+            if node.right:
+                queue.append((node.right, node.val, max_val))
+            if node.left:
+                queue.append((node.left, min_val, node.val))
+
+        return True

leetcode/validate_binary_search_tree/test_solution.py

@@ -3,14 +3,13 @@
 from leetcode_py.test_utils import logged_test
 
 from .helpers import assert_is_valid_bst, run_is_valid_bst
-from .solution import Solution
+from .solution import Solution, SolutionBFS, SolutionDFS
 
 
 class TestValidateBinarySearchTree:
-    def setup_method(self):
-        self.solution = Solution()
 
     @logged_test
+    @pytest.mark.parametrize("solution_class", [Solution, SolutionDFS, SolutionBFS])
     @pytest.mark.parametrize(
         "root_list, expected",
         [
@@ -22,6 +21,6 @@ def setup_method(self):
             ([2, 1, 3, None, None, None, 4], True),
         ],
     )
-    def test_is_valid_bst(self, root_list: list[int | None], expected: bool):
-        result = run_is_valid_bst(Solution, root_list)
+    def test_is_valid_bst(self, root_list: list[int | None], expected: bool, solution_class: type):
+        result = run_is_valid_bst(solution_class, root_list)
         assert_is_valid_bst(result, expected)