feat: add 30 coding challenges with solutions

15 beginner + 15 intermediate challenges covering core Python patterns.
Each challenge has function stubs, type hints, test cases, and hints.
Solutions in separate directory for self-checking.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: travisjneuman

practice/challenges/README.md

@@ -0,0 +1,42 @@
+# Coding Challenges
+
+Standalone coding challenges to sharpen your Python skills. Each challenge is a single file with a problem description, function stub, hints, and built-in tests.
+
+## How It Works
+
+1. **Read the docstring** at the top of each challenge file for the problem description and examples.
+2. **Implement the function** where it says `pass`.
+3. **Run the file** with `python <filename>.py` -- the built-in tests will tell you if your solution is correct.
+4. **Check the solution** in `solutions/` only after you have genuinely attempted the problem.
+
+## Difficulty Levels
+
+| Level            | Description                                                      | Prereqs                                    |
+| ---------------- | ---------------------------------------------------------------- | ------------------------------------------ |
+| **Beginner**     | Core Python: variables, strings, lists, loops, conditionals      | Level 0-2 of the curriculum                |
+| **Intermediate** | Decorators, generators, classes, async, file I/O, data structures | Level 3-6 of the curriculum                |
+
+## Directory Structure
+
+```
+challenges/
+  README.md              -- This file
+  beginner/              -- 15 beginner challenges
+  intermediate/          -- 15 intermediate challenges
+  solutions/
+    beginner/            -- Beginner solutions with explanations
+    intermediate/        -- Intermediate solutions with explanations
+```
+
+## Tips
+
+- Read the entire docstring before writing any code.
+- Use the hint only if you are stuck for more than 5 minutes.
+- Run the tests frequently as you build up your solution.
+- If all tests pass but you are unsure why, trace through your code by hand with the example inputs.
+- Compare your passing solution to the provided solution -- there are often multiple valid approaches.
+
+## Estimated Time
+
+- Beginner challenges: 10-30 minutes each
+- Intermediate challenges: 30-60 minutes each

practice/challenges/beginner/01-swap-variables.py

@@ -0,0 +1,34 @@
+"""
+Challenge: Swap Variables
+Difficulty: Beginner
+Concepts: variables, tuple unpacking, arithmetic tricks
+Time: 10 minutes
+
+Swap two variables without using a temporary third variable.
+Return them as a tuple (b, a) where the values have been exchanged.
+
+Examples:
+    >>> swap(1, 2)
+    (2, 1)
+    >>> swap("hello", "world")
+    ('world', 'hello')
+"""
+
+
+def swap(a, b) -> tuple:
+    """Swap two values and return them as a tuple. Implement this function."""
+    # Hint: Python supports simultaneous assignment with commas.
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Basic integers
+    assert swap(1, 2) == (2, 1), "Basic integer swap failed"
+    # Test 2: Strings
+    assert swap("hello", "world") == ("world", "hello"), "String swap failed"
+    # Test 3: Same values
+    assert swap(5, 5) == (5, 5), "Same value swap failed"
+    # Test 4: Mixed types
+    assert swap(42, "answer") == ("answer", 42), "Mixed type swap failed"
+    print("All tests passed!")

practice/challenges/beginner/02-fizzbuzz.py

@@ -0,0 +1,40 @@
+"""
+Challenge: FizzBuzz
+Difficulty: Beginner
+Concepts: loops, conditionals, modulo operator, list building
+Time: 15 minutes
+
+Given an integer n, return a list of strings from 1 to n where:
+- Multiples of 3 are replaced with "Fizz"
+- Multiples of 5 are replaced with "Buzz"
+- Multiples of both 3 and 5 are replaced with "FizzBuzz"
+- All other numbers are converted to their string representation
+
+Examples:
+    >>> fizzbuzz(5)
+    ['1', '2', 'Fizz', '4', 'Buzz']
+    >>> fizzbuzz(15)[-1]
+    'FizzBuzz'
+"""
+
+
+def fizzbuzz(n: int) -> list[str]:
+    """Return FizzBuzz sequence from 1 to n. Implement this function."""
+    # Hint: Check divisibility by 15 (both) before checking 3 or 5 individually.
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Small range
+    assert fizzbuzz(5) == ["1", "2", "Fizz", "4", "Buzz"], "Small range failed"
+    # Test 2: FizzBuzz at 15
+    result = fizzbuzz(15)
+    assert result[14] == "FizzBuzz", "FizzBuzz at 15 failed"
+    assert result[2] == "Fizz", "Fizz at 3 failed"
+    assert result[4] == "Buzz", "Buzz at 5 failed"
+    # Test 3: Single element
+    assert fizzbuzz(1) == ["1"], "Single element failed"
+    # Test 4: Length check
+    assert len(fizzbuzz(20)) == 20, "Length check failed"
+    print("All tests passed!")

practice/challenges/beginner/03-reverse-string.py

