feat: add more problems

Author: wislertt

.amazonq/plans/create_template_example.md

@@ -4,20 +4,24 @@ Migrate problems from `.templates/leetcode/json_old/` to `.templates/leetcode/js
 
 ## Migration Steps
 
+**Note**: Commands require UI confirmation popup - click "Run" when prompted for `make` commands.
+
 1. **Create JSON**: Analyze old format, create new template in `.templates/leetcode/json/` (reference `.templates/leetcode/examples/` for format)
 2. **Generate**: `make p-gen PROBLEM=<name>`
 3. **Lint**: `make p-lint PROBLEM=<name>` (fix JSON if fails, regenerate with `FORCE=1`)
-4. **Implement**: Look at `leetcode_old/` code - copy solution with all comments/notes and review test cases
-    - **Important**: Re-copy solution after `p-gen` since it overwrites with TODO placeholders
-    - **Multiple solutions**: If old code has alternative implementations (e.g., Solution, SolutionDFS, SolutionBFS),
-      add parametrize to test all classes (see lru_cache as example)
-5. **Test**: `make p-test PROBLEM=<name>`
-6. **Enhance tests**: Review test coverage - check if cases cover edge scenarios:
+4. **Enhance tests**: Review test coverage - check if cases cover edge scenarios:
+    - **Check old tests**: Examine `leetcode_old/<problem>/tests.py` for comprehensive test coverage
+    - **Update JSON**: Add relevant/generalizable test cases to JSON template (exclude problem-specific error handling)
     - Boundary values (min/max constraints, empty inputs)
     - Different input sizes/lengths
     - Zero/null cases, single elements
     - Error conditions, special values
     - If only 2-3 basic cases, add comprehensive edge cases (update JSON → regenerate with `FORCE=1` → lint → re-copy solution → test)
+5. **Implement**: Look at `leetcode_old/` code - copy solution with all comments/notes
+    - **Important**: Re-copy solution after `p-gen` since it overwrites with TODO placeholders
+    - **Multiple solutions**: If old code has alternative implementations (e.g., Solution, SolutionDFS, SolutionBFS),
+      add parametrize to test all classes (see lru_cache as example)
+6. **Test**: `make p-test PROBLEM=<name>` (edit JSON and revalidate for reproducibility if needed)
 
 ## Progress
 

.amazonq/plans/migrate_problems_to_new_template.md

@@ -0,0 +1,65 @@
+{
+    "problem_name": "balanced_binary_tree",
+    "solution_class_name": "Solution",
+    "problem_number": "110",
+    "problem_title": "Balanced Binary Tree",
+    "difficulty": "Easy",
+    "topics": "Tree, Depth-First Search, Binary Tree",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Given a binary tree, determine if it is **height-balanced**.\n\nA height-balanced binary tree is a binary tree in which the depth of the two subtrees of every node never differs by more than one.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "![Example 1](https://assets.leetcode.com/uploads/2020/10/06/balance_1.jpg)\n\n```\nInput: root = [3,9,20,null,null,15,7]\nOutput: true\n```"
+            },
+            {
+                "content": "![Example 2](https://assets.leetcode.com/uploads/2020/10/06/balance_2.jpg)\n\n```\nInput: root = [1,2,2,3,3,null,null,4,4]\nOutput: false\n```"
+            },
+            { "content": "```\nInput: root = []\nOutput: true\n```" }
+        ]
+    },
+    "readme_constraints": "- The number of nodes in the tree is in the range `[0, 5000]`.\n- `-10^4 <= Node.val <= 10^4`",
+    "readme_additional": "",
+    "helpers_imports": "from leetcode_py import TreeNode",
+    "helpers_content": "",
+    "helpers_run_name": "is_balanced",
+    "helpers_run_signature": "(solution_class: type, root_list: list[int | None])",
+    "helpers_run_body": "    implementation = solution_class()\n    root = TreeNode.from_list(root_list)\n    return implementation.is_balanced(root)",
+    "helpers_assert_name": "is_balanced",
+    "helpers_assert_signature": "(result: bool, expected: bool) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "from leetcode_py import TreeNode",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_is_balanced, run_is_balanced\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BalancedBinaryTree",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "is_balanced",
+                "signature": "(self, root: TreeNode[int] | None) -> bool",
+                "body": "        # TODO: Implement is_balanced\n        return False"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_is_balanced",
+                "signature": "(self, root_list: list[int | None], expected: bool)",
+                "parametrize": "root_list, expected",
+                "test_cases": "[([3, 9, 20, None, None, 15, 7], True), ([1, 2, 2, 3, 3, None, None, 4, 4], False), ([], True), ([1], True), ([1, 2], True), ([1, None, 2], True), ([1, 2, 3, 4], True), ([1, 2, 2, 3, None, None, 3, 4, None, None, 4], False)]",
+                "body": "        result = run_is_balanced(Solution, root_list)\n        assert_is_balanced(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_is_balanced, assert_is_balanced\nfrom solution import Solution\nfrom leetcode_py import TreeNode",
+    "playground_setup": "# Example test case\nroot_list: list[int | None] = [3, 9, 20, None, None, 15, 7]\nexpected = True",
+    "playground_run": "result = run_is_balanced(Solution, root_list)\nresult",
+    "playground_assert": "assert_is_balanced(result, expected)"
+}

.templates/leetcode/json/balanced_binary_tree.json

@@ -0,0 +1,61 @@
+{
+    "problem_name": "basic_calculator",
+    "solution_class_name": "Solution",
+    "problem_number": "224",
+    "problem_title": "Basic Calculator",
+    "difficulty": "Hard",
+    "topics": "Math, String, Stack, Recursion",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Given a string `s` representing a valid expression, implement a basic calculator to evaluate it, and return the result of the evaluation.\n\n**Note:** You are **not** allowed to use any built-in function which evaluates strings as mathematical expressions, such as `eval()`.",
+    "_readme_examples": {
+        "list": [
+            { "content": "```\nInput: s = \"1 + 1\"\nOutput: 2\n```" },
+            { "content": "```\nInput: s = \" 2-1 + 2 \"\nOutput: 3\n```" },
+            { "content": "```\nInput: s = \"(1+(4+5+2)-3)+(6+8)\"\nOutput: 23\n```" }
+        ]
+    },
+    "readme_constraints": "- `1 <= s.length <= 3 * 10^5`\n- `s` consists of digits, `'+'`, `'-'`, `'('`, `')'`, and `' '`.\n- `s` represents a valid expression.\n- `'+'` is **not** used as a unary operation (i.e., `\"+1\"` and `\"+(2 + 3)\"` is invalid).\n- `'-'` could be used as a unary operation (i.e., `\"-1\"` and `\"-(2 + 3)\"` is valid).\n- There will be no two consecutive operators in the input.\n- Every number and running calculation will fit in a signed 32-bit integer.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "calculate",
+    "helpers_run_signature": "(solution_class: type, s: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.calculate(s)",
+    "helpers_assert_name": "calculate",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_calculate, run_calculate\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BasicCalculator",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "calculate",
+                "signature": "(self, s: str) -> int",
+                "body": "        # TODO: Implement calculate\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_calculate",
+                "signature": "(self, s: str, expected: int)",
+                "parametrize": "s, expected",
+                "test_cases": "[('1 + 1', 2), (' 2-1 + 2 ', 3), ('(1+(4+5+2)-3)+(6+8)', 23), ('1', 1), ('-1', -1), ('-(1+2)', -3), ('2147483647', 2147483647), ('1-1+1', 1), ('0', 0), ('-0', 0), ('1+(2+3)', 6), ('(1+2)+3', 6), ('1-(2+3)', -4), ('(1-2)+3', 2), ('-(-1)', 1), ('-(-(-1))', -1), ('1000000-999999', 1), ('10+20-30+40', 40), ('((1+2)+(3+4))', 10), ('1+(2-(3+4))', -4), ('-(1+(2+3))', -6), ('   1   +   2   ', 3), ('123+456', 579), ('-2147483648', -2147483648)]",
+                "body": "        result = run_calculate(Solution, s)\n        assert_calculate(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_calculate, assert_calculate\nfrom solution import Solution",
+    "playground_setup": "# Example test case\ns = '(1+(4+5+2)-3)+(6+8)'\nexpected = 23",
+    "playground_run": "result = run_calculate(Solution, s)\nresult",
+    "playground_assert": "assert_calculate(result, expected)"
+}

