ci: fix ci

Author: wislertt

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

@@ -53,10 +53,8 @@ Execute complete workflow from `.cursor/commands/problem-creation.md`:
 
 **CRITICAL**: Before running quality assurance, implement the optimal solution:
 
-1. **Implement solution**: Write the optimal algorithm in `solution.py`
-2. **Add multiple approaches**: Include alternative solutions (e.g., Solution, SolutionOptimized)
-3. **Use parametrized testing**: Ensure all solution approaches are tested
-4. **Verify correctness**: Solution must handle all test cases correctly
+1. **Implement solution**: Write the optimal algorithm in `solution.py` - implement only 1 solution in the `Solution` class, no need to add more classes
+2. **Verify correctness**: Solution must handle all test cases correctly
 
 #### 2.4: Quality Assurance & Reproducibility Verification
 

.cursor/commands/test-quality-assurance.md

@@ -1,43 +1,51 @@
 # Test Quality Assurance Rules
 
-## Simple Enhancement Workflow
-
-When user requests test case enhancement or **test reproducibility verification**:
+## CRITICAL: Follow These Steps EXACTLY - No Deviations
 
 ### 1. Problem Resolution
 
 - Use active file context or user-provided problem name
 - If unclear, run: `poetry run python -m leetcode_py.tools.check_test_cases --threshold=10 --max=1`
 
-### 2. Enhancement Process
+### 2. Test Reproducibility Verification Process
+
+**MANDATORY 6-Step Process - Execute in Order:**
 
 ```bash
-# Simple 4-step process:
-# 1. Update JSON template with more test cases (12-15 total)
-# 2. Backup original
-mv leetcode/{problem_name} .cache/leetcode/{problem_name}
-# 3. Regenerate with enhanced tests
-make p-gen PROBLEM={problem_name} FORCE=1 && make p-lint PROBLEM={problem_name}
-# 4. Restore original solution, keep enhanced tests
-cp .cache/leetcode/{problem_name}/solution.py leetcode/{problem_name}/solution.py
-```
+# Step 1: Backup original files
+cp -r leetcode/{problem_name} leetcode/{problem_name}_backup
 
-### 3. Verification
+# Step 2: Regenerate from JSON template (use Makefile, NOT poetry run)
+make p-gen PROBLEM={problem_name} FORCE=1
 
-- Run `make p-test PROBLEM={problem_name}`
-- Fix any incorrect expected values in test cases
-- Update JSON template with corrections
+# Step 3: Restore original solution ONLY
+cp leetcode/{problem_name}_backup/solution.py leetcode/{problem_name}/solution.py
 
-### 4. Restore Backup
+# Step 4: Verify mypy passes (CRITICAL for CI)
+poetry run mypy leetcode/{problem_name}/test_solution.py --explicit-package-bases --install-types --non-interactive --check-untyped-defs
 
-```bash
-# Copy enhanced test_solution.py to backup
-cp leetcode/{problem_name}/test_solution.py .cache/leetcode/{problem_name}/
-# Restore all original files (preserves user edits)
-rm -rf leetcode/{problem_name}
-mv .cache/leetcode/{problem_name} leetcode/{problem_name}
+# Step 5: Verify tests pass (expected to fail if solution is incomplete)
+make p-test PROBLEM={problem_name}
+
+# Step 6: Cleanup
+rm -rf leetcode/{problem_name}_backup
 ```
 
+### 3. What NOT to Do
+
+- ❌ **NEVER edit cookiecutter templates** (`{{cookiecutter.problem_name}}/` files)
+- ❌ **NEVER use `poetry run python -m leetcode_py.cli.main gen`** - use `make p-gen` instead
+- ❌ **NEVER modify helpers.py manually** - let regeneration handle it
+- ❌ **NEVER skip mypy verification** - this is the main CI issue
+- ❌ **NEVER assume tests will pass** - they may fail if solution is incomplete
+
+### 4. What to Do
+
+- ✅ **ALWAYS use `make p-gen PROBLEM={problem_name} FORCE=1`** for regeneration
+- ✅ **ALWAYS verify mypy passes** before considering task complete
+- ✅ **ALWAYS restore original solution** after regeneration
+- ✅ **ALWAYS check JSON template** if mypy fails (look for `assert_assert_` bugs)
+
 ## Test Case Standards
 
 ### Coverage Requirements
