GLM-5.2 Fast Preview API

Here are the bugs in the provided function:

### Bug 1: Ties are not broken alphabetically **Why it's wrong:** The sorting key `lambda kv: -kv[1]` only sorts the words by their frequency in descending order. Python's `sorted` function is stable, meaning that if two words have the same frequency, they will retain their original relative order (which is the order they were inserted into the dictionary), not alphabetical order. **Fix:** Change the sorting key to a tuple: `lambda kv: (-kv[1], kv[0])`. This sorts by frequency descending (`-kv[1]`), and for ties, it sorts by the word alphabetically ascending (`kv[0]`).

### Bug 2: Punctuation is not stripped **Why it's wrong:** The function uses `text.lower().split()`, which splits the text by whitespace but leaves punctuation attached to the words. For example, the word `"apple"` and `"apple!"` will be treated as two completely different words, resulting in incorrect frequency counts. **Fix:** Use a regular expression like `re.findall(r'\w+', text.lower())` to extract only the alphanumeric words, ignoring punctuation.

### Bug 3 (Edge Case): No handling for negative `k` **Why it's wrong:** If `k` is negative, `ranked[:k]` behaves unexpectedly in Python (it returns all items except the last `k` items). A top-k function should ideally just return an empty list if `k <= 0`. **Fix:** Add an early return `if k <= 0: return []`.

### Corrected Version

```python import re

def top_k_words(text, k): if k <= 0: return [] # Extract words (alphanumeric sequences) and convert to lowercase words = re.findall(r'\w+', text.lower()) # Count frequencies counts = {} for w in words: counts[w] = counts.get(w, 0) + 1 # Sort by frequency (descending) and alphabetically (ascending) for ties ranked = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0])) return [w for w, _ in ranked[:k]] ```

### Complexity Let \(N\) be the number of words in the text, and \(U\) be the number of unique words (so \(U \le N\)).

**Time Complexity:** - Finding words and counting: \(O(N)\) - Sorting the unique words: \(O(U \log U)\) - Slicing the list: \(O(k)\) Overall Time Complexity: **\(O(N + U \log U)\)**

*(Note: If we wanted to optimize the time complexity strictly for \(k\), we could use a min-heap of size \(k\) via `heapq.nlargest`, which would reduce the time complexity to \(O(N + U \log k)\). However, the standard `sorted` approach is cleaner and usually sufficient unless \(U\) is massive).*

**Space Complexity:** - The `counts` dictionary takes \(O(U)\) space. - The `ranked` list takes \(O(U)\) space. Overall Space Complexity: **\(O(U)\)** (or \(O(N)\) in the worst case where every word is unique).