Claude Sonnet 4.6 × fizzbuzz

## FizzBuzz Implementation

```python
def fizzbuzz(n: int) -> list[str]:
    """
    Generate a FizzBuzz sequence from 1 to n (inclusive).

    For each number in the range:
    - Returns 'FizzBuzz' if the number is divisible by both 3 and 5
    - Returns 'Fizz' if the number is divisible by 3 only
    - Returns 'Buzz' if the number is divisible by 5 only
    - Returns the number as a string otherwise

    Args:
        n: The upper bound of the sequence (inclusive). Must be a positive integer.

    Returns:
        A list of strings representing the FizzBuzz sequence from 1 to n.

    Raises:
        TypeError: If n is not an integer.
        ValueError: If n is less than 1.

    Examples:
        >>> fizzbuzz(15)
        ['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']

        >>> fizzbuzz(5)
        ['1', '2', 'Fizz', '4', 'Buzz']

        >>> fizzbuzz(1)
        ['1']
    """
    if not isinstance(n, int):
        raise TypeError(f"n must be an integer, got {type(n).__name__}")
    if n < 1:
        raise ValueError(f"n must be a positive integer, got {n}")

    result = []
    for i in range(1, n + 1):
        if i % 15 == 0:       # Check 15 first to avoid overriding FizzBuzz with Fizz/Buzz
            result.append("FizzBuzz")
        elif i % 3 == 0:
            result.append("Fizz")
        elif i % 5 == 0:
            result.append("Buzz")
        else:
            result.append(str(i))

    return result


# --- Usage Examples ---
if __name__ == "__main__":
    # Basic usage
    print("FizzBuzz up to 15:")
    print(fizzbuzz(15))

    # Formatted output
    print("\nFormatted FizzBuzz up to 20:")
    for index, value in enumerate(fizzbuzz(20), start=1):
        print(f"  {index:>2}: {value}")

    # Edge cases
    print(f"\nSingle element: {fizzbuzz(1)}")
    print(f"Up to 5:        {fizzbuzz(5)}")
```

### Sample Output

```
FizzBuzz up to 15:
['1', '2', 'Fizz', '4', 'Buzz', 'Fizz', '7', '8', 'Fizz', 'Buzz', '11', 'Fizz', '13', '14', 'FizzBuzz']

Formatted FizzBuzz up to 20:
   1: 1
   2: 2
   3: Fizz
   4: 4
   5: Buzz
   6: Fizz
   7: 7
   8: 8
   9: Fizz
  10: Buzz
  11: 11
  12: Fizz
  13: 13
  14: 14
  15: FizzBuzz
  16: 16
  17: 17
  18: Fizz
  19: 19
  20: Buzz

Single element: ['1']
Up to 5:        ['1', '2', 'Fizz', '4', 'Buzz']
```

### Key Design Decisions

| Decision | Reason |
|---|---|
| Check `% 15` first | Cleanly handles the FizzBuzz case without nested conditions |
| `TypeError` / `ValueError` | Provides clear, actionable error messages for bad input |
| Returns `list[str]` | Consistent type — numbers are strings too, making iteration uniform |
| Validates `n >= 1` | An empty or negative range has no meaningful FizzBuzz output |