Skip to main content
Talentd

Finding the Users Active Minutes - Solution & Explanation

MediumArrayHash Table14 min readAsked at: Amazon, Twitter
Practice this problem

Problem Statement

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.

 

Example 1:

Input: logs = [[0,5],[1,2],[0,2],[0,5],[1,3]], k = 5
Output: [0,2,0,0,0]
Explanation:
The user with ID=0 performed actions at minutes 5, 2, and 5 again. Hence, they have a UAM of 2 (minute 5 is only counted once).
The user with ID=1 performed actions at minutes 2 and 3. Hence, they have a UAM of 2.
Since both users have a UAM of 2, answer[2] is 2, and the remaining answer[j] values are 0.

Example 2:

Input: logs = [[1,1],[2,2],[2,3]], k = 4
Output: [1,1,0,0]
Explanation:
The user with ID=1 performed a single action at minute 1. Hence, they have a UAM of 1.
The user with ID=2 performed actions at minutes 2 and 3. Hence, they have a UAM of 2.
There is one user with a UAM of 1 and one with a UAM of 2.
Hence, answer[1] = 1, answer[2] = 1, and the remaining values are 0.

 

Constraints:

  • 1 <= logs.length <= 104
  • 0 <= IDi <= 109
  • 1 <= timei <= 105
  • k is in the range [The maximum UAM for a user, 105].

Approach Overview

Problem Overview: You receive a list of logs where each entry contains a userId and a minute. A user's active minutes are the number of unique minutes they appear in the logs. The task is to compute how many users have exactly 1..k unique active minutes and return the frequency array.

Approach 1: HashMap to Track Unique Minutes (Time: O(n), Space: O(n))

Use a hash map where the key is userId and the value is a set of minutes the user was active. Iterate through the logs and insert each minute into the corresponding user's set. Because sets automatically remove duplicates, repeated log entries for the same minute are ignored. After processing all logs, iterate through the map and compute each user's unique minute count. Maintain a result array of size k where index i tracks how many users have i + 1 active minutes. This approach relies heavily on fast hash lookups and is a classic pattern when solving counting problems with hash tables and arrays.

Approach 2: Two-Pass Calculation (Time: O(n), Space: O(n))

The same core idea can be structured as two clear passes over the data. In the first pass, build a mapping from userId to a set of unique minutes using a hash map. In the second pass, iterate over each user's set, compute the set size, and increment the corresponding index in the result array if the size is ≤ k. Separating the logic into two phases makes the code easier to reason about and debug during interviews. The algorithm still performs constant-time hash insertions and set operations, making it efficient for large log inputs. This technique frequently appears in problems involving hash table aggregation or deduplication tasks.

Recommended for interviews: The hash map + set approach is the expected solution. Interviewers want to see that you recognize duplicate minutes must be filtered using a set and that you can convert those counts into a frequency distribution of size k. Explaining the logic clearly and handling edge cases such as duplicate logs demonstrates solid command of hash-based counting patterns.

Approach 1: Approach 1: HashMap to Track Unique Minutes

This approach utilizes a HashMap to keep track of each user's unique active minutes.

Steps:

  • Create a HashMap where the key is the user ID and the value is a set of unique active minutes.
  • Iterate through the logs and populate the map for each user ID with unique minutes.
  • Create an array of size k to store the number of users with a specific count of unique active minutes.
  • Iterate through the map and update the array based on each user's number of unique minutes.
  • Return the array.

This Python solution uses a defaultdict of sets to track unique minutes for each user.

It iterates over the logs and populates the set with unique minutes for each user. Then it fills the result array based on the unique minute counts.

Code

PythonC++JavaC#JavaScript

Python

C++

Java

C#

JavaScript

Complexity

Time Complexity: O(n), where n is the number of elements in logs. Each log entry is processed once.

Space Complexity: O(m), where m is the number of distinct user ID and minute pairs.

Try this approach in the editor →

Approach 2: Approach 2: Two-Pass Calculation

