Users with a Short Sign-In Session

logs are globally sorted by increasing integer timestamp. Each entry is timestamp user SIGNIN or timestamp user SIGNOUT. Per user, sessions are well formed and non-overlapping.
Return sorted user ids that have at least one session with duration at most maxTime, where duration is signout timestamp minus its paired signin timestamp.

Function
usersWithShortSession(logs: String[], maxTime: int) → String[]

Examples
Example 1
logs = ["1 alice SIGNIN","2 bob SIGNIN","5 alice SIGNOUT","12 bob SIGNOUT"]
maxTime = 5
return = ["alice"]
Alice's duration is 4; Bob's is 10.
Example 2
logs = ["0 a SIGNIN","3 a SIGNOUT","10 a SIGNIN","20 a SIGNOUT"]
maxTime = 3
return = ["a"]
At least one qualifying session is sufficient.
Example 3
logs = ["1 z SIGNIN","9 z SIGNOUT"]
maxTime = 7
return = []
The only duration is 8.

Constraints
0 <= logs.length <= 2 * 10^5.
Timestamps are strictly increasing nonnegative integers.
User ids have no spaces and each user's events alternate SIGNIN, SIGNOUT.

Walk the logs once. Split each line into timestamp, user, and event. On SIGNIN, store map[user] = timestamp. On SIGNOUT, compute timestamp - map[user], and if it's <= maxTime, add the user to a set. Since each user's events strictly alternate, you never need a stack or a queue, just one open signin per user. Pitfalls: using < instead of <= (Example 1 and 3 test the boundary), parsing the timestamp as a string and comparing lexicographically, and forgetting to sort the final output. Also handle empty logs, which should return an empty list. A set dedupes users with several short sessions, as in Example 2. Complexity is O(n) for the scan plus O(k log k) for sorting the result. With up to 2 * 10^5 lines, this is comfortably fast. If you freeze on parsing or the sort step, StealthCoder can hand you the working code live.

If you see this problem in your OA tomorrow, the play is to recognize the pattern in 30 seconds. StealthCoder buys you that recognition.