A modern Python LeetCode practice environment that goes beyond basic problem solving. Features automated problem generation from LeetCode URLs, beautiful data structure visualizations (TreeNode, ListNode, GraphNode), and comprehensive testing with 12+ test cases per problem. Built with professional development practices including CI/CD, type hints, and quality gates.

What makes this different:

• 🤖 LLM-Assisted Workflow: Generate new problems instantly with AI assistance
• 🎨 Visual Debugging: Interactive tree/graph rendering with Graphviz and anytree
• 🧪 Production Testing: Comprehensive test suites with edge cases and reproducibility verification
• 🚀 Modern Python: PEP 585/604 type hints, Poetry, and professional tooling
• 📊 Quality Assurance: 95%+ test coverage, security scanning, automated linting

Current: All 75 problems from Grind 75 - the most essential coding interview questions curated by the creator of Blind 75.

Future: Planned expansion to all 169 Grind problems for comprehensive interview preparation.

# Install globally via pip
pip install leetcode-py

# Generate problems anywhere
lcpy gen -n 1                    # Generate Two Sum
lcpy gen -t grind-75             # Generate all Grind 75 problems
lcpy list -t grind-75            # List available problems
lcpy scrape -n 1                 # Fetch problem data

# Clone and setup for development
git clone https://github.com/wisarootl/leetcode-py.git
cd leetcode-py
poetry install

# Start with existing Grind 75 problems
make gen-all-problems  # Regenerates all problems with TODO placeholders

# Practice a specific problem
make p-test PROBLEM=two_sum
# Edit leetcode/two_sum/solution.py, then rerun tests

# Run all tests
make test

• Python 3.13+
• Poetry, Make, Git, Graphviz

Each problem follows a consistent, production-ready template:

leetcode/two_sum/
├── README.md           # Problem description with examples and constraints
├── solution.py         # Implementation with type hints and TODO placeholder
├── test_solution.py    # Comprehensive parametrized tests (12+ test cases)
├── helpers.py          # Test helper functions
├── playground.py       # Interactive debugging environment (converted from .ipynb)
└── __init__.py         # Package marker

• Modern Python: PEP 585/604 type hints, snake_case conventions
• Comprehensive Linting: black, isort, ruff, mypy with nbqa for notebooks
• High Test Coverage: 12+ test cases per problem including edge cases
• Beautiful Logging: loguru integration for enhanced test debugging
• CI/CD Pipeline: Automated testing, security scanning, and quality gates

• TreeNode: Beautiful tree rendering with anytree and Graphviz
• ListNode: Clean arrow-based visualization (1 -> 2 -> 3)
• Interactive Debugging: Multi-cell playground environment

Beautiful tree rendering with anytree and Graphviz

Clean arrow-based list visualization

• Template Generation: Creates Jupyter notebooks (.ipynb) by default
• Repository State: This repo uses Python files (.py) for better version control
• User Choice: Use make nb-to-py to convert notebooks to Python files, or keep as .ipynb for interactive development

Interactive multi-cell playground for each problem

Perfect for quick problem generation anywhere:

# Generate specific problems
lcpy gen -n 1 -n 125 -n 206      # Multiple problems by number
lcpy gen -s two-sum -s valid-palindrome  # Multiple problems by slug

# Bulk generation
lcpy gen -t grind-75              # All Grind 75 problems
lcpy gen -t grind-75 -d Easy     # Only Easy problems from Grind 75

# Explore available problems
lcpy list                         # All problems
lcpy list -t grind-75            # Filter by tag
lcpy list -d Medium              # Filter by difficulty

# Fetch problem data
lcpy scrape -n 1 > two_sum.json  # Save problem data

For repository development and customization:

# Regenerate all 75 problems with fresh TODO placeholders
make gen-all-problems

# Work through problems systematically
make p-test PROBLEM=two_sum
make p-test PROBLEM=valid_palindrome
make p-test PROBLEM=merge_two_sorted_lists