This approach performs two separate passes over the logs data.

Steps:

  • First, collect all the unique times for each user using a map and set combination.
  • In the second pass, you iterate the collection of user-minute sets to count occurrences of each UAM value, updating the results array.
  • Using two passes decouples unique minute calculation and result aggregation.

In this two-pass Python solution, the set collects unique minute logs in the first pass, and the result tally is compiled in a separate pass.

Code

PythonC++JavaC#JavaScript

Python

C++

Java

C#

JavaScript

Complexity

Time Complexity: O(n), where n is the number of log entries.

Space Complexity: O(m), accommodating unique user-minute entries.

Try this approach in the editor →

Approach 3: Hash Table

We use a hash table d to record all the unique operation times of each user, and then traverse the hash table to count the number of active minutes for each user. Finally, we count the distribution of the number of active minutes for each user.

The time complexity is O(n), and the space complexity is O(n), where n is the length of the logs array.

Code

PythonJavaC++GoTypeScript

Python

Java

C++

Go

TypeScript

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Approach 1: HashMap to Track Unique Minutes

Time Complexity: O(n), where n is the number of elements in logs. Each log entry is processed once.

Space Complexity: O(m), where m is the number of distinct user ID and minute pairs.

Approach 2: Two-Pass Calculation

Time Complexity: O(n), where n is the number of log entries.

Space Complexity: O(m), accommodating unique user-minute entries.

Hash Table—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
HashMap to Track Unique MinutesO(n)O(n)General case. Efficient when logs may contain duplicate minutes per user.
Two-Pass CalculationO(n)O(n)Cleaner separation of aggregation and counting logic, easier to reason about in interviews.

Video Solution

LeetCode 1817. Finding the Users Active Minutes | Medium | 🏆 Weekly Contest 235 |Algorithm Explained • Cherry Coding [IIT-G] • 2,332 views views

Watch 9 more video solutions →

Frequently Asked Questions

Is Finding the Users Active Minutes easy or hard?
The problem is rated Medium but conceptually straightforward once you recognize the need for deduplication. The main challenge is realizing that duplicate log entries must be ignored, which naturally leads to using a set for each user.
Finding the Users Active Minutes Python/Java solution
Python solutions typically use defaultdict(set) to track minutes per user, while Java implementations use HashMap<Integer, HashSet<Integer>>. Both follow the same idea: collect unique minutes for each user and then compute the distribution for values from 1 to k.
How to solve Finding the Users Active Minutes in O(n)?
Process each log once and store minutes in a set for each user using a hash map. After building this structure, compute the size of each user's set and update the frequency array for values from 1 to k. Hash lookups and set insertions keep the algorithm linear in the number of logs.
What is the best approach for Finding the Users Active Minutes?
The optimal approach uses a hash map where each user ID maps to a set of unique minutes. Iterate through the logs and insert the minute into the user's set, then count the size of each set to build the result array. This method runs in O(n) time and O(n) space and efficiently removes duplicate minutes.
Is Finding the Users Active Minutes asked at Google/Amazon/Meta?
Problems involving log aggregation, counting unique events, and hash map frequency tracking appear frequently in interviews at companies like Amazon, Google, and Meta. This problem tests practical skills such as deduplication using sets and frequency counting.
What data structure is used in Finding the Users Active Minutes?
The main data structures are a hash map and a set. The hash map stores each user ID, while the set keeps track of unique minutes for that user. An array of length k is then used to count how many users fall into each active-minute category.
What is the time complexity of Finding the Users Active Minutes?
The optimal solution runs in O(n) time where n is the number of log entries. Each log is processed once with constant-time hash map and set operations. Space complexity is O(n) because each unique (user, minute) pair may be stored in the hash map sets.

Ready to solve this problem?

Practice Finding the Users Active Minutes with our built-in code editor and test cases.

Practice on FleetCode
Previous

Two Sum

Next

Median of Two Sorted Arrays