Maximum Frequency Stack

Process operations on a frequency stack.
push adds its value.
pop removes and returns a value with the greatest current frequency. Among tied values, remove the one pushed most recently.
The value paired with a pop is ignored. Return the popped values in operation order.

Function
processFrequencyStack(operations: String[], values: int[]) → int[]

Examples
Example 1
operations = ["push","push","push","push","push","push","pop","pop","pop","pop"]
values = [5,7,5,7,4,5,0,0,0,0]
return = [5,7,5,4]
The first pop chooses frequency 3; later ties use push recency.
Example 2
operations = ["push","push","pop","pop"]
values = [1,2,0,0]
return = [2,1]
Both values initially have frequency one, so 2 leaves first.
Example 3
operations = ["push","push","push","pop"]
values = [9,9,3,0]
return = [9]
Frequency two beats the more recent frequency-one value.

Constraints
1 <= operations.length == values.length <= 20000.
Each operation is push or pop.
0 <= values[i] <= 10^9 for pushes.
Every pop occurs while the structure is nonempty.

The trick is two hash maps. Keep freq[value] for the current count of each value, and group[f], a stack of values that reached frequency f, in push order. Track maxFreq. On push, increment freq[v], update maxFreq, and append v to group[freq[v]]. On pop, take the top of group[maxFreq], remove it, decrement freq[v], and if group[maxFreq] is now empty, decrement maxFreq. Every operation is O(1), so 20000 operations is trivial. The common pitfall is reaching for a heap with a timestamp, which works but costs O(log n) and needs lazy deletion bugs. Another miss is decrementing freq but leaving the value in the lower group. That's correct, because it was already pushed there earlier. Ignore the values entry on pops. If you freeze during the live OA, StealthCoder can surface this structure so you're not rebuilding it under pressure.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.