Expiring Authentication Token Manager

You are given a token lifetime timeToLive and an ordered array of authentication-manager operations operations.
Each operation is an array of three strings: [type, tokenId, currentTime]. The supported operation types are:
GENERATE: create the unique token tokenId at currentTime. Its expiration time becomes currentTime + timeToLive.
RENEW: if tokenId exists and is unexpired at currentTime, reset its expiration time to currentTime + timeToLive. Otherwise, ignore the operation.
COUNT: count the tokens that are unexpired at currentTime. For this operation, tokenId is the empty string.
A token is unexpired at time t exactly when its expiration time is strictly greater than t. Therefore, a token is already expired at the instant equal to its expiration time.
Return one count for every COUNT operation, preserving query order. GENERATE and RENEW operations do not add values to the returned array.

Function
countUnexpiredTokens(timeToLive: int, operations: String[][]) → int[]

Examples
Example 1
timeToLive = 5
operations = [["GENERATE","aaa","1"],["RENEW","aaa","2"],["COUNT","","6"],["GENERATE","bbb","7"],["RENEW","aaa","8"],["RENEW","bbb","10"],["COUNT","","12"]]
return = [1,1]
Token aaa first expires at time 6, then renewal at time 2 moves its expiration to 7, so the count at time 6 is 1. It is expired by time 8, so that renewal is ignored. Token bbb is renewed from expiration time 12 to 15, so the count at time 12 is also 1.
Example 2
timeToLive = 3
operations = [["GENERATE","alpha","1"],["COUNT","","3"],["COUNT","","4"]]
return = [1,0]
Token alpha expires at time 4. It is unexpired at time 3 but expired at time 4.
Example 3
timeToLive = 4
operations = [["RENEW","ghost","1"],["GENERATE","x","2"],["GENERATE","y","3"],["RENEW","x","4"],["COUNT","","5"],["COUNT","","7"],["COUNT","","8"]]
return = [2,1,0]
Renewing the missing token ghost has no effect. Renewal moves token x's expiration to time 8, while token y expires at time 7. The three counts are therefore 2, 1, and 0.

Constraints
1 <= timeToLive <= 10^8.
1 <= operations.length <= 2000.
Every operation contains exactly three strings and uses one of GENERATE, RENEW, or COUNT.
Every non-empty tokenId contains from 1 through 10 lowercase English letters.
Every token ID used by GENERATE is unique.
Operation times are decimal integers from 1 through 10^8 and are strictly increasing across the array.

Store a hash map from tokenId to expiration time. GENERATE sets map[id] = t + timeToLive. RENEW checks that the id exists and map[id] > t, then resets it to t + timeToLive. Otherwise ignore it. COUNT loops over the map and counts entries with expiration > t. With at most 2000 operations, that O(n^2) worst case is fine, so don't build a heap or a sorted structure you don't need. The pitfall is the boundary. Use strictly greater, not greater-or-equal, or Example 2 returns 1 instead of 0 at time 4. Another trap is parsing: the times arrive as strings, so convert them to integers before comparing, or you'll compare lexicographically. Also remember COUNT has an empty tokenId and shouldn't touch the map. If the boundary logic slips under pressure, StealthCoder is the hedge that catches it live.

Drill it cold or hedge it with StealthCoder. Either way, don't walk into the OA hoping you remember the trick.