@@ -84,24 +92,34 @@ poetry run python -m leetcode_py.tools.check_test_cases --threshold=12
 make p-gen PROBLEM={problem_name} FORCE=1
 ```
 
-## Test Reproducibility Verification
+## Common Issues & Solutions
 
-Use this same workflow when CI tests fail due to reproducibility issues:
+### Issue: `assert_assert_missing_number` Error
 
-**Process Name**: Test Reproducibility Verification
+**Cause**: JSON template has `helpers_assert_name: "assert_missing_number"` but template adds `assert_` prefix
+**Solution**: Change JSON to `helpers_assert_name: "missing_number"` so template generates `assert_missing_number`
 
-**When to Use**:
+### Issue: mypy Import Errors
 
-- CI test failures in reproducibility checks
-- Inconsistent test results between environments
-- Missing edge cases causing coverage gaps
-- Need to ensure 100% code coverage
+**Cause**: Regenerated helpers.py doesn't match test imports
+**Solution**: Use `make p-gen` (not poetry run) and verify JSON template is correct
+
+### Issue: Tests Fail After Regeneration
+
+**Expected**: Tests may fail if solution is incomplete (returns 0 or placeholder)
+**Action**: This is normal - focus on mypy passing, not test results
 
 ## Success Criteria
 
-- All tests pass with enhanced test cases
-- Minimum 12 comprehensive test cases per problem
-- Original solution code preserved
-- **Enhanced test cases in final test_solution.py**
-- JSON template updated for future regeneration
-- **100% code coverage including edge cases**
+- ✅ **mypy passes** with no errors (CRITICAL for CI)
+- ✅ **Test structure matches JSON template** exactly
+- ✅ **Original solution preserved** (user's code intact)
+- ✅ **helpers.py generated correctly** (no `assert_assert_` bugs)
+- ✅ **Reproducibility verified** (can regenerate consistently)
+
+## When to Use This Workflow
+
+- GitHub Actions CI failures due to mypy errors
+- Test reproducibility verification requests
+- Need to ensure test structure matches JSON template
+- CI test failures in reproducibility checks

leetcode/counting_bits/solution.py

@@ -2,28 +2,6 @@
 
 
 class Solution:
-    def count_bits(self, n: int) -> List[int]:
-        """
-        Count bits using dynamic programming approach.
-
-        Key insight: For any number i, the number of 1s in its binary representation
-        is equal to the number of 1s in i >> 1 (right shift by 1) plus the least significant bit.
-
-        Time: O(n)
-        Space: O(1) excluding output array
-        """
-        result = [0] * (n + 1)
-
-        for i in range(1, n + 1):
-            # result[i] = result[i >> 1] + (i & 1)
-            # i >> 1 removes the least significant bit
-            # i & 1 gets the least significant bit
-            result[i] = result[i >> 1] + (i & 1)
-
-        return result
-
-
-class SolutionOptimized:
     def count_bits(self, n: int) -> List[int]:
         """
         Optimized version with better variable naming and comments.
@@ -42,38 +20,3 @@ def count_bits(self, n: int) -> List[int]:
             bits_count[num] = bits_count[num >> 1] + (num & 1)
 
         return bits_count
-
-
-class SolutionNaive:
-    def count_bits(self, n: int) -> List[int]:
-        """
-        Naive approach using built-in bin() function.
-
-        Time: O(n log n) - bin() takes O(log n) time
-        Space: O(1) excluding output array
-        """
-        result = []
-        for i in range(n + 1):
-            result.append(bin(i).count("1"))
-        return result
-
-
-class SolutionBitManipulation:
-    def count_bits(self, n: int) -> List[int]:
-        """
-        Using bit manipulation to count 1s directly.
-
-        Time: O(n log n) - each number takes O(log n) time
-        Space: O(1) excluding output array
-        """
-        result = []
-
-        for i in range(n + 1):
-            count = 0
-            num = i
-            while num > 0:
-                count += num & 1  # Check if least significant bit is 1
-                num >>= 1  # Right shift to check next bit
-            result.append(count)
-
-        return result

leetcode/house_robber_ii/solution.py

@@ -2,43 +2,6 @@
 
 
 class Solution:
-    def rob(self, nums: List[int]) -> int:
-        """
-        House Robber II - Circular arrangement.
-
-        The key insight is that since houses are in a circle, we can't rob both
-        the first and last house. So we have two cases:
-        1. Rob houses 0 to n-2 (exclude last house)
-        2. Rob houses 1 to n-1 (exclude first house)
-
-        Time: O(n)
-        Space: O(1)
-        """
-        if not nums:
-            return 0
-        if len(nums) == 1:
-            return nums[0]
-        if len(nums) == 2:
-            return max(nums[0], nums[1])
-
-        def rob_linear(houses: List[int]) -> int:
-            """Rob houses in linear arrangement (no circle)."""
-            prev2 = prev1 = 0
-            for money in houses:
-                current = max(prev1, prev2 + money)
-                prev2, prev1 = prev1, current
-            return prev1
-
-        # Case 1: Rob houses 0 to n-2 (exclude last house)
-        case1 = rob_linear(nums[:-1])
-
-        # Case 2: Rob houses 1 to n-1 (exclude first house)
-        case2 = rob_linear(nums[1:])
-
-        return max(case1, case2)
-
-
-class SolutionOptimized:
     def rob(self, nums: List[int]) -> int:
         """
         Optimized version with better variable naming and edge case handling.

leetcode/missing_number/README.md

@@ -2,7 +2,7 @@
 
 **Difficulty:** Easy
 **Topics:** Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting
-**Tags:** blind-75
+**Tags:** neetcode-150, blind-75
 
 **LeetCode:** [Problem 268](https://leetcode.com/problems/missing-number/description/)
 

leetcode/missing_number/solution.py

@@ -1,84 +1,7 @@
-from typing import List
-
-
 class Solution:
-    def missing_number(self, nums: List[int]) -> int:
-        """
-        Find the missing number using mathematical approach.
-
-        The sum of numbers from 0 to n is n*(n+1)/2.
-        The missing number is the difference between expected sum and actual sum.
-
-        Time: O(n)
-        Space: O(1)
-        """
-        n = len(nums)
-        expected_sum = n * (n + 1) // 2
-        actual_sum = sum(nums)
-        return expected_sum - actual_sum
-
-
-class SolutionOptimized:
-    def missing_number(self, nums: List[int]) -> int:
-        """
-        Find the missing number using XOR approach.
-
-        XOR has the property that a ^ a = 0 and a ^ 0 = a.
-        If we XOR all numbers from 0 to n with all numbers in nums,
-        the missing number will be the only one left.
-
-        Time: O(n)
-        Space: O(1)
-        """
-        n = len(nums)
-        result = n  # Start with n since we're missing one number
-
-        for i in range(n):
-            result ^= i ^ nums[i]
-
-        return result
-
-
-class SolutionHashSet:
-    def missing_number(self, nums: List[int]) -> int:
-        """
-        Find the missing number using hash set approach.
-
-        Time: O(n)
-        Space: O(n)
-        """
-        num_set = set(nums)
-        n = len(nums)
-
-        for i in range(n + 1):
-            if i not in num_set:
-                return i
-
-        return -1  # Should never reach here
-
-
-class SolutionSorting:
-    def missing_number(self, nums: List[int]) -> int:
-        """
-        Find the missing number using sorting approach.
-
-        Time: O(n log n)
-        Space: O(1) if sorting in-place
-        """
-        nums.sort()
-        n = len(nums)
-
-        # Check if 0 is missing
-        if nums[0] != 0:
-            return 0
-
-        # Check if n is missing
-        if nums[-1] != n:
-            return n
-
-        # Check for missing number in between
-        for i in range(1, n):
-            if nums[i] != nums[i - 1] + 1:
-                return nums[i - 1] + 1
 
-        return -1  # Should never reach here
+    # Time: O(?)
+    # Space: O(?)
+    def missing_number(self, nums: list[int]) -> int:
+        # TODO: Implement missing_number
+        return 0