High-Access Employees

High-Access Employees - Problem

You are given a 2D array of strings access_times of 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 in 24-hour format ("0800" or "2250").

An employee is high-access if they accessed the system three or more times within a one-hour period. Times with exactly one hour of difference are not part of the same one-hour period. For example, "0815" and "0915" are not part of the same one-hour period.

Return a list containing the names of high-access employees in any order.

Input & Output

Example 1 — Multiple Employees

$ Input: access_times = [["a","0549"],["b","0457"],["a","0532"],["a","0621"],["b","0540"]]

› Output: []

💡 Note: Employee 'a' has access times at 0549 (9:49), 0532 (5:32), and 0621 (6:21). After sorting: 532, 549, 621. The span from 532 to 621 is 89 minutes, which is greater than 60 minutes, so 'a' is not high-access. Employee 'b' only has 2 accesses. Therefore, no employees are high-access.

Example 2 — Close Time Window

$ Input: access_times = [["d","0002"],["c","0808"],["c","0829"],["e","0215"],["d","1508"],["d","1444"],["d","1410"],["c","0809"]]

› Output: ["c","d"]

💡 Note: Employee 'c' has times 808, 829, 809. Sorted: 808, 809, 829. Window 808-829 = 21 minutes with 3 accesses. Employee 'd' has times 0002, 1508, 1444, 1410. Sorted: 2, 1410, 1444, 1508. Window 1410-1508 = 58 minutes with 3 accesses.

Example 3 — No Violations

$ Input: access_times = [["cd","0000"],["cd","0200"],["cd","0400"]]

› Output: []

💡 Note: Employee 'cd' has times 0000, 0200, 0400. These are spaced 120 minutes apart (0000 to 0200 = 120 min, 0200 to 0400 = 120 min), so no 3 accesses occur within 60 minutes.

Constraints

1 ≤ access_times.length ≤ 100
access_times[i].length == 2
1 ≤ access_times[i][0].length ≤ 10
access_times[i][0] consists only of English small letters
access_times[i][1].length == 4
access_times[i][1] is in 24-hour time format

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8

The key insight is to group access times by employee, then use sliding window on sorted times to efficiently detect 3+ accesses within 60 minutes. The optimized approach sorts each employee's times and checks consecutive windows. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Check All Combinations

⏱️ Time: O(n × m³) Space: O(n)

For each employee, collect all their access times and check every possible combination of 3 accesses to see if they fall within a one-hour window.

Optimized - Sort and Sliding Window

⏱️ Time: O(n log n) Space: O(n)

Group accesses by employee, sort their times, then use a sliding window approach to efficiently check if any 3 consecutive accesses fall within a 60-minute period.

Brute Force - Check All Combinations — Algorithm Steps

Group access times by employee name
For each employee, check all combinations of 3 access times
Convert time strings to minutes for easy comparison
Check if any 3 times fall within 60-minute window

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by Employee

Collect all access times for each employee

Check Combinations

For each employee, try all combinations of 3 times

Find Violations

Mark employees with 3+ accesses in <60 minutes

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int time;
    int returned;
} Result;

Result* solution(char* fnCode, int* args, int argsSize, int t, int cancelTimeMs, int* returnSize) {
    Result* results = malloc(100 * sizeof(Result));
    int currentTime = 0;
    int count = 0;
    
    // Initialize x from args
    int x = (argsSize > 0) ? args[0] : 0;
    
    // First call at time 0
    results[count].time = currentTime;
    results[count].returned = x;
    count++;
    x++; // Increment after returning
    
    // Schedule subsequent calls
    currentTime += t;
    while (currentTime < cancelTimeMs) {
        results[count].time = currentTime;
        results[count].returned = x;
        count++;
        x++; // Increment after returning
        currentTime += t;
    }
    
    *returnSize = count;
    return results;
}

int parseArgs(char* argsStr, int* args) {
    int count = 0;
    char* ptr = argsStr;
    
    // Skip opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            args[count] = 0;
            while (*ptr >= '0' && *ptr <= '9') {
                args[count] = args[count] * 10 + (*ptr - '0');
                ptr++;
            }
            count++;
        } else {
            ptr++;
        }
    }
    
    return count;
}

int main() {
    char fnCode[100];
    char argsStr[100];
    int t, cancelTimeMs;
    
    fgets(fnCode, sizeof(fnCode), stdin);
    fgets(argsStr, sizeof(argsStr), stdin);
    scanf("%d", &t);
    scanf("%d", &cancelTimeMs);
    
    // Parse args properly
    int args[10];
    int argsSize = parseArgs(argsStr, args);
    
    int returnSize;
    Result* result = solution(fnCode, args, argsSize, t, cancelTimeMs, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("{\"time\":%d,\"returned\":%d}", result[i].time, result[i].returned);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m³)

For each employee (n total accesses), check all combinations of 3 times (m³ where m is accesses per employee)

⚡ Linearithmic

Space Complexity

O(n)

Hash map to group accesses by employee name

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

234 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler