feat: update

Author: wislertt

.amazonq/plans/migrate_problems_to_new_template.md

@@ -4,15 +4,20 @@ Migrate problems from `.templates/leetcode/json_old/` to `.templates/leetcode/js
 
 ## Migration Steps
 
-1. **Create JSON**: Analyze old format, create new template in `.templates/leetcode/json/`
+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**: If only 2-3 cases, add edge cases (update JSON → regenerate → lint → test)
+6. **Enhance tests**: Review test coverage - check if cases cover edge scenarios:
+    - 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)
 
 ## Progress
 

.github/workflows/ci-test-reproducibility.yml

@@ -35,17 +35,6 @@ jobs:
             - name: Install dependencies
               run: poetry install --no-interaction --no-ansi
 
-            # - name: Cache Graphviz
-            #   id: cache-graphviz
-            #   uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
-            #   with:
-            #       path: /usr/bin/dot
-            #       key: graphviz-${{ runner.os }}
-
-            # - name: Install Graphviz
-            #   if: steps.cache-graphviz.outputs.cache-hit != 'true'
-            #   run: sudo apt-get update && sudo apt-get install -y graphviz
-
             - name: Delete existing problems
               run: rm -rf leetcode/*/
 

.templates/leetcode/json/add_binary.json

@@ -0,0 +1,60 @@
+{
+    "problem_name": "add_binary",
+    "solution_class_name": "Solution",
+    "problem_number": "67",
+    "problem_title": "Add Binary",
+    "difficulty": "Easy",
+    "topics": "Math, String, Bit Manipulation, Simulation",
+    "_tags": { "list": ["grind-75"] },
+    "readme_description": "Given two binary strings `a` and `b`, return *their sum as a binary string*.",
+    "_readme_examples": {
+        "list": [
+            { "content": "```\nInput: a = \"11\", b = \"1\"\nOutput: \"100\"\n```" },
+            { "content": "```\nInput: a = \"1010\", b = \"1011\"\nOutput: \"10101\"\n```" }
+        ]
+    },
+    "readme_constraints": "- `1 <= a.length, b.length <= 10^4`\n- `a` and `b` consist only of `'0'` or `'1'` characters.\n- Each string does not contain leading zeros except for the zero itself.",
+    "readme_additional": "",
+    "helpers_imports": "",
+    "helpers_content": "",
+    "helpers_run_name": "add_binary",
+    "helpers_run_signature": "(solution_class: type, a: str, b: str)",
+    "helpers_run_body": "    implementation = solution_class()\n    return implementation.add_binary(a, b)",
+    "helpers_assert_name": "add_binary",
+    "helpers_assert_signature": "(result: str, expected: str) -> 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_add_binary, run_add_binary\nfrom .solution import Solution",
+    "test_content": "",
+    "test_class_name": "AddBinary",
+    "test_class_content": "    def setup_method(self):\n        self.solution = Solution()",
+    "_solution_methods": {
+        "list": [
+            {
+                "name": "add_binary",
+                "signature": "(self, a: str, b: str) -> str",
+                "body": "        # TODO: Implement add_binary\n        return \"\""
+            }
+        ]
+    },
+    "_test_helper_methods": {
+        "list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
+    },
+    "_test_methods": {
+        "list": [
+            {
+                "name": "test_add_binary",
+                "signature": "(self, a: str, b: str, expected: str)",
+                "parametrize": "a, b, expected",
+                "test_cases": "[('11', '1', '100'), ('1010', '1011', '10101'), ('0', '0', '0'), ('1', '1', '10'), ('1111', '1111', '11110'), ('1', '0', '1'), ('0', '1', '1'), ('1', '111', '1000'), ('111', '1', '1000'), ('1010', '1', '1011'), ('1111', '1', '10000')]",
+                "body": "        result = run_add_binary(Solution, a, b)\n        assert_add_binary(result, expected)"
+            }
+        ]
+    },
+    "playground_imports": "from helpers import run_add_binary, assert_add_binary\nfrom solution import Solution",
+    "playground_setup": "# Example test case\na = '11'\nb = '1'\nexpected = '100'",
+    "playground_run": "result = run_add_binary(Solution, a, b)\nresult",
+    "playground_assert": "assert_add_binary(result, expected)"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= accounts_merge
+PROBLEM ?= add_binary
 FORCE ?= 0
 COMMA := ,
 

