feat: dev

Author: wislertt

.amazonq/rules/problem-creation.md

@@ -9,7 +9,8 @@ When user requests a problem by **number** or **name/slug**, the assistant will:
 3. **Create** JSON file in `.templates/leetcode/json/{problem_name}.json`
 4. **Update** Makefile with `PROBLEM ?= {problem_name}`
 5. **Generate** problem structure using `make p-gen`
-6. **Verify** with `make lint`
+6. **Verify** with `make lint` - fix template issues in JSON if possible, or manually fix generated files if template limitations
+7. **Iterate** if JSON fixes: re-run `make p-gen PROBLEM={problem_name} FORCE=1` and `make lint` until passes to ensure reproducibility
 
 ## Scraping Commands
 

.templates/leetcode/json/lru_cache.json

@@ -0,0 +1,42 @@
+{
+    "problem_name": "lru_cache",
+    "class_name": "LRUCache",
+    "method_name": "lru_cache",
+    "problem_number": "146",
+    "problem_title": "LRU Cache",
+    "difficulty": "Medium",
+    "topics": "Hash Table, Linked List, Design, Doubly-Linked List",
+    "tags": ["grind-75", "top-interview"],
+    "problem_description": "Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.\n\nImplement the LRUCache class:\n\n- LRUCache(int capacity) Initialize the LRU cache with positive size capacity.\n- int get(int key) Return the value of the key if the key exists, otherwise return -1.\n- void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.\n\nThe functions get and put must each run in O(1) average time complexity.",
+    "examples": [
+        {
+            "input": "[\"LRUCache\", \"put\", \"put\", \"get\", \"put\", \"get\", \"put\", \"get\", \"get\", \"get\"]\n[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]",
+            "output": "[null, null, null, 1, null, -1, null, -1, 3, 4]"
+        }
+    ],
+    "constraints": "- 1 <= capacity <= 3000\n- 0 <= key <= 10^4\n- 0 <= value <= 10^5\n- At most 2 * 10^5 calls will be made to get and put.",
+    "parameters": "capacity: int",
+    "return_type": "None",
+    "dummy_return": "None",
+    "imports": "",
+    "test_cases": [
+        {
+            "args": [
+                ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"],
+                [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+            ],
+            "expected": [null, null, null, 1, null, -1, null, -1, 3, 4]
+        }
+    ],
+    "param_names": "operations, inputs, expected",
+    "param_names_with_types": "operations: list[str], inputs: list[list[int]], expected: list[int | None]",
+    "input_description": "operations={operations}, inputs={inputs}",
+    "input_params": "operations, inputs",
+    "expected_param": "expected",
+    "method_args": "operations, inputs",
+    "test_setup": "cache = None\nresult = []\nfor i, op in enumerate(operations):\n    if op == \"LRUCache\":\n        cache = LRUCache(inputs[i][0])\n        result.append(None)\n    elif op == \"get\":\n        result.append(cache.get(inputs[i][0]))\n    elif op == \"put\":\n        cache.put(inputs[i][0], inputs[i][1])\n        result.append(None)",
+    "test_logging": "logger.info(f\"Testing LRU Cache with operations: {operations}\")\nlogger.info(f\"Inputs: {inputs}\")\nlogger.info(f\"Expected: {expected}\")\nlogger.info(f\"Result: {result}\")",
+    "assertion_code": "assert result == expected",
+    "test_input_setup": "operations = [\"LRUCache\", \"put\", \"put\", \"get\", \"put\", \"get\", \"put\", \"get\", \"get\", \"get\"]\ninputs = [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]",
+    "expected_output_setup": "expected = [None, None, None, 1, None, -1, None, -1, 3, 4]"
+}

.templates/leetcode/scrape.py

@@ -31,6 +31,9 @@ def fetch(
     if number:
         problem = scraper.get_problem_by_number(number)
     else:
+        if slug is None:
+            typer.echo("Error: Slug cannot be None", err=True)
+            raise typer.Exit(1)
         problem = scraper.get_problem_by_slug(slug)
 
     if not problem:

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= spiral_matrix
+PROBLEM ?= lru_cache
 FORCE ?= 0
 
 sync_submodules:

README.md

@@ -9,28 +9,32 @@
 
 Premium LeetCode practice repository with Python solutions, algorithm templates, data structure visualizations, and automated testing. Perfect for coding interview preparation, competitive programming, and mastering algorithms with Blind 75, Grind 75, and NeetCode 150 problems.
 
-## 📋 Prerequisites
-
-- Python 3.13+
-- make, git, Graphviz, poetry
-
-## 🛠️ Installation
+## 🚀 Quick Start
 
 ```bash
 # Clone the repository
 git clone https://github.com/wisarootl/leetcode-py.git
 cd leetcode-py
 
 # Install dependencies
-pip install -r requirements.txt
+poetry install
 
-# Generate all problems
+# Generate all problems to start practicing (fresh start - wipes all solutions)
 make gen-all-problems
 
-# Verify setup
+# Run existing problems
+make p-test PROBLEM=insert_interval
+make p-test PROBLEM=invert_binary_tree
+
+# Run all tests
 make test
 ```
 
+## 📋 Prerequisites
+
+- Python 3.13+
+- make, git, Graphviz, poetry
+
 ## 📁 Problem Structure
 
 Each problem follows a consistent template:
@@ -91,20 +95,6 @@ _Interactive multi-cell playground for each problem_
 - **Full linting** - black, isort, ruff, mypy with nbqa for notebooks
 - **Modern Python** - PEP 585/604 syntax with full type hints
 
-## 🚀 Quick Start
-
-```bash
-# Generate all problems to start practicing
-make gen-all-problems
-
-# Run existing problems
-make p-test PROBLEM=insert_interval
-make p-test PROBLEM=invert_binary_tree
-
-# Run all tests
-make test
-```
-
 ## 🔄 Workflow Examples
 
 **Practice existing problems**:
@@ -119,18 +109,12 @@ make p-test PROBLEM=two_sum
 **Add new problems**:
 
 ```bash
-# Copy problem description and solution placeholder from LeetCode
-# Then ask your LLM assistant:
-# "Create a new LeetCode problem for Valid Anagram"
-#
-# Behind the scenes, the LLM will:
-# 1. Create JSON template following .amazonq/rules/problem-creation.md
-# 2. Run `make p-gen PROBLEM=valid_anagram`
-# 3. Generate complete problem structure with tests
-# 4. You just implement the solution!
+# Ask your LLM assistant:
+# "Create LeetCode problem 146 (LRU Cache)"
+# The assistant handles everything automatically!
 ```
 
-_The LLM follows structured rules in `.amazonq/rules/problem-creation.md` to ensure consistent, high-quality problem generation using proven templates._
+_Behind the scenes: Assistant follows `.amazonq/rules/problem-creation.md` to scrape problem data, create JSON template, generate structure with `make p-gen`, and verify with `make lint`._
 
 **Bulk operations**:
 

leetcode/lru_cache/README.md

@@ -0,0 +1,35 @@
+# 146. LRU Cache
+
+**Difficulty:** Medium
+**Topics:** Hash Table, Linked List, Design, Doubly-Linked List
+**Tags:** grind-75, top-interview
+**LeetCode:** [Problem 146](https://leetcode.com/problems/lru-cache/description/)
+
+## Problem Description
+
+Design a data structure that follows the constraints of a Least Recently Used (LRU) cache.
+
+Implement the LRUCache class:
+
+- LRUCache(int capacity) Initialize the LRU cache with positive size capacity.
+- int get(int key) Return the value of the key if the key exists, otherwise return -1.
+- void put(int key, int value) Update the value of the key if the key exists. Otherwise, add the key-value pair to the cache. If the number of keys exceeds the capacity from this operation, evict the least recently used key.
+
+The functions get and put must each run in O(1) average time complexity.
+
+## Examples
+
+### Example 1:
+
+```
+Input: ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
+[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+Output: [null, null, null, 1, null, -1, null, -1, 3, 4]
+```
+
+## Constraints
+
+- 1 <= capacity <= 3000
+- 0 <= key <= 10^4
+- 0 <= value <= 10^5
+- At most 2 \* 10^5 calls will be made to get and put.

leetcode/lru_cache/__init__.py

@@ -0,0 +1,89 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import LRUCache"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "operations = [\"LRUCache\", \"put\", \"put\", \"get\", \"put\", \"get\", \"put\", \"get\", \"get\", \"get\"]\n",
+    "inputs = [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]\n",
+    "expected = [None, None, None, 1, None, -1, None, -1, 3, 4]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None, None, None, 1, None, -1, None, -1, 3, 4]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "cache: LRUCache | None = None\n",
+    "result: list[int | None] = []\n",
+    "for i, op in enumerate(operations):\n",
+    "    if op == \"LRUCache\":\n",
+    "        cache = LRUCache(inputs[i][0])\n",
+    "        result.append(None)\n",
+    "    elif op == \"get\" and cache is not None:\n",
+    "        result.append(cache.get(inputs[i][0]))\n",
+    "    elif op == \"put\" and cache is not None:\n",
+    "        cache.put(inputs[i][0], inputs[i][1])\n",
+    "        result.append(None)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert 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": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/lru_cache/playground.ipynb

@@ -0,0 +1,33 @@
+from collections import OrderedDict
+
+
+class LRUCache:
+    # Space: O(capacity)
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self.cache: OrderedDict[int, int] = OrderedDict()
+
+    # Time: O(1)
+    # Space: O(1)
+    def get(self, key: int) -> int:
+        if key not in self.cache:
+            return -1
+
+        # Move to end (most recent)
+        self.cache.move_to_end(key)
+        return self.cache[key]
+
+    # Time: O(1)
+    # Space: O(1)
+    def put(self, key: int, value: int) -> None:
+        if key in self.cache:
+            # Update existing and move to end
+            self.cache[key] = value
+            self.cache.move_to_end(key)
+        else:
+            # Add new
+            if len(self.cache) >= self.capacity:
+                # Remove LRU (first item)
+                self.cache.popitem(last=False)
+
+            self.cache[key] = value

leetcode/lru_cache/solution.py

@@ -0,0 +1,39 @@
+import pytest
+from loguru import logger
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import LRUCache
+
+
+class TestLRUCache:
+    @pytest.mark.parametrize(
+        "operations, inputs, expected",
+        [
+            (
+                ["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"],
+                [[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]],
+                [None, None, None, 1, None, -1, None, -1, 3, 4],
+            ),
+        ],
+    )
+    @logged_test
+    def test_lru_cache(self, operations: list[str], inputs: list[list[int]], expected: list[int | None]):
+        logger.info(f"Testing LRU Cache with operations: {operations}")
+        logger.info(f"Inputs: {inputs}")
+        logger.info(f"Expected: {expected}")
+
+        cache: LRUCache | None = None
+        result: list[int | None] = []
+        for i, op in enumerate(operations):
+            if op == "LRUCache":
+                cache = LRUCache(inputs[i][0])
+                result.append(None)
+            elif op == "get" and cache is not None:
+                result.append(cache.get(inputs[i][0]))
+            elif op == "put" and cache is not None:
+                cache.put(inputs[i][0], inputs[i][1])
+                result.append(None)
+
+        logger.info(f"Result: {result}")
+        assert result == expected