Finding the Users Active Minutes - Practice Coding Problems

Finding the Users Active Minutes - Problem

You are given the logs for users' actions on LeetCode, and an integer k. The logs are represented by a 2D integer array logs where each logs[i] = [IDi, timei] indicates that the user with IDi performed an action at the minute timei.

Multiple users can perform actions simultaneously, and a single user can perform multiple actions in the same minute.

The user active minutes (UAM) for a given user is defined as the number of unique minutes in which the user performed an action on LeetCode. A minute can only be counted once, even if multiple actions occur during it.

You are to calculate a 1-indexed array answer of size k such that, for each j (1 <= j <= k), answer[j] is the number of users whose UAM equals j.

Return the array answer as described above.

Input & Output

Example 1 — Basic Case

$ Input: logs = [[0,5],[1,2],[0,2],[0,5],[1,3]], k = 5

› Output: [0,2,0,0,0]

💡 Note: User 0 has UAM=2 (minutes 2,5), User 1 has UAM=2 (minutes 2,3). So 0 users have UAM=1, 2 users have UAM=2, and 0 users have UAM=3,4,5.

Example 2 — Single User

$ Input: logs = [[1,1],[1,2],[1,3]], k = 4

› Output: [0,0,1,0]

💡 Note: User 1 has UAM=3 (minutes 1,2,3). So 1 user has UAM=3, others are 0.

Example 3 — Duplicate Minutes

$ Input: logs = [[0,1],[0,1],[1,1]], k = 3

› Output: [2,0,0]

💡 Note: User 0 has UAM=1 (minute 1 counted once), User 1 has UAM=1 (minute 1). So 2 users have UAM=1.

Constraints

1 ≤ logs.length ≤ 10⁴
0 ≤ ID_i ≤ 10⁹
1 ≤ time_i ≤ 10⁵
k is in the range [1, logs.length]

Visualization

Tap to expand

Understanding the Visualization

Input Logs

2D array of [userID, minute] pairs

Group by User

Collect unique minutes for each user

Count UAM

Count how many users have each UAM value

Key Takeaway

🎯 Key Insight: Group logs by user first, count unique minutes, then frequency count by UAM

Asked in

LC LeetCode 15 A Amazon 8

The key insight is to group logs by user ID first, then count unique minutes per user, and finally count users by UAM values. Best approach is Two-Pass Hash Map with Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Map	O(n + u)	O(n + k)	First pass builds user→minutes map, second pass counts UAM frequencies
Brute Force with Nested Loops	O(n × u)	O(u + k)	For each user, scan all logs to find unique minutes, then count users by UAM

Two-Pass Hash Map — Algorithm Steps

First pass: Build hash map of user→unique minutes
Second pass: Count users grouped by UAM values
Return 1-indexed result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Pass 1

Build user→minutes map from logs

Pass 2

Count users by their UAM values

Result

Return frequency array

Code -

solution.c — C

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

int* solution(int** logs, int logsSize, int k, int* returnSize) {
    int maxUserId = 0;
    for (int i = 0; i < logsSize; i++) {
        if (logs[i][0] > maxUserId) maxUserId = logs[i][0];
    }
    
    // First pass: collect unique minutes per user
    int** userMinutes = (int**)calloc(maxUserId + 1, sizeof(int*));
    int* userCounts = (int*)calloc(maxUserId + 1, sizeof(int));
    
    for (int i = 0; i < logsSize; i++) {
        int userId = logs[i][0];
        int minute = logs[i][1];
        
        if (userMinutes[userId] == NULL) {
            userMinutes[userId] = (int*)calloc(1001, sizeof(int));
        }
        
        if (userMinutes[userId][minute] == 0) {
            userMinutes[userId][minute] = 1;
            userCounts[userId]++;
        }
    }
    
    // Second pass: count users by UAM
    int* result = (int*)calloc(k, sizeof(int));
    *returnSize = k;
    
    for (int userId = 0; userId <= maxUserId; userId++) {
        if (userCounts[userId] > 0 && userCounts[userId] <= k) {
            result[userCounts[userId] - 1]++;
        }
    }
    
    // Cleanup
    for (int i = 0; i <= maxUserId; i++) {
        if (userMinutes[i]) free(userMinutes[i]);
    }
    free(userMinutes);
    free(userCounts);
    
    return result;
}

int main() {
    // Simplified input parsing for demo
    int logs[5][2] = {{0,5},{1,2},{0,2},{0,5},{1,3}};
    int* logsPtr[5];
    for (int i = 0; i < 5; i++) {
        logsPtr[i] = logs[i];
    }
    
    int k = 5;
    int returnSize;
    int* result = solution(logsPtr, 5, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + u)

n logs processed once + u users counted once

✓ Linear Growth

Space Complexity

O(n + k)

Hash map stores up to n user-minute pairs + result array size k

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~15 min Avg. Time

450 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-Pass Hash Map — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler