Finding the Users Active Minutes solution and explanation
9 more videos on this problem
LeetCode 1817. Finding the Users Active Minutes | Medium | 🏆 Weekly Contest 235 |Algorithm ExplainedCherry Coding [IIT-G] · 7:19 · 2K views
LeetCode 1817 Finding the Users Active Minutes - Java Solution Using HashMapAlgorithmicIQ · 9:26 · 772 views
1817. Finding the Users Active Minutes (Leetcode Medium)Programming Live with Larry · 4:36 · 684 views
LeetCode 1817 : Java Solution | Finding the Users Active MinutesAmit Manjarly · 14:10 · 322 views
LeetCode 1817 | Finding the Users Active Minutes | HashMap | JavaSleepy Cracker · 4:45 · 187 views
LeetCode 1817 : C++ Solution | Finding the Users Active MinutesAmit Manjarly · 9:34 · 145 views
LeetCode 1817: Users Active Minutes | Solution Explained |ELMS - NG · 6:05 · 37 views
l-13 1817 finding user active minutesDD Does · 8:29 · 20 views
Leetcode 1817 JavaBenjamin Rudin · 10:07 · 13 views
LeetCode 1817: Finding the Users Active MinutesAlitaCode · 30:07 · 4 views
The 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.
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 <= 1040 <= IDi <= 1091 <= timei <= 105kis 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
kto 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.
def finding_users_active_minutes(logs, k):
from collections import defaultdict
user_minutes = defaultdict(set)
for user_id, time in logs:
user_minutes[user_id].add(time)
result = [0] * k
for uam in user_minutes.values():
result[len(uam) - 1] += 1
return resultimport java.util.*;
public class Solution {
public int[] findingUsersActiveMinutes(int[][] logs, int k) {
Map<Integer, Set<Integer>> userMinutes = new HashMap<>();
for (int[] log : logs) {
userMinutes.computeIfAbsent(log[0], x -> new HashSet<>()).add(log[1]);
}
int[] result = new int[k];
for (Set<Integer> minutes : userMinutes.values()) {
result[minutes.size() - 1]++;
}
return result;
}
}#include <vector>
#include <unordered_map>
#include <unordered_set>
using namespace std;
vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) {
unordered_map<int, unordered_set<int>> userMinutes;
for (const auto& log : logs) {
userMinutes[log[0]].insert(log[1]);
}
vector<int> result(k, 0);
for (const auto& entry : userMinutes) {
result[entry.second.size() - 1]++;
}
return result;
}function findingUsersActiveMinutes(logs, k) {
const userMinutes = new Map();
for (const [userId, time] of logs) {
if (!userMinutes.has(userId)) {
userMinutes.set(userId, new Set());
}
userMinutes.get(userId).add(time);
}
const result = new Array(k).fill(0);
for (const minutes of userMinutes.values()) {
result[minutes.size - 1]++;
}
return result;
}using System;
using System.Collections.Generic;
public class Solution {
public int[] FindingUsersActiveMinutes(int[][] logs, int k) {
var userMinutes = new Dictionary<int, HashSet<int>>();
foreach (var log in logs) {
if (!userMinutes.ContainsKey(log[0])) {
userMinutes[log[0]] = new HashSet<int>();
}
userMinutes[log[0]].Add(log[1]);
}
var result = new int[k];
foreach (var minutes in userMinutes.Values) {
result[minutes.Count - 1]++;
}
return result;
}
}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.
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: 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.
def finding_users_active_minutes(logs, k):
from collections import defaultdict
user_minutes = defaultdict(set)
for log in logs:
user_minutes[log[0]].add(log[1])
result = [0] * k
for minutes in user_minutes.values():
result[len(minutes) - 1] += 1
return resultimport java.util.*;
public class Solution {
public int[] findingUsersActiveMinutes(int[][] logs, int k) {
Map<Integer, Set<Integer>> userMinutes = new HashMap<>();
for (int[] log : logs) {
userMinutes.computeIfAbsent(log[0], x -> new HashSet<>()).add(log[1]);
}
int[] result = new int[k];
for (Set<Integer> minutes : userMinutes.values()) {
result[minutes.size() - 1]++;
}
return result;
}
}#include <vector>
#include <unordered_map>
#include <unordered_set>
using namespace std;
vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) {
unordered_map<int, unordered_set<int>> userMinutes;
for (const auto& log : logs) {
userMinutes[log[0]].insert(log[1]);
}
vector<int> result(k, 0);
for (const auto& um : userMinutes) {
result[um.second.size() - 1]++;
}
return result;
}function findingUsersActiveMinutes(logs, k) {
const userMinutes = new Map();
for (const [userId, time] of logs) {
if (!userMinutes.has(userId)) {
userMinutes.set(userId, new Set());
}
userMinutes.get(userId).add(time);
}
const result = new Array(k).fill(0);
for (const minutes of userMinutes.values()) {
result[minutes.size - 1]++;
}
return result;
}using System;
using System.Collections.Generic;
public class Solution {
public int[] FindingUsersActiveMinutes(int[][] logs, int k) {
var userMinutes = new Dictionary<int, HashSet<int>>();
foreach (var log in logs) {
if (!userMinutes.ContainsKey(log[0])) {
userMinutes[log[0]] = new HashSet<int>();
}
userMinutes[log[0]].Add(log[1]);
}
var result = new int[k];
foreach (var minutes in userMinutes.Values) {
result[minutes.Count - 1]++;
}
return result;
}
}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.
Time Complexity: O(n), where n is the number of log entries.
Space Complexity: O(m), accommodating unique user-minute entries.
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.
function findingUsersActiveMinutes(logs: number[][], k: number): number[] {
const d: Map<number, Set<number>> = new Map();
for (const [i, t] of logs) {
if (!d.has(i)) {
d.set(i, new Set<number>());
}
d.get(i)!.add(t);
}
const ans: number[] = Array(k).fill(0);
for (const [_, ts] of d) {
++ans[ts.size - 1];
}
return ans;
}func findingUsersActiveMinutes(logs [][]int, k int) []int {
d := map[int]map[int]bool{}
for _, log := range logs {
i, t := log[0], log[1]
if _, ok := d[i]; !ok {
d[i] = make(map[int]bool)
}
d[i][t] = true
}
ans := make([]int, k)
for _, ts := range d {
ans[len(ts)-1]++
}
return ans
}Complexity comparison
| Approach | Complexity |
|---|---|
| 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 | – |
Complexity analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| HashMap to Track Unique Minutes | O(n) | O(n) | General case. Efficient when logs may contain duplicate minutes per user. |
| Two-Pass Calculation | O(n) | O(n) | Cleaner separation of aggregation and counting logic, easier to reason about in interviews. |
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.