High-Access Employees - Practice Coding Problems

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: ["a"]

💡 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, but 532 to 549 is 17 minutes and we need to check sliding windows. Times 532, 549, 621 span 89 minutes which is > 60, so not high-access based on this analysis.

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

Understanding the Visualization

Input Processing

Parse employee access records with timestamps

Pattern Detection

Find employees with 3+ accesses in <60 minutes

Result

List of high-access employees

Key Takeaway

🎯 Key Insight: Sort timestamps per employee, then use sliding window to efficiently detect violations

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

Approach	Time	Space	Notes
✓ Brute Force - Check All Combinations	O(n × m³)	O(n)	Group by employee, then check every possible 3-access combination
Optimized - Sort and Sliding Window	O(n log n)	O(n)	Sort access times per employee, then use sliding window to find violations

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>

#define MAX_EMPLOYEES 1000
#define MAX_ACCESSES 1000
#define MAX_NAME_LEN 50

typedef struct {
    char name[MAX_NAME_LEN];
    int times[MAX_ACCESSES];
    int count;
} Employee;

int timeToMinutes(const char* timeStr) {
    int hours = (timeStr[0] - '0') * 10 + (timeStr[1] - '0');
    int minutes = (timeStr[2] - '0') * 10 + (timeStr[3] - '0');
    return hours * 60 + minutes;
}

int compare(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

char** solution(char*** access_times, int access_times_size, int* returnSize) {
    Employee employees[MAX_EMPLOYEES];
    int employeeCount = 0;
    
    for (int i = 0; i < access_times_size; i++) {
        char* name = access_times[i][0];
        int time = timeToMinutes(access_times[i][1]);
        
        int found = -1;
        for (int j = 0; j < employeeCount; j++) {
            if (strcmp(employees[j].name, name) == 0) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            strcpy(employees[employeeCount].name, name);
            employees[employeeCount].times[0] = time;
            employees[employeeCount].count = 1;
            employeeCount++;
        } else {
            employees[found].times[employees[found].count] = time;
            employees[found].count++;
        }
    }
    
    char** result = (char**)malloc(MAX_EMPLOYEES * sizeof(char*));
    *returnSize = 0;
    
    for (int e = 0; e < employeeCount; e++) {
        if (employees[e].count < 3) continue;
        
        int found = 0;
        for (int i = 0; i < employees[e].count && !found; i++) {
            for (int j = i + 1; j < employees[e].count && !found; j++) {
                for (int k = j + 1; k < employees[e].count; k++) {
                    int timeList[3] = {employees[e].times[i], employees[e].times[j], employees[e].times[k]};
                    qsort(timeList, 3, sizeof(int), compare);
                    if (timeList[2] - timeList[0] < 60) {
                        result[*returnSize] = (char*)malloc(MAX_NAME_LEN * sizeof(char));
                        strcpy(result[*returnSize], employees[e].name);
                        (*returnSize)++;
                        found = 1;
                        break;
                    }
                }
            }
        }
    }
    
    return result;
}

int main() {
    printf("[]");
    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)

✓ Linear Growth

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