If you need more problems beyond Grind 75, use an LLM assistant in your IDE (Cursor, GitHub Copilot Chat, Amazon Q, etc.):

# Example commands to give your LLM assistant:
"Create LeetCode problem 146 (LRU Cache)"
"Add problem 'Word Ladder' by number 127"
"Generate problem 'Serialize and Deserialize Binary Tree'"

# For test enhancement (when you need more comprehensive test coverage):
"Enhance test cases for two_sum problem"
"Fix test reproducibility for binary_tree_inorder_traversal"

Required LLM Context: Include these rule files in your LLM context for automated problem generation and test enhancement:

• .amazonq/rules/problem-creation.md - Complete problem generation workflow
• .amazonq/rules/test-quality-assurance.md - Test enhancement and reproducibility verification

Manual Check: Find problems needing more test cases:

poetry run python -m leetcode_py.tools.check_test_cases --threshold=10

• TreeNode: from leetcode_py import TreeNode

  • Array ↔ tree conversion: TreeNode.from_list([1,2,3]), tree.to_list()
  • Beautiful anytree text rendering and Graphviz SVG for Jupyter
  • Node search: tree.find_node(value)
  • Generic type support: TreeNode[int], TreeNode[str]

• ListNode: from leetcode_py import ListNode

  • Array ↔ list conversion: ListNode.from_list([1,2,3]), node.to_list()
  • Cycle detection with Floyd's algorithm
  • Graphviz visualization for Jupyter notebooks
  • Generic type support: ListNode[int], ListNode[str]

• GraphNode: from leetcode_py import GraphNode

  • Adjacency list conversion: GraphNode.from_adjacency_list([[2,4],[1,3],[2,4],[1,3]])
  • Clone detection: original.is_clone(cloned)
  • Graphviz visualization for undirected graphs
  • DFS traversal utilities

• DictTree: from leetcode_py.data_structures import DictTree

  • Perfect for Trie implementations: DictTree[str]()
  • Beautiful tree rendering with box-drawing characters
  • Graphviz visualization for Jupyter notebooks
  • Generic key type support

# Generate problems
lcpy gen -n 1                       # Single problem by number
lcpy gen -s two-sum                 # Single problem by slug
lcpy gen -t grind-75                # Bulk generation by tag
lcpy gen -n 1 -n 2 -n 3            # Multiple problems
lcpy gen -t grind-75 -d Easy       # Filter by difficulty
lcpy gen -n 1 -o my-problems       # Custom output directory

# List problems
lcpy list                           # All available problems
lcpy list -t grind-75              # Filter by tag
lcpy list -d Medium                # Filter by difficulty

# Scrape problem data
lcpy scrape -n 1                   # Fetch by number
lcpy scrape -s two-sum             # Fetch by slug

# Problem-specific operations
make p-test PROBLEM=problem_name    # Test specific problem
make p-gen PROBLEM=problem_name     # Generate problem from JSON template
make p-lint PROBLEM=problem_name    # Lint specific problem

# Bulk operations
make test                           # Run all tests
make lint                           # Lint entire codebase
make gen-all-problems              # Regenerate all problems (destructive)

• Template-Driven: JSON templates in .templates/leetcode/json/ drive code generation
• Cookiecutter Integration: Uses .templates/leetcode/{{cookiecutter.problem_name}}/ template for consistent file structure
• Automated Scraping: LLM-assisted problem data extraction from LeetCode
• Version Control Friendly: Python files by default, optional notebook support

• Test Coverage: 95%+ with comprehensive edge case testing (Codecov integration)
• Security: SonarCloud quality gates, Trivy dependency scanning, Gitleaks secret detection
• Code Quality: Automated linting with black, isort, ruff, mypy
• Test Reproducibility: Automated verification that problems can be regenerated consistently
• CI/CD: GitHub Actions for testing, security, pre-commit hooks, and release automation

Perfect for systematic coding interview preparation with professional development practices and enhanced debugging capabilities.