Authentication System

Implement a session-based authentication system that manages user sessions using unique token IDs and a configurable time-to-live (time_to_live, or TTL) measured in seconds.
When a token is generated, its expiration time is current_time + time_to_live. A token may be renewed only while it is still unexpired; a successful renewal resets its expiration time to current_time + time_to_live.
Process every string in queries in the given order. The system must support these three operations:
generate <token_id> <current_time>: At current_time, create a new token with the specified ID. Its expiration time is current_time + time_to_live.
renew <token_id> <current_time>: At current_time, extend an existing unexpired token's expiration time to current_time + time_to_live. Ignore the request if the token does not exist or has already expired.
count <current_time>: Return the number of unexpired tokens at current_time.
Important: Token expiration is evaluated before processing any action at the same timestamp. If a token's expiration time is exactly equal to current_time, the token is expired and cannot be renewed or counted.

Function
getUnexpiredTokens(time_to_live: int, queries: String[]) → int[]

Examples
Example 1
time_to_live = 5
queries = ["generate aaa 1","renew aaa 2","count 6","generate bbb 7","renew aaa 8","renew bbb 10","count 15"]
return = [1,0]
At time 6, token aaa is the only unexpired token, so the first count is 1. At time 15, all tokens have expired, so the second count is 0.
Example 2
time_to_live = 35
queries = ["generate token1 3","count 4","generate token2 6","count 7","generate token3 11","count 41"]
return = [1,2,1]
After generate token1 3, token1 expires at time 38.
At count 4, only token1 is unexpired, so the result is 1.
After generate token2 6, token2 expires at time 41.
At count 7, token1 and token2 are unexpired, so the result is 2.
After generate token3 11, token3 expires at time 46.
At count 41, token1 has expired, token2 expires at the same timestamp and is therefore already expired, and token3 remains unexpired. The result is 1.
Example 3
time_to_live = 9
queries = ["generate token1 3","renew token1 5","generate token2 7","renew token2 8","generate token3 9","count 12"]
return = [3]
After generate token1 3, token1 expires at time 12.
After renew token1 5, its expiration time becomes 14.
After generate token2 7, token2 expires at time 16.
After renew token2 8, its expiration time becomes 17.
After generate token3 9, token3 expires at time 18.
At count 12, all three tokens are unexpired, so the result is 3.

Keep a hash map from token_id to expiration time. Generate sets map[id] = t + ttl. Renew checks that the id exists and map[id] > t, then sets map[id] = t + ttl. Count scans the map and counts entries where expiration > t. That's O(n) per count, fine for most inputs. If the input is large, add a min-heap of expirations or a lazy cleanup, but renewals leave stale heap entries, so validate against the map when popping. The pitfall is the strict inequality. Example 2 shows it: token2 expires at 41, count at 41 returns 1, not 2. Also parse each query by splitting on spaces, and only append results for count queries. If the boundary logic or the heap cleanup trips you up mid-assessment, StealthCoder is the hedge that gives you a working solution on screen without the proctor seeing it.

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