.templates/leetcode/json/basic_calculator.json

@@ -0,0 +1,64 @@
+{
+    "problem_name": "best_time_to_buy_and_sell_stock",
+    "solution_class_name": "Solution",
+    "problem_number": "121",
+    "problem_title": "Best Time to Buy and Sell Stock",
+    "difficulty": "Easy",
+    "topics": "Array, Dynamic Programming",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "You are given an array `prices` where `prices[i]` is the price of a given stock on the ith day.\n\nYou want to maximize your profit by choosing a **single day** to buy one stock and choosing a **different day in the future** to sell that stock.\n\nReturn *the maximum profit you can achieve from this transaction*. If you cannot achieve any profit, return `0`.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: prices = [7,1,5,3,6,4]\nOutput: 5\n```\n**Explanation:** Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.\nNote that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell."
+            },
+            {
+                "content": "```\nInput: prices = [7,6,4,3,1]\nOutput: 0\n```\n**Explanation:** In this case, no transactions are done and the max profit = 0."
+            }
+        ]
+    },
+    "readme_constraints": "- 1 <= prices.length <= 10^5\n- 0 <= prices[i] <= 10^4",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "max_profit",
+    "helpers_run_signature": "(solution_class: type, prices: list[int])",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.max_profit(prices)",
+    "helpers_assert_name": "max_profit",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_max_profit, run_max_profit\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BestTimeToBuyAndSellStock",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "max_profit",
+                "signature": "(self, prices: list[int]) -> int",
+                "body": "        # TODO: Implement max_profit\n        return 0"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_max_profit",
+                "signature": "(self, prices: list[int], expected: int)",
+                "parametrize": "prices, expected",
+                "test_cases": "[([7, 1, 5, 3, 6, 4], 5), ([7, 6, 4, 3, 1], 0), ([1, 2, 3, 4, 5], 4), ([5, 4, 3, 2, 1], 0), ([1], 0), ([2, 1], 0), ([1, 2], 1), ([3, 2, 6, 5, 0, 3], 4)]",
+                "body": "        result = run_max_profit(Solution, prices)\n        assert_max_profit(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_max_profit, assert_max_profit\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nprices = [7, 1, 5, 3, 6, 4]\nexpected = 5",
+    "playground_run": "result = run_max_profit(Solution, prices)\nresult",
+    "playground_assert": "assert_max_profit(result, expected)"
+}