leetcode/add_binary/README.md

@@ -0,0 +1,33 @@
+# Add Binary
+
+**Difficulty:** Easy
+**Topics:** Math, String, Bit Manipulation, Simulation
+**Tags:** grind-75
+
+**LeetCode:** [Problem 67](https://leetcode.com/problems/add-binary/description/)
+
+## Problem Description
+
+Given two binary strings `a` and `b`, return _their sum as a binary string_.
+
+## Examples
+
+### Example 1:
+
+```
+Input: a = "11", b = "1"
+Output: "100"
+```
+
+### Example 2:
+
+```
+Input: a = "1010", b = "1011"
+Output: "10101"
+```
+
+## Constraints
+
+- `1 <= a.length, b.length <= 10^4`
+- `a` and `b` consist only of `'0'` or `'1'` characters.
+- Each string does not contain leading zeros except for the zero itself.

leetcode/add_binary/__init__.py

@@ -0,0 +1,8 @@
+def run_add_binary(solution_class: type, a: str, b: str):
+    implementation = solution_class()
+    return implementation.add_binary(a, b)
+
+
+def assert_add_binary(result: str, expected: str) -> bool:
+    assert result == expected
+    return True

leetcode/add_binary/helpers.py

@@ -0,0 +1,69 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from helpers import assert_add_binary, run_add_binary\n",
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "a = \"11\"\n",
+    "b = \"1\"\n",
+    "expected = \"100\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "run",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "result = run_add_binary(Solution, a, b)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "assert",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert_add_binary(result, expected)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/add_binary/playground.ipynb

@@ -0,0 +1,26 @@
+class Solution:
+    # Time: O(len(a) + len(b))
+    # Space: O(len(a) + len(b))
+    def add_binary(self, a: str, b: str) -> str:
+        # int(a, 2) converts binary string to decimal: int("11", 2) → 3
+        # bin() converts decimal to binary string with prefix: bin(3) → '0b11'
+        # [2:] removes the '0b' prefix to get just binary digits
+        return bin(int(a, 2) + int(b, 2))[2:]
+
+
+# Python Base Conversion:
+#
+# String → Integer (using int() with base parameter):
+# - int("1010", 2) → 10 (binary to decimal)
+# - int("ff", 16) → 255 (hex to decimal)
+# - int("10", 8) → 8 (octal to decimal)
+#
+# Integer → String (conversion functions add prefixes):
+# - bin(10) → '0b1010' (binary with '0b' prefix)
+# - hex(255) → '0xff' (hex with '0x' prefix)
+# - oct(8) → '0o10' (octal with '0o' prefix)
+#
+# These prefixes match Python literal syntax:
+# - 0b1010 = 10, 0xff = 255, 0o10 = 8
+#
+# For string problems, slice off the prefix: bin(n)[2:] gives just the digits.

leetcode/add_binary/solution.py

@@ -0,0 +1,32 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .helpers import assert_add_binary, run_add_binary
+from .solution import Solution
+
+
+class TestAddBinary:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @logged_test
+    @pytest.mark.parametrize(
+        "a, b, expected",
+        [
+            ("11", "1", "100"),
+            ("1010", "1011", "10101"),
+            ("0", "0", "0"),
+            ("1", "1", "10"),
+            ("1111", "1111", "11110"),
+            ("1", "0", "1"),
+            ("0", "1", "1"),
+            ("1", "111", "1000"),
+            ("111", "1", "1000"),
+            ("1010", "1", "1011"),
+            ("1111", "1", "10000"),
+        ],
+    )
+    def test_add_binary(self, a: str, b: str, expected: str):
+        result = run_add_binary(Solution, a, b)
+        assert_add_binary(result, expected)