@@ -0,0 +1,36 @@
+"""
+Challenge: Reverse String
+Difficulty: Beginner
+Concepts: strings, loops, iteration, string building
+Time: 15 minutes
+
+Reverse a string without using slice notation ([::-1]).
+You may use loops, recursion, or any other approach.
+
+Examples:
+    >>> reverse_string("hello")
+    'olleh'
+    >>> reverse_string("Python")
+    'nohtyP'
+"""
+
+
+def reverse_string(s: str) -> str:
+    """Reverse a string without using [::-1]. Implement this function."""
+    # Hint: Build a new string by iterating from the end, or use a loop to prepend characters.
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Basic word
+    assert reverse_string("hello") == "olleh", "Basic word failed"
+    # Test 2: Palindrome
+    assert reverse_string("racecar") == "racecar", "Palindrome failed"
+    # Test 3: Empty string
+    assert reverse_string("") == "", "Empty string failed"
+    # Test 4: Single character
+    assert reverse_string("x") == "x", "Single character failed"
+    # Test 5: Spaces and punctuation
+    assert reverse_string("hi there!") == "!ereht ih", "Spaces and punctuation failed"
+    print("All tests passed!")

practice/challenges/beginner/04-count-vowels.py

@@ -0,0 +1,36 @@
+"""
+Challenge: Count Vowels
+Difficulty: Beginner
+Concepts: strings, loops, membership testing, case handling
+Time: 10 minutes
+
+Count the number of vowels (a, e, i, o, u) in a string.
+The count should be case-insensitive.
+
+Examples:
+    >>> count_vowels("hello")
+    2
+    >>> count_vowels("AEIOU")
+    5
+"""
+
+
+def count_vowels(s: str) -> int:
+    """Count vowels in a string (case-insensitive). Implement this function."""
+    # Hint: Convert to lowercase first, then check each character against "aeiou".
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Basic word
+    assert count_vowels("hello") == 2, "Basic word failed"
+    # Test 2: All vowels
+    assert count_vowels("AEIOU") == 5, "All vowels uppercase failed"
+    # Test 3: No vowels
+    assert count_vowels("rhythm") == 0, "No vowels failed"
+    # Test 4: Empty string
+    assert count_vowels("") == 0, "Empty string failed"
+    # Test 5: Mixed case
+    assert count_vowels("Beautiful Day") == 6, "Mixed case failed"
+    print("All tests passed!")

practice/challenges/beginner/05-palindrome-check.py

@@ -0,0 +1,40 @@
+"""
+Challenge: Palindrome Check
+Difficulty: Beginner
+Concepts: strings, two-pointer technique, case normalization
+Time: 15 minutes
+
+Check if a string is a palindrome. Ignore case and non-alphanumeric characters.
+A palindrome reads the same forward and backward.
+
+Examples:
+    >>> is_palindrome("racecar")
+    True
+    >>> is_palindrome("A man, a plan, a canal: Panama")
+    True
+    >>> is_palindrome("hello")
+    False
+"""
+
+
+def is_palindrome(s: str) -> bool:
+    """Check if a string is a palindrome (ignoring case and non-alphanumeric chars). Implement this function."""
+    # Hint: First strip out non-alphanumeric characters and lowercase everything, then compare.
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Simple palindrome
+    assert is_palindrome("racecar") is True, "Simple palindrome failed"
+    # Test 2: Sentence palindrome
+    assert is_palindrome("A man, a plan, a canal: Panama") is True, "Sentence palindrome failed"
+    # Test 3: Not a palindrome
+    assert is_palindrome("hello") is False, "Not a palindrome failed"
+    # Test 4: Empty string
+    assert is_palindrome("") is True, "Empty string failed"
+    # Test 5: Single character
+    assert is_palindrome("a") is True, "Single character failed"
+    # Test 6: Numbers and letters
+    assert is_palindrome("Was it a car or a cat I saw?") is True, "Complex palindrome failed"
+    print("All tests passed!")

practice/challenges/beginner/06-sum-of-digits.py

@@ -0,0 +1,36 @@
+"""
+Challenge: Sum of Digits
+Difficulty: Beginner
+Concepts: integers, modulo, floor division, loops
+Time: 10 minutes
+
+Given a non-negative integer, return the sum of its digits.
+Do not convert the integer to a string -- use arithmetic only.
+
+Examples:
+    >>> sum_of_digits(123)
+    6
+    >>> sum_of_digits(9999)
+    36
+"""
+
+
+def sum_of_digits(n: int) -> int:
+    """Sum all digits of a non-negative integer using arithmetic. Implement this function."""
+    # Hint: Use n % 10 to get the last digit and n // 10 to remove it.
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Basic number
+    assert sum_of_digits(123) == 6, "Basic number failed"
+    # Test 2: All nines
+    assert sum_of_digits(9999) == 36, "All nines failed"
+    # Test 3: Zero
+    assert sum_of_digits(0) == 0, "Zero failed"
+    # Test 4: Single digit
+    assert sum_of_digits(7) == 7, "Single digit failed"
+    # Test 5: Large number
+    assert sum_of_digits(10001) == 2, "Large number failed"
+    print("All tests passed!")

