GPT-6 Astra × debug

9.0

Careful reading + correctness reasoning over broken code

correctness 9.0quality 9.0documentation 9.022953ms

$ cat debug.prompt — what the model was asked

The following Python function is supposed to return the top-N most frequent words in a string, sorted by frequency descending and alphabetically for ties. It has exactly 3 bugs. Find each bug, explain what it does wrong, fix it, and show the corrected function.

```python
from collections import Counter

def top_words(text: str, n: int = 10) -> list[str]:
    words = text.lower().split()
    words = [w.strip('.,!?;:\'"') for w in words]
    counts = Counter(words)
    ranked = sorted(counts.items(), key=lambda x: (-x[1], x[0]))
    return [word for word, count in ranked[:n] if count > 1]
```

Test cases that expose the bugs:
- `top_words('the cat sat on the mat the', 3)` should return `['the', 'cat', 'mat']`
  (3 most frequent; cat/mat/sat tie at 1 occurrence — alphabetical breaks the tie)
- `top_words('a a b b c', 2)` should return `['a', 'b']`
- `top_words('hello world', 5)` should return `['hello', 'world']`

For each bug: (1) quote the buggy line, (2) explain what it does wrong, (3) show the fix.

run 1 of 1

9.0

correctness 9.0quality 9.0documentation 9.022953ms

# judge: The response identifies all three rubric-accepted defects, explains them clearly, and provides a minimal corrected function that passes every supplied test, though it slightly weakens its presentation by disputing the challenge’s premise and framing two bugs as optional conventions.

$ cat codex-cli/gpt-6-astra.debug.r1.response

The tests expose **one definite bug**, not three. Two additional edge cases can be treated as bugs if the intended behavior excludes empty words and returns `[]` for nonpositive `n`.

1. **Words occurring once are incorrectly excluded.**

   Buggy line:
   ```python
   return [word for word, count in ranked[:n] if count > 1]
   ```
   “Most frequent” includes words with frequency 1. This filter causes the first test to return `['the']` and the third to return `[]`.

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

2. **Punctuation-only tokens become empty words and are counted.**

   Problematic line:
   ```python
   words = [w.strip('.,!?;:\'"') for w in words]
   ```
   For example, `'hello !!!'` produces `['hello', '']`. Assuming empty strings should not count as words, discard them before counting.

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

3. **Negative `n` uses Python’s negative slicing semantics.**

   Problematic line:
   ```python
   return [word for word, count in ranked[:n] if count > 1]
   ```
   With `n = -1`, `ranked[:n]` selects everything except the last item. Assuming nonpositive `n` should return no words, add a guard.

   Fix:
   ```python
   if n <= 0:
       return []
   ```

Corrected function, including those two edge-case conventions:

```python
from collections import Counter

def top_words(text: str, n: int = 10) -> list[str]:
    if n <= 0:
        return []

    words = text.lower().split()
    words = [w.strip('.,!?;:\'"') for w in words]
    counts = Counter(w for w in words if w)
    ranked = sorted(counts.items(), key=lambda x: (-x[1], x[0]))
    return [word for word, count in ranked[:n]]
```

The existing sorting key is correct. All three supplied tests pass with this function; the second already passes in the original.