Stable Top K Frequent Words

Given an array of words and an integer k, return the k distinct words with the highest frequencies.
Rank words by descending frequency. When two words have the same frequency, rank the word whose first occurrence has the smaller array index first. Return the selected words in this ranking order.

Function
topKFrequentStable(words: String[], k: int) → String[]

Examples
Example 1
words = ["apple","banana","apple","cherry","banana","date"]
k = 2
return = ["apple","banana"]
apple and banana each occur twice. The first apple appears at index 0, before the first banana at index 1.
Example 2
words = ["z","a","z","a","b"]
k = 3
return = ["z","a","b"]
z and a have frequency two and keep first-occurrence order. The remaining word b is third.
Example 3
words = ["solo"]
k = 1
return = ["solo"]
The only distinct word is selected.

Constraints
1 <= words.length <= 200000
1 <= words[i].length <= 30
Each word contains lowercase English letters.
1 <= k <= the number of distinct words.

Walk the array once and build a map from word to a pair: count and first index. Only set the first index when the word is new. That's O(n). Then you have two clean options. Sort the distinct entries by count descending, then first index ascending, and slice the first k. That's O(m log m) where m is distinct words. Or use a heap of size k with the same comparator, which is O(m log k). Both pass at this input size. The pitfall is copying the classic LeetCode answer, which breaks ties alphabetically. Here alphabetical order gives wrong output on example 2 style cases. Another trap is updating the first index on every occurrence, which turns it into last index. If you freeze up on the comparator during the live OA, StealthCoder is the hedge that reads the problem and hands you the working version.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.