High-Access Employees - Practice Coding Problems

High-Access Employees - Problem

Imagine you're a security officer monitoring employee badge access to a restricted facility. Your job is to identify employees who might be exhibiting suspicious behavior by accessing the system too frequently within short time periods.

You are given a 2D array access_times containing employee access records for a single day. Each record contains:

access_times[i][0] - Employee name (string)
access_times[i][1] - Access time in 24-hour format (string like "0815" or "1430")

An employee is considered "high-access" if they accessed the system three or more times within any one-hour period.

Important Rules:

Times exactly one hour apart are NOT in the same period (e.g., "0815" and "0915")
Cross-day periods don't count (e.g., "2350" and "0010" are separate)
You need to find any one-hour window with 3+ accesses

Goal: Return a list of all high-access employee names in any order.

Input & Output

example_1.py — Basic High Access

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

› Output: ["a"]

💡 Note: Employee 'a' has access times [0549, 0532, 0621]. After sorting: [0532, 0549, 0621]. The window [0532, 0549, 0621] spans 89 minutes, but we can find a valid window [0532, 0549] within 17 minutes. However, checking more carefully: from 0532 to 0549 is 17 minutes (valid), but we need 3 accesses in one window. Actually, let me recalculate: 0621-0532=89 minutes > 60, so we need to check smaller windows. The key insight is that times 0532, 0549 are within 60 minutes, and if there was a third access between 0532-0632, employee 'a' would be high-access.

example_2.py — Multiple Employees

$ 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': times [0808, 0829, 0809] → sorted [0808, 0809, 0829]. Window from 0808 to 0829 is 21 minutes with 3 accesses → HIGH ACCESS. Employee 'd': times [0002, 1508, 1444, 1410] → sorted [0002, 1410, 1444, 1508]. Window from 1410 to 1508 is 58 minutes with 3 accesses → HIGH ACCESS.

example_3.py — No High Access

$ Input: access_times = [["alice","0800"],["alice","0900"],["alice","1000"],["bob","0830"]]

› Output: []

💡 Note: Alice has times [0800, 0900, 1000]. Each consecutive pair is exactly 60 minutes apart (0900-0800=100, 1000-0900=100), but we need times to be LESS than 60 minutes apart to be in the same window. Bob has only 1 access. No employee qualifies as high-access.

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 "HHMM"
All access times are within the same day

Visualization

Tap to expand

Understanding the Visualization

Collect Access Data

Security system logs every badge scan with employee name and timestamp

Group by Employee

Sort all access records into employee-specific files

Time-Based Analysis

For each employee, sort their access times chronologically

Sliding Window Check

Use a one-hour sliding window to detect 3+ accesses in any period

Flag Suspicious Activity

Employees with high-frequency access patterns are flagged for review

Key Takeaway

🎯 Key Insight: Group access times by employee, sort chronologically, then use a sliding window to efficiently detect any one-hour period with 3+ accesses - like a smart security system automatically flagging suspicious access patterns!

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 25

The optimal approach uses a hash map to group access times by employee, then applies a sliding window technique on sorted times. Key insight: sort each employee's times and use two pointers to maintain valid one-hour windows, checking if any window contains 3+ accesses. Time complexity: O(n log k) where n is total records and k is average times per employee.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Sorted Times	O(n log k)	O(n)	Sort each employee's times, use two pointers to maintain sliding window
Brute Force (Check Every Time Window)	O(n²)	O(n)	For each employee, check every possible one-hour window to count accesses
Hash Map + Sliding Window	O(n log k)	O(n)	Group by employee, sort times, then use sliding window to find 3+ accesses

Two Pointers with Sorted Times — Algorithm Steps

Group access times by employee using hash map
For each employee, sort their access times
Initialize left and right pointers at start of sorted array
Move right pointer forward, expand window
When window exceeds 60 minutes, move left pointer forward
If window ever contains 3+ elements, employee is high-access

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Both left and right start at beginning of sorted times

Expand Right

Move right pointer to include more access times

Shrink Left

When window > 60 minutes, move left pointer forward

Check Window

If window has 3+ times, mark as high-access

Code -

solution.c — C

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

#define MAX_EMPLOYEES 1000
#define MAX_TIMES 100
#define MAX_NAME_LEN 20

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

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

char** findHighAccessEmployees(char*** access_times, int access_times_size, int* access_times_col_size, int* returnSize) {
    Employee employees[MAX_EMPLOYEES];
    int emp_count = 0;
    
    // Group access times by employee
    for (int i = 0; i < access_times_size; i++) {
        char* name = access_times[i][0];
        int time = atoi(access_times[i][1]);
        
        // Find or create employee
        int emp_idx = -1;
        for (int j = 0; j < emp_count; j++) {
            if (strcmp(employees[j].name, name) == 0) {
                emp_idx = j;
                break;
            }
        }
        
        if (emp_idx == -1) {
            emp_idx = emp_count++;
            strcpy(employees[emp_idx].name, name);
            employees[emp_idx].count = 0;
        }
        
        employees[emp_idx].times[employees[emp_idx].count++] = time;
    }
    
    char** result = (char**)malloc(MAX_EMPLOYEES * sizeof(char*));
    int result_count = 0;
    
    for (int emp = 0; emp < emp_count; emp++) {
        qsort(employees[emp].times, employees[emp].count, sizeof(int), compare_ints);
        
        int left = 0;  // Left pointer
        
        for (int right = 0; right < employees[emp].count; right++) {  // Right pointer
            // Shrink window from left while it's too large
            while (employees[emp].times[right] - employees[emp].times[left] >= 60) {
                left++;
            }
            
            // Check current window size
            int window_size = right - left + 1;
            if (window_size >= 3) {
                result[result_count] = (char*)malloc(MAX_NAME_LEN * sizeof(char));
                strcpy(result[result_count], employees[emp].name);
                result_count++;
                break;
            }
        }
    }
    
    *returnSize = result_count;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

n total records, sorting k times per employee dominates

⚡ Linearithmic

Space Complexity

O(n)

Hash map storage for grouping by employee

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~18 min Avg. Time

890 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

Two Pointers with Sorted Times — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler