Finding the Users Active Minutes - Practice Coding Problems

Finding the Users Active Minutes - Problem

Imagine you're a data analyst at a coding platform tracking user engagement patterns. You have access to user activity logs and need to understand how many users are active for specific durations.

Given a 2D integer array logs where each logs[i] = [IDi, timei] represents that user IDi performed an action at minute timei, and an integer k, your task is to analyze user engagement patterns.

Key Points:

Multiple users can be active simultaneously
A user can perform multiple actions in the same minute (but it counts as 1 active minute)
User Active Minutes (UAM) = number of unique minutes a user was active

Return a 1-indexed array of size k where answer[j] represents the number of users whose UAM equals j.

Example: If 3 users were active for exactly 2 minutes each, then answer[2] = 3.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: User 1: active at minutes 1 and 3 → UAM = 2. User 2: active at minute 2 → UAM = 1. User 3: active at minute 1 → UAM = 1. So we have 2 users with UAM=1, 1 user with UAM=2, and 0 users with UAM=3 or UAM=4.

example_2.py — Duplicate Activities

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

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

💡 Note: User 0: active at minutes 2 and 5 (minute 5 counted once) → UAM = 2. User 1: active at minutes 2 and 3 → UAM = 2. Both users have UAM=2, so answer[1] = 2.

example_3.py — Single User Multiple Times

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

› Output: [1]

💡 Note: User 1 performs multiple actions at minute 1, but it only counts as 1 unique active minute. So UAM = 1, and answer[0] = 1.

Constraints

1 ≤ logs.length ≤ 10⁴
0 ≤ ID_i ≤ 10⁹
1 ≤ time_i ≤ 10⁵
1 ≤ k ≤ 1000
logs[i].length == 2

Visualization

Tap to expand

Understanding the Visualization

Record Visits

Track each customer's unique visit hours using a hash map

Count Patterns

Group customers by their total unique visit hours

Generate Report

Create frequency report showing engagement distribution

Key Takeaway

🎯 Key Insight: Hash tables efficiently deduplicate activities per user and enable fast frequency counting for engagement analysis

Asked in

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

The optimal solution uses a hash table to track unique active minutes for each user in O(n) time. We build a map from user ID to a set of unique minutes, then count how many users have each possible UAM value. This approach efficiently handles duplicate activities and scales well with input size.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(n)	First pass builds user activity map, second pass counts UAM frequencies
One-Pass Hash Table (Optimal)	O(n)	O(n)	Build user activity map and count frequencies simultaneously in a single pass
Brute Force (Nested Loops)	O(k × n²)	O(n)	For each possible UAM value, scan all logs to count users

Two-Pass Hash Table — Algorithm Steps

Create a hash map to store user ID -> set of unique minutes
First pass: iterate through logs and populate the hash map
For each log entry, add the minute to the user's set
Second pass: count UAM frequencies
For each user in hash map, get their UAM count
Increment the corresponding index in result array
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Map

First pass: create user -> unique minutes mapping

Count Frequencies

Second pass: count how many users have each UAM value

Code -

solution.c — C

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

#define MAX_USERS 100001
#define MAX_MINUTES 100001

int* findingUsersActiveMinutes(int** logs, int logsSize, int* logsColSize, int k, int* returnSize) {
    int* result = (int*)calloc(k, sizeof(int));
    *returnSize = k;
    
    // Use 2D array to simulate hash map
    bool userMinutes[MAX_USERS][MAX_MINUTES] = {false};
    bool hasUser[MAX_USERS] = {false};
    
    // First pass: build user activity map
    for (int i = 0; i < logsSize; i++) {
        int userId = logs[i][0];
        int minute = logs[i][1];
        userMinutes[userId][minute] = true;
        hasUser[userId] = true;
    }
    
    // Second pass: count UAM frequencies
    for (int userId = 0; userId < MAX_USERS; userId++) {
        if (!hasUser[userId]) continue;
        
        int uam = 0;
        for (int minute = 0; minute < MAX_MINUTES; minute++) {
            if (userMinutes[userId][minute]) {
                uam++;
            }
        }
        
        if (uam >= 1 && uam <= k) {
            result[uam - 1]++;
        }
    }
    
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

First pass O(n) to build hash map, second pass O(unique users) to count frequencies

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n entries for user-minute pairs

⚡ Linearithmic Space

34.8K Views

Medium Frequency

~15 min Avg. Time

1.2K 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 Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler