feat: add 5 more leetcodes

Author: wislertt

.cursor/.dev/next_problem.py

@@ -6,6 +6,7 @@
 # Import the problem lists
 sys.path.append(str(Path(__file__).parent.parent.parent))
 from problem_lists import available_lists
+from problem_lists.unscrapable import get_unscrapable_numbers
 from problem_lists.utils import get_existing_problems
 
 
@@ -15,6 +16,7 @@ def get_next_problem(tag_names=None):
         tag_names = list(available_lists.keys())
 
     existing_problems = get_existing_problems()
+    unscrapable_numbers = get_unscrapable_numbers()
 
     # Find the list with the lowest missing problems
     best_list = None
@@ -24,7 +26,8 @@ def get_next_problem(tag_names=None):
     for tag_name, problem_tuples in available_lists.items():
         if tag_name in tag_names:
             problem_numbers = {num for num, _ in problem_tuples}
-            missing = problem_numbers - existing_problems
+            # Exclude unscrapable problems from missing problems
+            missing = problem_numbers - existing_problems - unscrapable_numbers
             missing_count = len(missing)
 
             if missing_count > 0 and missing_count < min_missing:

.cursor/.dev/problem_lists/unscrapable.py

@@ -0,0 +1,28 @@
+# Unscrapable Problems List
+# Problems that cannot be scraped due to being premium, having API issues, or other technical limitations
+
+# Format: (problem_number, problem_name)
+UNSCRAPABLE_PROBLEMS = [
+    (252, "meeting-rooms"),
+    (253, "meeting-rooms-ii"),
+    (261, "graph-valid-tree"),
+    (271, "encode-and-decode-strings"),
+    (323, "number-of-connected-components-in-an-undirected-graph"),
+    # Add more unscrapable problems as discovered
+]
+
+
+# Helper function to check if a problem is unscrapable
+def is_unscrapable(problem_number: int) -> bool:
+    """Check if a problem number is in the unscrapable list."""
+    return any(num == problem_number for num, _ in UNSCRAPABLE_PROBLEMS)
+
+
+def is_unscrapable_by_name(problem_name: str) -> bool:
+    """Check if a problem name is in the unscrapable list."""
+    return any(name == problem_name for _, name in UNSCRAPABLE_PROBLEMS)
+
+
+def get_unscrapable_numbers() -> set[int]:
+    """Get all unscrapable problem numbers as a set."""
+    return {num for num, _ in UNSCRAPABLE_PROBLEMS}

.cursor/.dev/update_tags.json

@@ -9,9 +9,11 @@ When user requests **batch creation of multiple problems**, the assistant will:
 3. **For each problem**:
     - Find next problem via `poetry run python .cursor/.dev/next_problem.py`
     - Follow all steps from `.cursor/commands/problem-creation.md`
-    - Verify reproducibility and quality via `.cursor/commands/test-quality-assurance.md`
+    - **MANDATORY**: Read and follow `.cursor/commands/test-quality-assurance.md` for quality verification
 4. **Provide batch summary** at the end
 
+**CRITICAL INSTRUCTION**: You MUST read the test-quality-assurance.md file before executing quality assurance for any problem. Do not rely on memory or assumptions about the workflow.
+
 ## High-Level Process
 
 ### Step 1: Initialize Batch
@@ -32,6 +34,7 @@ poetry run python .cursor/.dev/next_problem.py
 
 - Extract problem number and name from output
 - Log progress: "Problem X/Count: #NUMBER - NAME"
+- **Note**: The script automatically excludes unscrapable problems (premium, API issues, etc.)
 
 #### 2.2: Follow Problem Creation Workflow
 
@@ -55,15 +58,17 @@ Execute complete workflow from `.cursor/commands/problem-creation.md`:
 3. **Use parametrized testing**: Ensure all solution approaches are tested
 4. **Verify correctness**: Solution must handle all test cases correctly
 
-#### 2.4: Quality Assurance
+#### 2.4: Quality Assurance & Reproducibility Verification
+
+**MANDATORY**: You MUST read and follow the complete workflow from `.cursor/commands/test-quality-assurance.md` for EVERY problem.
+
+**REQUIRED ACTION**: Before proceeding with quality assurance, you MUST:
 
-Execute workflow from `.cursor/commands/test-quality-assurance.md`:
+1. **Read the file**: `read_file /Users/wisl/Desktop/vault/personal-repo/leetcode-py/.cursor/commands/test-quality-assurance.md`
+2. **Follow the exact 4-step process** described in that file
+3. **Execute each step** as specified in the test-quality-assurance.md workflow
 
-1. **Run tests**: `make p-test PROBLEM={problem_name}`
-2. **Check test coverage**: Ensure minimum 12 test cases
-3. **Enhance if needed**: Update JSON with more test cases
-4. **Verify reproducibility**: Ensure all tests pass consistently
-5. **Final verification**: `make p-lint PROBLEM={problem_name}`
+**CRITICAL**: Do NOT proceed without reading the test-quality-assurance.md file first. The workflow includes specific backup, regenerate, and restore steps that must be followed exactly.
 
 ### Step 3: Batch Summary
 
@@ -142,11 +147,12 @@ Next Steps: All problems created successfully!
 
 ### Common failure scenarios:
 
-- Scraping fails (problem not found)
+- Scraping fails (problem not found, premium problem, API issues)
 - JSON template issues (invalid syntax)
 - Generation fails (missing dependencies)
 - Tests fail (incorrect expected values)
 - Linting errors (template problems)
+- Unscrapable problems (automatically excluded by next_problem.py)
 
 ### Recovery actions:
 
@@ -155,6 +161,9 @@ Next Steps: All problems created successfully!
 - **Generation**: Check Makefile and dependencies
 - **Tests**: Update expected values in JSON template
 - **Linting**: Fix template issues and regenerate
+- **Unscrapable**: Add to `.cursor/.dev/problem_lists/unscrapable.py` and continue with next problem
+
+**CRITICAL**: Never edit generated files directly (helpers.py, test_solution.py, README.md, etc.). Always fix issues in the JSON template and regenerate to ensure reproducibility. The ONLY exception is solution.py implementation - you may edit this file directly to implement the optimal solution.
 
 ## Success Criteria
 
@@ -166,10 +175,13 @@ Each problem must meet:
 - ✅ **Parametrized testing** for all solution approaches
 - ✅ Linting passes without errors
 - ✅ All tests pass
-- ✅ Minimum 12 comprehensive test cases
+- ✅ **test-quality-assurance.md file read and complete workflow executed**
+- ✅ Minimum 12 comprehensive test cases (verified via check_test_cases tool)
+- ✅ **Test reproducibility verified** (tests pass consistently)
 - ✅ Images included in README if available
-- ✅ Proper JSON template created
+- ✅ Proper JSON template created and updated
 - ✅ Code coverage includes edge cases
+- ✅ **Original solution preserved** after quality assurance process
 
 ## Batch Parameters
 
@@ -178,6 +190,26 @@ Each problem must meet:
 - **Force**: Whether to overwrite existing problems
 - **Dry Run**: Preview mode without actual creation
 
+## Unscrapable Problems Management
+
+### Adding Unscrapable Problems
+
+When encountering a problem that cannot be scraped (premium, API issues, etc.):
+
+1. **Add to unscrapable list**: Update `.cursor/.dev/problem_lists/unscrapable.py`
+2. **Format**: `(problem_number, "problem-name")`
+3. **Continue batch**: The next_problem.py script will automatically skip unscrapable problems
+
+### Example unscrapable.py entry:
+
+```python
+UNSCRAPABLE_PROBLEMS = [
+    (252, "meeting-rooms"),
+    (253, "meeting-rooms-ii"),  # if also unscrapable
+    # Add more as discovered
+]
+```
+
 ## Notes
 
 - **Sequential Processing**: Create one problem at a time to avoid conflicts
@@ -187,3 +219,4 @@ Each problem must meet:
 - **Quality Focus**: Ensure each problem meets all quality standards
 - **Reproducibility**: Verify tests pass consistently with implemented solutions
 - **Documentation**: Maintain clear logs of the entire process
+- **Unscrapable Handling**: Automatically exclude known unscrapable problems

.cursor/commands/batch-problem-creation.md

@@ -0,0 +1,53 @@
+# Update Tags Command
+
+## Description
+
+Updates `.tags.json5` by running the `update_tags.py` script, sorting the output alphabetically, and cleaning up temporary files. The LLM handles this process directly to preserve comments in the JSON5 file.
+
+## Usage
+
+When user requests "update tags" or "update-tags", the assistant will:
+
+1. **Run update script**: Execute `poetry run python .cursor/.dev/update_tags.py`
+2. **Read output**: Read the generated `.cursor/.dev/update_tags.json` file
+3. **Read current tags**: Read the existing `.tags.json5` file to preserve comments
+4. **Sort and merge**: Sort the new tags alphabetically by name and merge with existing structure
+5. **Update file**: Write the updated tags to `.tags.json5` while preserving comments
+6. **Cleanup**: Delete the temporary `.cursor/.dev/update_tags.json` file
+
+## LLM Workflow
+
+```python
+# 1. Run the update script
+poetry run python .cursor/.dev/update_tags.py
+
+# 2. Read the generated JSON file
+with open('.cursor/.dev/update_tags.json', 'r') as f:
+    new_tags = json.load(f)
+
+# 3. Read existing .tags.json5 to preserve comments
+with open('.tags.json5', 'r') as f:
+    existing_content = f.read()
+
+# 4. Sort new tags alphabetically by name
+sorted_tags = sorted(new_tags, key=lambda x: x.get('name', ''))
+
+# 5. Update the .tags.json5 file while preserving comments
+# (Implementation depends on JSON5 structure and comment preservation needs)
+
+# 6. Clean up temporary file
+os.remove('.cursor/.dev/update_tags.json')
+```
+
+## Prerequisites
+
+- `update_tags.py` script must exist in `.cursor/.dev/`
+- The script must output a JSON file to `.cursor/.dev/update_tags.json`
+- Assistant must handle JSON5 comment preservation
+
+## Output
+
+- Updates `.tags.json5` with alphabetically sorted tags
+- Preserves existing comments in the JSON5 file
+- Removes temporary `.cursor/.dev/update_tags.json` file
+- Provides success/error feedback

.cursor/commands/update-tags.md

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= number_of_1_bits
+PROBLEM ?= top_k_frequent_elements
 FORCE ?= 0
 COMMA := ,
 

Makefile

@@ -0,0 +1,47 @@
+# Counting Bits
+
+**Difficulty:** Easy
+**Topics:** Dynamic Programming, Bit Manipulation
+**Tags:** blind-75
+
+**LeetCode:** [Problem 338](https://leetcode.com/problems/counting-bits/description/)
+
+## Problem Description
+
+Given an integer `n`, return _an array_ `ans` _of length_ `n + 1` _such that for each_ `i` _(0 <= i <= n),_ `ans[i]` \*is the **number of\*** `1`**\*'s** in the binary representation of\* `i`.
+
+## Examples
+
+### Example 1:
+
+```
+Input: n = 2
+Output: [0,1,1]
+Explanation:
+0 --> 0
+1 --> 1
+2 --> 10
+```
+
+### Example 2:
+
+```
+Input: n = 5
+Output: [0,1,1,2,1,2]
+Explanation:
+0 --> 0
+1 --> 1
+2 --> 10
+3 --> 11
+4 --> 100
+5 --> 101
+```
+
+## Constraints
+
+- 0 <= n <= 10^5
+
+**Follow up:**
+
+- It is very easy to come up with a solution with a runtime of `O(n log n)`. Can you do it in linear time `O(n)` and possibly in a single pass?
+- Can you do it without using any built-in function (i.e., like `__builtin_popcount` in C++)?

leetcode/counting_bits/README.md

@@ -0,0 +1,8 @@
+def run_count_bits(solution_class: type, n: int):
+    implementation = solution_class()
+    return implementation.count_bits(n)
+
+
+def assert_count_bits(result: list[int], expected: list[int]) -> bool:
+    assert result == expected
+    return True

leetcode/counting_bits/__init__.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_count_bits, run_count_bits
+from solution import Solution
+
+# %%
+# Example test case
+n = 2
+expected = [0, 1, 1]
+
+# %%
+result = run_count_bits(Solution, n)
+result
+
+# %%
+assert_count_bits(result, expected)