From 186bb752891e2ba37594459d4d30e2cc96bcdea0 Mon Sep 17 00:00:00 2001 From: Harivansh Rathi Date: Sun, 14 Dec 2025 15:58:15 -0500 Subject: [PATCH] examples for clawd --- .claude/commands/generate.md | 2 + .claude/problem-examples.md | 336 +++++++++++++++++++++++++++++++++++ 2 files changed, 338 insertions(+) create mode 100644 .claude/problem-examples.md diff --git a/.claude/commands/generate.md b/.claude/commands/generate.md index ea49dda..927368b 100644 --- a/.claude/commands/generate.md +++ b/.claude/commands/generate.md @@ -6,6 +6,8 @@ allowed-tools: Write, Bash(mkdir:*) # Generate a New Practice Problem +**Reference**: @.claude/problem-examples.md for consistent formatting and quality examples. + You are generating a practical implementation problem for veetcode - a terminal-based coding practice tool. ## Arguments Provided diff --git a/.claude/problem-examples.md b/.claude/problem-examples.md new file mode 100644 index 0000000..615342d --- /dev/null +++ b/.claude/problem-examples.md @@ -0,0 +1,336 @@ +# Problem Examples Reference + +Reference examples for generating consistent, high-quality practice problems. + +## Easy Example: Email Validator + +**solution.py**: +```python +""" +Email Validator + +You're building a user registration system. Before storing emails in your +database, you need to validate that they follow the correct format. + +Write a function that checks if an email address is valid. + +Example 1: + Input: email = "user@example.com" + Output: True + Explanation: Has username, @, domain with dot + +Example 2: + Input: email = "invalid-email" + Output: False + Explanation: Missing @ symbol + +Example 3: + Input: email = "@nodomain.com" + Output: False + Explanation: Empty username before @ + +Constraints: + - Input is always a string + - Valid emails have: non-empty username, exactly one @, domain with at least one dot + - No spaces allowed anywhere in the email +""" + + +def is_valid_email(email: str) -> bool: + """Return True if email is valid, False otherwise.""" + pass # Your implementation here +``` + +**tests.py**: +```python +import pytest +from solution import is_valid_email + + +def test_valid_simple(): + assert is_valid_email("user@example.com") == True + + +def test_valid_with_dots(): + assert is_valid_email("user.name@example.co.uk") == True + + +def test_invalid_no_at(): + assert is_valid_email("userexample.com") == False + + +def test_invalid_no_domain_dot(): + assert is_valid_email("user@examplecom") == False + + +def test_invalid_empty_username(): + assert is_valid_email("@example.com") == False + + +def test_invalid_spaces(): + assert is_valid_email("user @example.com") == False +``` + +--- + +## Medium Example: Group Transactions + +**solution.py**: +```python +""" +Transaction Grouper + +You're building a financial dashboard. Users want to see their transactions +grouped by category, with totals calculated for each group. + +Given a list of transactions (each with amount, category, and date), +return a dictionary grouping transactions by category with their total. + +Example 1: + Input: transactions = [ + {"amount": 50, "category": "food", "date": "2024-01-01"}, + {"amount": 30, "category": "food", "date": "2024-01-02"}, + {"amount": 100, "category": "transport", "date": "2024-01-01"} + ] + Output: {"food": 80, "transport": 100} + Explanation: food: 50+30=80, transport: 100 + +Example 2: + Input: transactions = [] + Output: {} + Explanation: No transactions means empty result + +Constraints: + - Each transaction has "amount" (positive int), "category" (string), "date" (string) + - Categories are case-sensitive + - Return categories in any order +""" + + +def group_transactions(transactions: list[dict]) -> dict[str, int]: + """Return dictionary mapping category to total amount.""" + pass # Your implementation here +``` + +**tests.py**: +```python +import pytest +from solution import group_transactions + + +def test_multiple_categories(): + txns = [ + {"amount": 50, "category": "food", "date": "2024-01-01"}, + {"amount": 30, "category": "food", "date": "2024-01-02"}, + {"amount": 100, "category": "transport", "date": "2024-01-01"} + ] + assert group_transactions(txns) == {"food": 80, "transport": 100} + + +def test_empty_list(): + assert group_transactions([]) == {} + + +def test_single_transaction(): + txns = [{"amount": 25, "category": "entertainment", "date": "2024-01-01"}] + assert group_transactions(txns) == {"entertainment": 25} + + +def test_single_category_multiple_transactions(): + txns = [ + {"amount": 10, "category": "food", "date": "2024-01-01"}, + {"amount": 20, "category": "food", "date": "2024-01-02"}, + {"amount": 30, "category": "food", "date": "2024-01-03"} + ] + assert group_transactions(txns) == {"food": 60} + + +def test_case_sensitive_categories(): + txns = [ + {"amount": 10, "category": "Food", "date": "2024-01-01"}, + {"amount": 20, "category": "food", "date": "2024-01-02"} + ] + result = group_transactions(txns) + assert result == {"Food": 10, "food": 20} + + +def test_many_categories(): + txns = [ + {"amount": 1, "category": "a", "date": "2024-01-01"}, + {"amount": 2, "category": "b", "date": "2024-01-01"}, + {"amount": 3, "category": "c", "date": "2024-01-01"}, + {"amount": 4, "category": "d", "date": "2024-01-01"} + ] + assert group_transactions(txns) == {"a": 1, "b": 2, "c": 3, "d": 4} +``` + +--- + +## Hard Example: Rate Limiter + +**solution.py**: +```python +""" +Rate Limiter + +You're building an API gateway that needs to prevent abuse. Implement a +rate limiter that tracks requests per user and enforces limits using +a sliding window algorithm. + +The rate limiter should allow at most `max_requests` per user within +any `window_seconds` time period. + +Example 1: + limiter = RateLimiter(max_requests=3, window_seconds=60) + limiter.allow_request("user1", timestamp=0) # True (1st request) + limiter.allow_request("user1", timestamp=30) # True (2nd request) + limiter.allow_request("user1", timestamp=45) # True (3rd request) + limiter.allow_request("user1", timestamp=50) # False (4th in 60s window) + limiter.allow_request("user1", timestamp=61) # True (1st request expired) + +Example 2: + limiter = RateLimiter(max_requests=2, window_seconds=10) + limiter.allow_request("user1", timestamp=0) # True + limiter.allow_request("user2", timestamp=0) # True (different user) + limiter.allow_request("user1", timestamp=5) # True + limiter.allow_request("user1", timestamp=8) # False (limit reached) + +Constraints: + - max_requests >= 1 + - window_seconds >= 1 + - timestamps are non-negative integers (seconds) + - timestamps are always non-decreasing for a given user + - user_id is a non-empty string +""" + + +class RateLimiter: + """Sliding window rate limiter.""" + + def __init__(self, max_requests: int, window_seconds: int): + """Initialize rate limiter with request limit and time window.""" + pass # Your implementation here + + def allow_request(self, user_id: str, timestamp: int) -> bool: + """Return True if request is allowed, False if rate limited.""" + pass # Your implementation here + + def get_remaining(self, user_id: str, timestamp: int) -> int: + """Return number of remaining requests allowed for user.""" + pass # Your implementation here +``` + +**tests.py**: +```python +import pytest +from solution import RateLimiter + + +def test_basic_allow(): + limiter = RateLimiter(max_requests=3, window_seconds=60) + assert limiter.allow_request("user1", 0) == True + assert limiter.allow_request("user1", 30) == True + assert limiter.allow_request("user1", 45) == True + + +def test_rate_limit_exceeded(): + limiter = RateLimiter(max_requests=2, window_seconds=60) + assert limiter.allow_request("user1", 0) == True + assert limiter.allow_request("user1", 30) == True + assert limiter.allow_request("user1", 45) == False + + +def test_window_expiration(): + limiter = RateLimiter(max_requests=2, window_seconds=60) + assert limiter.allow_request("user1", 0) == True + assert limiter.allow_request("user1", 30) == True + assert limiter.allow_request("user1", 45) == False + assert limiter.allow_request("user1", 61) == True # First request expired + + +def test_multiple_users_independent(): + limiter = RateLimiter(max_requests=1, window_seconds=60) + assert limiter.allow_request("user1", 0) == True + assert limiter.allow_request("user2", 0) == True + assert limiter.allow_request("user1", 30) == False + assert limiter.allow_request("user2", 30) == False + + +def test_get_remaining(): + limiter = RateLimiter(max_requests=3, window_seconds=60) + assert limiter.get_remaining("user1", 0) == 3 + limiter.allow_request("user1", 0) + assert limiter.get_remaining("user1", 0) == 2 + limiter.allow_request("user1", 30) + assert limiter.get_remaining("user1", 30) == 1 + + +def test_get_remaining_after_expiration(): + limiter = RateLimiter(max_requests=2, window_seconds=60) + limiter.allow_request("user1", 0) + limiter.allow_request("user1", 30) + assert limiter.get_remaining("user1", 30) == 0 + assert limiter.get_remaining("user1", 61) == 1 # First expired + + +def test_single_request_limit(): + limiter = RateLimiter(max_requests=1, window_seconds=10) + assert limiter.allow_request("user1", 0) == True + assert limiter.allow_request("user1", 5) == False + assert limiter.allow_request("user1", 10) == False + assert limiter.allow_request("user1", 11) == True + + +def test_new_user_has_full_allowance(): + limiter = RateLimiter(max_requests=5, window_seconds=60) + limiter.allow_request("user1", 0) + limiter.allow_request("user1", 10) + assert limiter.get_remaining("new_user", 20) == 5 + + +def test_rapid_requests(): + limiter = RateLimiter(max_requests=3, window_seconds=1) + assert limiter.allow_request("user1", 0) == True + assert limiter.allow_request("user1", 0) == True + assert limiter.allow_request("user1", 0) == True + assert limiter.allow_request("user1", 0) == False +``` + +--- + +## Topic Ideas by Concept + +### Arrays/Lists +- Remove duplicates preserving order +- Find pairs that sum to target +- Merge sorted arrays +- Rotate array by k positions +- Find missing number in sequence + +### Strings +- Validate email/URL/phone format +- Count word frequency +- Find longest palindromic substring +- Parse CSV line with quotes +- Compress string (aaabbc -> a3b2c1) + +### Hash Maps +- Group items by property +- Find first non-repeating character +- Two sum / three sum variations +- LRU Cache implementation +- Anagram grouping + +### Classes/OOP +- Shopping cart with discounts +- Bank account with transaction history +- Task scheduler with priorities +- Event emitter / pub-sub +- State machine implementation + +### Data Processing +- Filter and transform records +- Aggregate statistics +- Merge overlapping intervals +- Topological sort of dependencies +- Pagination with cursor