Watch 9 video solutions for High-Access Employees, a medium level problem involving Array, Hash Table, String. This walkthrough by Prakhar Agrawal has 1,361 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
You are given a 2D 0-indexed array of strings, access_times, with size n. For each i where 0 <= i <= n - 1, access_times[i][0] represents the name of an employee, and access_times[i][1] represents the access time of that employee. All entries in access_times are within the same day.
The access time is represented as four digits using a 24-hour time format, for example, "0800" or "2250".
An employee is said to be high-access if he has accessed the system three or more times within a one-hour period.
Times with exactly one hour of difference are not considered part of the same one-hour period. For example, "0815" and "0915" are not part of the same one-hour period.
Access times at the start and end of the day are not counted within the same one-hour period. For example, "0005" and "2350" are not part of the same one-hour period.
Return a list that contains the names of high-access employees with any order you want.
Example 1:
Input: access_times = [["a","0549"],["b","0457"],["a","0532"],["a","0621"],["b","0540"]] Output: ["a"] Explanation: "a" has three access times in the one-hour period of [05:32, 06:31] which are 05:32, 05:49, and 06:21. But "b" does not have more than two access times at all. So the answer is ["a"].
Example 2:
Input: access_times = [["d","0002"],["c","0808"],["c","0829"],["e","0215"],["d","1508"],["d","1444"],["d","1410"],["c","0809"]] Output: ["c","d"] Explanation: "c" has three access times in the one-hour period of [08:08, 09:07] which are 08:08, 08:09, and 08:29. "d" has also three access times in the one-hour period of [14:10, 15:09] which are 14:10, 14:44, and 15:08. However, "e" has just one access time, so it can not be in the answer and the final answer is ["c","d"].
Example 3:
Input: access_times = [["cd","1025"],["ab","1025"],["cd","1046"],["cd","1055"],["ab","1124"],["ab","1120"]] Output: ["ab","cd"] Explanation: "ab" has three access times in the one-hour period of [10:25, 11:24] which are 10:25, 11:20, and 11:24. "cd" has also three access times in the one-hour period of [10:25, 11:24] which are 10:25, 10:46, and 10:55. So the answer is ["ab","cd"].
Constraints:
1 <= access_times.length <= 100access_times[i].length == 21 <= access_times[i][0].length <= 10access_times[i][0] consists only of English small letters.access_times[i][1].length == 4access_times[i][1] is in 24-hour time format.access_times[i][1] consists only of '0' to '9'.Problem Overview: You receive a list of employee access logs where each record contains an employee name and a time in HHMM format. The goal is to return all employees who accessed the system three or more times within any one-hour window.
Approach 1: Sorting and Sliding Window (O(n log n) time, O(n) space)
The most practical solution groups logs by employee, converts the access time into minutes, and sorts each employee's access list. Sorting ensures chronological order so you can scan for any 60‑minute window containing at least three accesses. Use a sliding window (two pointers) over the sorted list: move the right pointer forward and check whether time[right] - time[left] <= 60. If the window size reaches three, mark that employee as high‑access. If the time gap exceeds 60 minutes, move the left pointer forward to shrink the window. Sorting dominates the cost, giving O(n log n) time overall and O(n) space for grouped logs.
This approach works well because access events for each employee are independent. Sorting plus a sliding window efficiently detects dense time intervals without repeatedly scanning the entire list. The technique appears frequently in interval and log analysis problems and combines ideas from sorting and the sliding window pattern.
Approach 2: Hash Map and Fixed Interval Counting (O(n log n) time, O(n) space)
Another clean approach uses a hash table mapping each employee to a list of their access times. After building the map, convert times to minutes and sort each employee's list. Instead of a dynamic sliding window, check fixed triplets: for every index i, verify whether times[i + 2] - times[i] <= 60. If true, the three accesses fall inside a one‑hour window, so the employee qualifies. Because only triplets are checked, the scan is linear after sorting.
This method reduces pointer management and keeps the logic simple. Sorting each employee's access list still determines the total time complexity. Space remains O(n) for storing grouped logs.
Recommended for interviews: The sorting + sliding window approach is the one most interviewers expect. It shows you recognize the chronological constraint and can efficiently maintain a dynamic time window. The hash‑map triplet check is slightly simpler and equally valid, but the sliding window demonstrates stronger familiarity with common log‑analysis patterns.
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Sorting + Sliding Window | O(n log n) | O(n) | Best general solution for detecting time windows within sorted logs |
| Hash Map + Fixed Triplet Check | O(n log n) | O(n) | Simpler logic when only checking groups of three accesses |