Frequency Tracker

Frequency Tracker - Problem

Design a data structure that keeps track of the values in it and answers some queries regarding their frequencies.

Implement the FrequencyTracker class:

FrequencyTracker(): Initializes the FrequencyTracker object with an empty array initially.
void add(int number): Adds number to the data structure.
void deleteOne(int number): Deletes one occurrence of number from the data structure. The data structure may not contain number, and in this case nothing is deleted.
bool hasFrequency(int frequency): Returns true if there is a number in the data structure that occurs frequency number of times, otherwise, it returns false.

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["FrequencyTracker", "add", "add", "hasFrequency"], values = [0, 3, 3, 2]

› Output: [null, null, null, true]

💡 Note: Create tracker, add 3 twice (frequency 2), hasFrequency(2) returns true since 3 appears 2 times

Example 2 — Delete Operations

$ Input: operations = ["FrequencyTracker", "add", "deleteOne", "hasFrequency"], values = [0, 1, 1, 1]

› Output: [null, null, null, false]

💡 Note: Add 1, delete 1, now no numbers exist so hasFrequency(1) returns false

Example 3 — Multiple Numbers

$ Input: operations = ["FrequencyTracker", "add", "add", "add", "hasFrequency", "hasFrequency"], values = [0, 1, 1, 2, 2, 1]

› Output: [null, null, null, null, true, true]

💡 Note: Add 1,1,2. Number 1 has frequency 2, number 2 has frequency 1. Both queries return true

Constraints

1 ≤ number ≤ 10⁵
1 ≤ frequency ≤ 10⁵
At most 2 × 10⁵ calls to add, deleteOne, and hasFrequency

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is to maintain two hash maps: one tracking the count of each number, and another tracking how many numbers have each frequency. This allows all operations to run in O(1) time. Best approach uses dual hash maps with Time: O(1), Space: O(n).

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Greedy

⏱️ Time: N/A Space: N/A

Brute Force - Count Every Query

⏱️ Time: O(n) Space: O(n)

Keep all numbers in a simple array. For hasFrequency queries, scan the entire array to count occurrences of each number and check if any matches the target frequency.

Optimized - Dual Hash Maps

⏱️ Time: O(1) Space: O(n)

Maintain two hash maps - one tracking count of each number, and another tracking how many numbers have each frequency. Update both maps on add/delete operations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_NUM 100000
#define MAX_FREQ 100000

static int count[MAX_NUM * 2 + 1];  // -100000 to 100000
static int freqCount[MAX_FREQ + 1]; // 0 to 100000

void initTracker() {
    memset(count, 0, sizeof(count));
    memset(freqCount, 0, sizeof(freqCount));
}

void add(int number) {
    int idx = number + MAX_NUM;
    int oldFreq = count[idx];
    int newFreq = oldFreq + 1;
    
    if (oldFreq > 0) {
        freqCount[oldFreq]--;
    }
    
    count[idx] = newFreq;
    freqCount[newFreq]++;
}

void deleteOne(int number) {
    int idx = number + MAX_NUM;
    if (count[idx] == 0) {
        return;
    }
    
    int oldFreq = count[idx];
    int newFreq = oldFreq - 1;
    
    freqCount[oldFreq]--;
    
    if (newFreq > 0) {
        count[idx] = newFreq;
        freqCount[newFreq]++;
    } else {
        count[idx] = 0;
    }
}

bool hasFrequency(int frequency) {
    if (frequency < 0 || frequency > MAX_FREQ) return false;
    return freqCount[frequency] > 0;
}

void parseStringArray(const char* str, char operations[][20], int* opCount) {
    *opCount = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == '"') {
            p++;
            int len = 0;
            while (*p && *p != '"') {
                operations[*opCount][len++] = *p++;
            }
            operations[*opCount][len] = '\0';
            (*opCount)++;
            if (*p == '"') p++;
        }
        while (*p && *p != ',' && *p != ']') p++;
        if (*p == ',') p++;
    }
}

void parseIntArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    char operations[1000][20];
    int values[1000];
    int opCount, valCount;
    
    parseStringArray(line1, operations, &opCount);
    parseIntArray(line2, values, &valCount);
    
    printf("[");
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "FrequencyTracker") == 0) {
            initTracker();
            printf("null");
        } else if (strcmp(operations[i], "add") == 0) {
            add(values[i]);
            printf("null");
        } else if (strcmp(operations[i], "deleteOne") == 0) {
            deleteOne(values[i]);
            printf("null");
        } else if (strcmp(operations[i], "hasFrequency") == 0) {
            printf("%s", hasFrequency(values[i]) ? "true" : "false");
        }
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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