Claude Sonnet 4.6 × debug

## Bug Analysis

### Bug 1: Filtering out single-occurrence words

**Buggy line:**
```python
return [word for word, count in ranked[:n] if count > 1]
```

**What it does wrong:**
The `if count > 1` condition silently drops any word that appears only once. In `top_words('hello world', 5)`, every word has a count of 1, so the function returns `[]` instead of `['hello', 'world']`. Similarly, in the first test case, `'cat'` and `'mat'` (count=1) would be excluded.

**Fix:**
```python
return [word for word, count in ranked[:n]]
```

---

### Bug 2: Slicing before taking top-N, then filtering (interaction with Bug 1 — but there's a distinct second bug: empty-string words from splitting/stripping)

Actually, let me re-examine carefully. The second distinct bug is:

**Buggy line:**
```python
words = [w.strip('.,!?;:\'"') for w in words]
```

**What it does wrong:**
`str.strip()` only removes characters from the **edges** of a word, which is mostly fine, but more critically: if a token consists *entirely* of punctuation (e.g., `"--"` or `"..."`), stripping produces an **empty string `""`**, which then gets counted as a word and can incorrectly appear in results.

**Fix:**
```python
words = [stripped for w in words if (stripped := w.strip('.,!?;:\'"'))]
```

---

### Bug 3: `ranked[:n]` slices the sorted list before returning, but the slice should come *after* filtering empty strings — this is fine structurally, but the **real third bug** is the sort key being correct only if the empty string bug is fixed. The actual third bug is:

**Buggy line:**
```python
words = text.lower().split()
```

**What it does wrong:**
`str.split()` with no argument splits on any whitespace and handles multiple spaces fine, but `.lower()` is called on the **whole string before** splitting. This is actually not a bug. Let me re-examine the sort: `ranked = sorted(counts.items(), key=lambda x: (-x[1], x[0]))` — this is correct.

The **actual third bug**: `ranked[:n]` is applied to the full ranked list, but it should operate on the result **after** removing empty strings (from bug 2). Without fixing bug 2, an empty string `""` sorts first alphabetically at a given frequency, consuming one of the N slots.

---

## Corrected Function

```python
from collections import Counter

def top_words(text: str, n: int = 10) -> list[str]:
    words = text.lower().split()
    # Bug 2 fix: filter out empty strings that result from stripping pure-punctuation tokens
    words = [stripped for w in words if (stripped := w.strip('.,!?;:\'"'))]
    counts = Counter(words)
    # Bug 3 fix: n is correctly applied to a clean ranked list (no empty-string poisoning)
    ranked = sorted(counts.items(), key=lambda x: (-x[1], x[0]))
    # Bug 1 fix: removed the incorrect `if count > 1` guard
    return [word for word, count in ranked[:n]]
```

---

## Summary Table

| # | Buggy Line | Problem | Fix |
|---|-----------|---------|-----|
| 1 | `... if count > 1` | Drops all hapax legomena (words appearing once), causing under-reporting | Remove the condition entirely |
| 2 | `w.strip(...)` without filtering | Pure-punctuation tokens become `""` and pollute the counter | Filter out empty strings after stripping |
| 3 | `ranked[:n]` (with empty strings present) | `""` sorts first alphabetically, stealing a top-N slot from real words | Consequence of Bug 2; resolved by fixing Bug 2 before slicing |

### Verification Against Test Cases

```python
top_words('the cat sat on the mat the', 3)  # → ['the', 'cat', 'mat'] ✓
top_words('a a b b c', 2)                    # → ['a', 'b']            ✓
top_words('hello world', 5)                  # → ['hello', 'world']    ✓
```