feat: add 14 more leetcode problems (#58)

Author: wislertt

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= valid_sudoku
+PROBLEM ?= find_k_closest_elements
 FORCE ?= 0
 COMMA := ,
 

docs/llm-assisted-problem-creation.md

@@ -121,7 +121,6 @@ make p-test PROBLEM={problem_name}
 
 - Assistant will automatically fix JSON template issues
 - Re-runs generation until linting passes
-- If JSON template fails after many iterations, ask agent to review the example template carefully as mentioned in the rules
 
 **Test failures:**
 

leetcode/contiguous_array/README.md

@@ -0,0 +1,42 @@
+# Contiguous Array
+
+**Difficulty:** Medium
+**Topics:** Array, Hash Table, Prefix Sum
+**Tags:** grind
+
+**LeetCode:** [Problem 525](https://leetcode.com/problems/contiguous-array/description/)
+
+## Problem Description
+
+Given a binary array `nums`, return _the maximum length of a contiguous subarray with an equal number of_ `0` _and_ `1`.
+
+## Examples
+
+### Example 1:
+
+```
+Input: nums = [0,1]
+Output: 2
+Explanation: [0, 1] is the longest contiguous subarray with an equal number of 0 and 1.
+```
+
+### Example 2:
+
+```
+Input: nums = [0,1,0]
+Output: 2
+Explanation: [0, 1] (or [1, 0]) is a longest contiguous subarray with equal number of 0 and 1.
+```
+
+### Example 3:
+
+```
+Input: nums = [0,1,1,1,1,1,0,0,0]
+Output: 6
+Explanation: [1,1,1,0,0,0] is the longest contiguous subarray with equal number of 0 and 1.
+```
+
+## Constraints
+
+- `1 <= nums.length <= 10^5`
+- `nums[i]` is either `0` or `1`.

leetcode/contiguous_array/__init__.py

@@ -0,0 +1,8 @@
+def run_find_max_length(solution_class: type, nums: list[int]):
+    implementation = solution_class()
+    return implementation.find_max_length(nums)
+
+
+def assert_find_max_length(result: int, expected: int) -> bool:
+    assert result == expected
+    return True

leetcode/contiguous_array/helpers.py

@@ -0,0 +1,29 @@
+# ---
+# jupyter:
+#   jupytext:
+#     text_representation:
+#       extension: .py
+#       format_name: percent
+#       format_version: '1.3'
+#       jupytext_version: 1.17.3
+#   kernelspec:
+#     display_name: leetcode-py-py3.13
+#     language: python
+#     name: python3
+# ---
+
+# %%
+from helpers import assert_find_max_length, run_find_max_length
+from solution import Solution
+
+# %%
+# Example test case
+nums = [0, 1]
+expected = 2
+
+# %%
+result = run_find_max_length(Solution, nums)
+result
+
+# %%
+assert_find_max_length(result, expected)

leetcode/contiguous_array/playground.py

@@ -0,0 +1,18 @@
+class Solution:
+
+    # Time: O(n)
+    # Space: O(n)
+    def find_max_length(self, nums: list[int]) -> int:
+        count_map = {0: -1}
+        count = 0
+        max_len = 0
+
+        for i, num in enumerate(nums):
+            count += 1 if num == 1 else -1
+
+            if count in count_map:
+                max_len = max(max_len, i - count_map[count])
+            else:
+                count_map[count] = i
+
+        return max_len

leetcode/contiguous_array/solution.py

@@ -0,0 +1,38 @@
+import pytest
+
+from leetcode_py import logged_test
+
+from .helpers import assert_find_max_length, run_find_max_length
+from .solution import Solution
+
+
+class TestContiguousArray:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @logged_test
+    @pytest.mark.parametrize(
+        "nums, expected",
+        [
+            ([0, 1], 2),
+            ([0, 1, 0], 2),
+            ([0, 1, 1, 1, 1, 1, 0, 0, 0], 6),
+            ([0], 0),
+            ([1], 0),
+            ([0, 0], 0),
+            ([1, 1], 0),
+            ([0, 0, 1, 0, 0, 1, 1, 0], 6),
+            ([1, 0, 1, 0, 1], 4),
+            ([0, 1, 1, 0, 1, 1, 1, 0], 4),
+            ([1, 1, 1, 1, 1, 1, 1, 1], 0),
+            ([0, 0, 0, 0, 0, 0, 0, 0], 0),
+            ([1, 0, 1, 1, 0, 0, 1, 0, 1], 8),
+            ([0, 1, 0, 1, 0, 1, 0, 1], 8),
+            ([1, 0, 0, 1, 1, 0, 1, 0, 0, 1], 10),
+            ([0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0], 10),
+            ([1, 1, 0, 0, 1, 1, 0, 0, 1, 1], 8),
+        ],
+    )
+    def test_find_max_length(self, nums: list[int], expected: int):
+        result = run_find_max_length(Solution, nums)
+        assert_find_max_length(result, expected)

leetcode/contiguous_array/test_solution.py

@@ -0,0 +1,50 @@
+# Course Schedule II
+
+**Difficulty:** Medium
+**Topics:** Depth-First Search, Breadth-First Search, Graph, Topological Sort
+**Tags:** grind
+
+**LeetCode:** [Problem 210](https://leetcode.com/problems/course-schedule-ii/description/)
+
+## Problem Description
+
+There are a total of `numCourses` courses you have to take, labeled from `0` to `numCourses - 1`. You are given an array `prerequisites` where `prerequisites[i] = [ai, bi]` indicates that you **must** take course `bi` first if you want to take course `ai`.
+
+- For example, the pair `[0, 1]`, indicates that to take course `0` you have to first take course `1`.
+
+Return the ordering of courses you should take to finish all courses. If there are many valid answers, return **any** of them. If it is impossible to finish all courses, return **an empty array**.
+
+## Examples
+
+### Example 1:
+
+```
+Input: numCourses = 2, prerequisites = [[1,0]]
+Output: [0,1]
+Explanation: There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1].
+```
+
+### Example 2:
+
+```
+Input: numCourses = 4, prerequisites = [[1,0],[2,0],[3,1],[3,2]]
+Output: [0,2,1,3]
+Explanation: There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0.
+So one correct course order is [0,1,2,3]. Another correct ordering is [0,2,1,3].
+```
+
+### Example 3:
+
+```
+Input: numCourses = 1, prerequisites = []
+Output: [0]
+```
+
+## Constraints
+
+- `1 <= numCourses <= 2000`
+- `0 <= prerequisites.length <= numCourses * (numCourses - 1)`
+- `prerequisites[i].length == 2`
+- `0 <= ai, bi < numCourses`
+- `ai != bi`
+- All the pairs `[ai, bi]` are **distinct**.