practice/challenges/beginner/07-find-max.py

@@ -0,0 +1,40 @@
+"""
+Challenge: Find Maximum
+Difficulty: Beginner
+Concepts: lists, iteration, comparison, edge cases
+Time: 10 minutes
+
+Find the maximum value in a list of numbers without using the built-in max() function.
+Raise a ValueError if the list is empty.
+
+Examples:
+    >>> find_max([3, 1, 4, 1, 5, 9])
+    9
+    >>> find_max([-5, -1, -8])
+    -1
+"""
+
+
+def find_max(numbers: list[int | float]) -> int | float:
+    """Find the maximum value in a list without using max(). Implement this function."""
+    # Hint: Start with the first element as your candidate, then compare against each remaining element.
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Positive numbers
+    assert find_max([3, 1, 4, 1, 5, 9]) == 9, "Positive numbers failed"
+    # Test 2: Negative numbers
+    assert find_max([-5, -1, -8]) == -1, "Negative numbers failed"
+    # Test 3: Single element
+    assert find_max([42]) == 42, "Single element failed"
+    # Test 4: Mixed positive and negative
+    assert find_max([-10, 0, 10]) == 10, "Mixed numbers failed"
+    # Test 5: Empty list raises ValueError
+    try:
+        find_max([])
+        assert False, "Empty list should raise ValueError"
+    except ValueError:
+        pass
+    print("All tests passed!")

practice/challenges/beginner/08-remove-duplicates.py

@@ -0,0 +1,36 @@
+"""
+Challenge: Remove Duplicates
+Difficulty: Beginner
+Concepts: lists, sets, order preservation, membership testing
+Time: 15 minutes
+
+Remove duplicate values from a list while preserving the original order.
+The first occurrence of each value should be kept.
+
+Examples:
+    >>> remove_duplicates([1, 2, 2, 3, 1, 4])
+    [1, 2, 3, 4]
+    >>> remove_duplicates(["a", "b", "a", "c"])
+    ['a', 'b', 'c']
+"""
+
+
+def remove_duplicates(items: list) -> list:
+    """Remove duplicates from a list, preserving order. Implement this function."""
+    # Hint: Use a set to track what you have already seen as you iterate.
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Integers with duplicates
+    assert remove_duplicates([1, 2, 2, 3, 1, 4]) == [1, 2, 3, 4], "Integer duplicates failed"
+    # Test 2: Strings
+    assert remove_duplicates(["a", "b", "a", "c"]) == ["a", "b", "c"], "String duplicates failed"
+    # Test 3: No duplicates
+    assert remove_duplicates([1, 2, 3]) == [1, 2, 3], "No duplicates failed"
+    # Test 4: All duplicates
+    assert remove_duplicates([5, 5, 5, 5]) == [5], "All duplicates failed"
+    # Test 5: Empty list
+    assert remove_duplicates([]) == [], "Empty list failed"
+    print("All tests passed!")

practice/challenges/beginner/09-word-frequency.py

@@ -0,0 +1,38 @@
+"""
+Challenge: Word Frequency
+Difficulty: Beginner
+Concepts: strings, dictionaries, splitting, case normalization
+Time: 20 minutes
+
+Count the frequency of each word in a text string. Words should be
+compared case-insensitively. Return a dictionary mapping lowercase
+words to their counts. Split on whitespace only.
+
+Examples:
+    >>> word_frequency("the cat and the dog")
+    {'the': 2, 'cat': 1, 'and': 1, 'dog': 1}
+    >>> word_frequency("Hello hello HELLO")
+    {'hello': 3}
+"""
+
+
+def word_frequency(text: str) -> dict[str, int]:
+    """Count word frequencies in text (case-insensitive). Implement this function."""
+    # Hint: Use .lower().split() to get normalized words, then build a dict with counts.
+    pass
+
+
+# --- Tests (do not modify) ---
+if __name__ == "__main__":
+    # Test 1: Basic sentence
+    assert word_frequency("the cat and the dog") == {"the": 2, "cat": 1, "and": 1, "dog": 1}, "Basic sentence failed"
+    # Test 2: Case insensitive
+    assert word_frequency("Hello hello HELLO") == {"hello": 3}, "Case insensitive failed"
+    # Test 3: Single word
+    assert word_frequency("Python") == {"python": 1}, "Single word failed"
+    # Test 4: Empty string
+    assert word_frequency("") == {}, "Empty string failed"
+    # Test 5: Multiple spaces
+    result = word_frequency("a  b  a")
+    assert result == {"a": 2, "b": 1}, "Multiple spaces failed"
+    print("All tests passed!")