.templates/leetcode/json/best_time_to_buy_and_sell_stock.json

@@ -0,0 +1,64 @@
+{
+    "problem_name": "binary_search",
+    "solution_class_name": "Solution",
+    "problem_number": "704",
+    "problem_title": "Binary Search",
+    "difficulty": "Easy",
+    "topics": "Array, Binary Search",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Given an array of integers `nums` which is sorted in ascending order, and an integer `target`, write a function to search `target` in `nums`. If `target` exists, then return its index. Otherwise, return `-1`.\n\nYou must write an algorithm with `O(log n)` runtime complexity.",
+    "_readme_examples": {
+        "list": [
+            {
+                "content": "```\nInput: nums = [-1,0,3,5,9,12], target = 9\nOutput: 4\n```\n**Explanation:** 9 exists in nums and its index is 4"
+            },
+            {
+                "content": "```\nInput: nums = [-1,0,3,5,9,12], target = 2\nOutput: -1\n```\n**Explanation:** 2 does not exist in nums so return -1"
+            }
+        ]
+    },
+    "readme_constraints": "- `1 <= nums.length <= 10^4`\n- `-10^4 < nums[i], target < 10^4`\n- All the integers in `nums` are **unique**.\n- `nums` is sorted in ascending order.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "search",
+    "helpers_run_signature": "(solution_class: type, nums: list[int], target: int)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.search(nums, target)",
+    "helpers_assert_name": "search",
+    "helpers_assert_signature": "(result: int, expected: int) -> bool",
+    "helpers_assert_body": "    assert result == expected\n    return True",
+    "solution_imports": "",
+    "solution_contents": "",
+    "solution_class_content": "",
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_search, run_search\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "BinarySearch",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "search",
+                "signature": "(self, nums: list[int], target: int) -> int",
+                "body": "        # TODO: Implement search\n        return -1"
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_search",
+                "signature": "(self, nums: list[int], target: int, expected: int)",
+                "parametrize": "nums, target, expected",
+                "test_cases": "[([-1, 0, 3, 5, 9, 12], 9, 4), ([-1, 0, 3, 5, 9, 12], 2, -1), ([5], 5, 0), ([5], -5, -1), ([1, 3, 5, 7, 9], 1, 0), ([1, 3, 5, 7, 9], 9, 4), ([1, 3, 5, 7, 9], 4, -1), ([1, 3], 1, 0), ([1, 3], 3, 1), ([1, 3], 2, -1), ([-5, -2, 0, 3, 7], -2, 1), ([-5, -2, 0, 3, 7], 0, 2), ([-5, -2, 0, 3, 7], -1, -1)]",
+                "body": "        result = run_search(Solution, nums, target)\n        assert_search(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_search, assert_search\nfrom solution import Solution",
+    "playground_setup": "# Example test case\nnums = [-1, 0, 3, 5, 9, 12]\ntarget = 9\nexpected = 4",
+    "playground_run": "result = run_search(Solution, nums, target)\nresult",
+    "playground_assert": "assert_search(result, expected)"
+}