High-Access Employees
A medium-tier problem at 46% community acceptance, tagged with Array, Hash Table, String. Reported in interviews at Atlassian and 1 others.
High-Access Employees shows up in live OAs at Atlassian and Goldman Sachs, and the 46% acceptance rate tells you most candidates miss the real pattern on first attempt. You're given access logs and need to identify which employees accessed the system too many times in a narrow time window. The trick isn't complicated once you see it, but the off-by-one errors and edge cases in time-window logic trip people up hard. If this lands in your assessment and you blank on the filtering logic, StealthCoder surfaces a clean solution in seconds while the proctor sees nothing.
Companies that ask "High-Access Employees"
High-Access Employees is the kind of problem that decides whether you pass. StealthCoder reads the problem on screen and surfaces a working solution in under 2 seconds. Invisible to screen share. The proctor sees nothing. Built by an Amazon engineer who used it to pass JPMorgan's OA and system design loop.
Get StealthCoderThe problem boils down to a two-step filter using a hash table to group access times by employee, then a sorting pass to check if any employee crosses the threshold in the required time span. Most candidates either miscount the window boundaries or iterate inefficiently through all possible minute ranges. The trap is treating the time window as a closed interval when it's really about consecutive access density. You need to sort each employee's timestamps and slide a window checking if any minute-to-minute span contains too many hits. Array iteration and hash tables handle the heavy lifting, but the string parsing of timestamps and the exact window logic are where candidates usually lose points. When you hit this live and the time-window math gets fuzzy, StealthCoder runs invisibly and hands you a working implementation that handles the boundary cases correctly.
Pattern tags
You know the problem.
Make sure you actually pass it.
High-Access Employees recycles across companies for a reason. It's medium-tier, and most candidates blank under the timer. StealthCoder is the hedge: an AI overlay invisible during screen share. It reads the problem and surfaces a working solution in under 2 seconds. Built by an Amazon engineer who used it to pass JPMorgan's OA and system design loop. Works on HackerRank, CodeSignal, CoderPad, and Karat.
High-Access Employees interview FAQ
Why does this problem have such a low acceptance rate if it's just hash tables and sorting?+
The 46% rate reflects how easy it is to misdefine the access window or count boundaries wrong. You can nail the hash table grouping and sorting, then fail on the final check that actually validates the time constraint. Off-by-one errors and threshold confusion are common. The logic feels simple until you're debugging test case 7 at minute 58 of your OA.
Is this actually asked in live interviews, or is it an online-assessment-only problem?+
Both Atlassian and Goldman Sachs have asked it in their reported OAs. It's the kind of problem that screens for whether you can handle data filtering and time-series logic without overthinking, skills both companies value in production systems.
Do I need to optimize beyond O(n log n) sorting?+
No. Sorting all timestamps plus a sliding-window pass is the standard approach and efficient enough. The problem isn't a trick to optimize further. It's a trap on correctness. Get the window logic right first, worry about micro-optimizations never.
What's the single biggest gotcha with time windows in this problem?+
Whether the window is inclusive or exclusive on both ends, and whether you count the endpoints correctly. Most candidates check 'in the last 60 minutes' wrong. Read the problem statement three times on that detail alone. It's where you'll lose points if you don't nail it in your first pass.
How does this problem connect to the other topics like String and Array?+
Timestamps come as strings and need parsing. Access logs are arrays you iterate and group. Hash tables aggregate by employee. Sorting orders the data for the window check. It's a practical workflow problem, not a pure data-structures quiz. All four topics matter equally.
Want the actual problem statement? View "High-Access Employees" on LeetCode →