Most Frequent IDs - Practice Coding Problems

Most Frequent IDs - Problem

Imagine you're building a real-time analytics system that tracks the popularity of different content IDs on a social media platform. As users interact with content throughout the day, IDs get added to or removed from your tracking system, and you need to continuously monitor which content is currently most popular.

You're given two arrays of equal length n:

nums: An array where each element represents a content ID
freq: An array where each element indicates how many times the corresponding ID should be added (positive values) or removed (negative values) from your tracking system

At each step i, you update your collection based on nums[i] and freq[i], then need to report the count of the most frequent ID currently in your system.

Example: If nums = [2, 3, 2, 1] and freq = [3, 2, -2, 1]:

Step 0: Add 3 copies of ID 2 → Collection: {2: 3} → Most frequent count: 3
Step 1: Add 2 copies of ID 3 → Collection: {2: 3, 3: 2} → Most frequent count: 3
Step 2: Remove 2 copies of ID 2 → Collection: {2: 1, 3: 2} → Most frequent count: 2
Step 3: Add 1 copy of ID 1 → Collection: {2: 1, 3: 2, 1: 1} → Most frequent count: 2

Return an array where each element represents the count of the most frequent ID after each step. If the collection becomes empty at any point, return 0 for that step.

Input & Output

example_1.py — Basic Operations

$ Input: nums = [2, 3, 2, 1], freq = [3, 2, -2, 1]

› Output: [3, 3, 2, 2]

💡 Note: Step 0: Add 3×ID(2) → {2:3} → max=3. Step 1: Add 2×ID(3) → {2:3,3:2} → max=3. Step 2: Remove 2×ID(2) → {2:1,3:2} → max=2. Step 3: Add 1×ID(1) → {2:1,3:2,1:1} → max=2.

example_2.py — Complete Removal

$ Input: nums = [5, 5, 3], freq = [1, -1, 1]

› Output: [1, 0, 1]

💡 Note: Step 0: Add 1×ID(5) → {5:1} → max=1. Step 1: Remove 1×ID(5) → {} → max=0. Step 2: Add 1×ID(3) → {3:1} → max=1.

example_3.py — Large Frequencies

$ Input: nums = [1, 1, 1], freq = [100, 50, -25]

› Output: [100, 150, 125]

💡 Note: Step 0: Add 100×ID(1) → {1:100} → max=100. Step 1: Add 50×ID(1) → {1:150} → max=150. Step 2: Remove 25×ID(1) → {1:125} → max=125.

Constraints

1 ≤ nums.length == freq.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
-10⁵ ≤ freq[i] ≤ 10⁵
freq[i] ≠ 0
The number of any ID will not become negative at any point

Visualization

Tap to expand

Understanding the Visualization

Content Gets Engagement

When content receives likes/shares, we add it to our trending tracker

Content Loses Popularity

When content becomes less relevant, we reduce its engagement count

Track Top Engagement

We always need to know the highest engagement count among all trending content

Efficient Updates

Use hash map + heap for fast updates and maximum tracking

Key Takeaway

🎯 Key Insight: Combine hash map's O(1) updates with heap's efficient maximum tracking, using lazy deletion to handle stale heap entries elegantly.

Asked in

G Google 42 f Meta 38 a Amazon 31 ⊞ Microsoft 28 Apple 19

The optimal solution uses a hash map for O(1) frequency updates combined with a max heap to efficiently track the maximum frequency. The key insight is using lazy deletion to handle outdated heap entries, achieving O(n log n) time complexity for real-time frequency tracking.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Scan All Frequencies)	O(n²)	O(n)	After each update, scan through all frequencies to find the maximum
Hash Map + Max Heap (Optimal)	O(n log n)	O(n)	Use frequency map with max heap for efficient maximum tracking

Brute Force (Scan All Frequencies) — Algorithm Steps

Initialize a frequency map to track ID counts
For each step, update the frequency of the corresponding ID
After each update, iterate through all frequencies to find the maximum
Store the maximum frequency in the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Update Frequency

Add/remove IDs from frequency map

Scan All Frequencies

Iterate through all entries to find maximum

Record Maximum

Store the maximum frequency found

Code -

solution.c — C

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

#define MAX_IDS 1000

typedef struct {
    int id;
    int freq;
} FreqEntry;

int* mostFrequentIDs(int* nums, int* freq, int n, int* returnSize) {
    FreqEntry frequency[MAX_IDS];
    int freqCount = 0;
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    
    for (int i = 0; i < n; i++) {
        // Find or create entry for nums[i]
        int found = -1;
        for (int j = 0; j < freqCount; j++) {
            if (frequency[j].id == nums[i]) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            frequency[freqCount].id = nums[i];
            frequency[freqCount].freq = freq[i];
            freqCount++;
        } else {
            frequency[found].freq += freq[i];
            if (frequency[found].freq <= 0) {
                // Remove entry
                for (int k = found; k < freqCount - 1; k++) {
                    frequency[k] = frequency[k + 1];
                }
                freqCount--;
            }
        }
        
        // Find maximum frequency
        int maxFreq = 0;
        for (int j = 0; j < freqCount; j++) {
            if (frequency[j].freq > maxFreq) {
                maxFreq = frequency[j].freq;
            }
        }
        
        result[i] = maxFreq;
    }
    
    return result;
}

int main() {
    int nums[] = {2, 3, 2, 1};
    int freq[] = {3, 2, -2, 1};
    int returnSize;
    int* result = mostFrequentIDs(nums, freq, 4, &returnSize);
    
    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²)

For each of n steps, we scan all unique IDs in the map (potentially O(n) unique IDs)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for the frequency map and result array

⚡ Linearithmic Space

52.3K Views

High Frequency

~25 min Avg. Time

1.8K 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

Brute Force (Scan All Frequencies) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler