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 &lt;= j &lt;= k), answer[j] is the number of users whose UAM equals j.

Return the array answer as described above.

&nbsp;
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.


&nbsp;
Constraints:


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


class Solution:
    def findingUsersActiveMinutes(self, logs: List[List[int]], k: int) -> List[int]:
        ret = [0] * k  # UAM store
        user_acts = {}  # User minutes store
        
        # Adding user minutes to hash table
		for log in logs:
            if user_acts.get(log[0], 0):
                user_acts[log[0]].append(log[1])
            else:
                user_acts[log[0]] = [log[1]]
                
        # Calculating UAM
		for k, v in user_acts.items():
            l = len(set(v))
            ret[l-1] += 1
    
        return ret
class Solution {
    public int[] findingUsersActiveMinutes(int[][] logs, int k) {
        HashMap<Integer, HashSet<Integer>> usersMap = new HashMap();
        
        for(int[] log : logs){
            int user = log[0];
            int min = log[1];
            
            //add current user mapping, if not exist
            usersMap.putIfAbsent(user, new HashSet<Integer>());
            
            //add unique new minute 
            usersMap.get(user).add(min);
        }
        
        
        
        int[] result = new int[k];
        for(int user : usersMap.keySet()){
            int uam = usersMap.get(user).size();
            //increment users count
            result[uam - 1]++;
         }

		return result;
        
    }
    
}
class Solution {
public:
    vector<int> findingUsersActiveMinutes(vector<vector<int>>& logs, int k) 
    {
        vector<int>ans(k,0);
        unordered_map<int,unordered_set<int>>m;

        for(int i = 0; i<logs.size(); i++)
        {
            m[logs[i][0]].insert(logs[i][1]);
        }
        for(auto x : m)
        {
            int t = x.second.size();
            ans[t-1]++;
        }
        return ans;
    }
};
var findingUsersActiveMinutes = function(logs, k) {
    const map = new Map();

    for (const [userID, minute] of logs) {
        if (!map.has(userID)) map.set(userID, new Set());
        map.get(userID).add(minute);
    }

    const count = new Array(k).fill(0);

    for (const actions of map.values()) {
        count[actions.size - 1]++;
    }

    return count;
};
Finding the Users Active Minutes