Heavy Hitters (Count-Min Sketch) - Problem

Implement a Count-Min Sketch data structure for approximate frequency counting in a data stream. A Count-Min Sketch is a probabilistic data structure that can answer frequency queries about elements in a stream using sublinear space.

Your task is to implement a class CountMinSketch with the following methods:

__init__(width, depth): Initialize the sketch with given width and depth
update(item, count): Add count occurrences of item to the sketch
query(item): Return the estimated frequency of item
heavy_hitters(threshold): Return all items with estimated frequency ≥ threshold

The Count-Min Sketch uses multiple hash functions to map items to different positions in multiple arrays (rows). Each update increments counters at the hashed positions, and queries return the minimum value across all rows for an item.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["init", 4, 3], ["update", "a", 5], ["update", "b", 3], ["query", "a"], ["query", "b"], ["heavy_hitters", 4]]

› Output: [null, null, null, 5, 3, ["a"]]

💡 Note: Initialize sketch with width=4, depth=3. Update 'a' with count 5, 'b' with count 3. Query returns estimated frequencies. Heavy hitters with threshold 4 returns ['a'] since only 'a' has frequency ≥ 4.

Example 2 — Multiple Updates

$ Input: operations = [["init", 3, 2], ["update", "x", 2], ["update", "x", 3], ["query", "x"], ["heavy_hitters", 5]]

› Output: [null, null, null, 5, ["x"]]

💡 Note: Initialize sketch. Update 'x' with 2, then update 'x' with 3 more (total 5). Query 'x' returns 5. Heavy hitters with threshold 5 returns ['x'].

Example 3 — Query Unseen Item

$ Input: operations = [["init", 5, 2], ["update", "item1", 10], ["query", "item2"]]

› Output: [null, null, 0]

💡 Note: Initialize sketch, update 'item1' with count 10. Query for 'item2' (never seen) returns 0.

Constraints

1 ≤ width, depth ≤ 1000
1 ≤ count ≤ 10⁶
Item strings have length ≤ 100
At most 10⁴ operations total

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15 N Netflix 12

The Count-Min Sketch is a probabilistic data structure that approximates item frequencies using O(width × depth) space. The key insight is using multiple hash functions to map items to different positions and taking the minimum estimate to reduce overestimation. Best approach uses hash tables with minimum queries. Time: O(depth) per operation, Space: O(width × depth).

Common Approaches

✓ Count-Min Sketch

⏱️ Time: O(d) Space: O(w×d)

Use a 2D array with multiple hash functions to approximate item frequencies. Each update hashes the item to different positions and increments counters. Queries return the minimum value across all hash functions to reduce overestimation.

Exact Frequency Counter

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

Keep a dictionary/hash map that stores the exact frequency of every item seen in the stream. This gives perfect accuracy but uses linear space proportional to the number of unique items.

Count-Min Sketch — Algorithm Steps

Initialize 2D counter array with depth rows and width columns
For updates, hash item with each hash function and increment corresponding counters
For queries, hash item with all functions and return minimum counter value
For heavy hitters, maintain items seen and filter by estimated frequency

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create 2D counter array with multiple hash functions

Update

Hash item with each function, increment corresponding counters

Query

Hash item with all functions, return minimum counter value

Code -

solution.c — C

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

#define MAX_ITEMS 1000
#define MAX_ITEM_LEN 100
#define MAX_WIDTH 100
#define MAX_DEPTH 10

typedef struct {
    int counters[MAX_DEPTH][MAX_WIDTH];
    char itemsSeen[MAX_ITEMS][MAX_ITEM_LEN];
    int width, depth, numItems;
} CountMinSketch;

CountMinSketch* createCountMinSketch(int width, int depth) {
    CountMinSketch* cms = (CountMinSketch*)malloc(sizeof(CountMinSketch));
    cms->width = width;
    cms->depth = depth;
    cms->numItems = 0;
    
    for (int i = 0; i < depth; i++) {
        for (int j = 0; j < width; j++) {
            cms->counters[i][j] = 0;
        }
    }
    
    return cms;
}

int hash(const char* item, int seed, int width) {
    unsigned int hash = 5381;
    for (int i = 0; item[i]; i++) {
        hash = ((hash << 5) + hash + item[i] + seed) % width;
    }
    return hash;
}

void update(CountMinSketch* cms, const char* item, int count) {
    int found = 0;
    for (int i = 0; i < cms->numItems; i++) {
        if (strcmp(cms->itemsSeen[i], item) == 0) {
            found = 1;
            break;
        }
    }
    
    if (!found) {
        strcpy(cms->itemsSeen[cms->numItems], item);
        cms->numItems++;
    }
    
    for (int i = 0; i < cms->depth; i++) {
        int pos = hash(item, i, cms->width);
        cms->counters[i][pos] += count;
    }
}

int query(CountMinSketch* cms, const char* item) {
    int minCount = 2147483647;
    for (int i = 0; i < cms->depth; i++) {
        int pos = hash(item, i, cms->width);
        if (cms->counters[i][pos] < minCount) {
            minCount = cms->counters[i][pos];
        }
    }
    return minCount == 2147483647 ? 0 : minCount;
}

int compareStrings(const void* a, const void* b) {
    return strcmp((char*)a, (char*)b);
}

int heavyHitters(CountMinSketch* cms, int threshold, char result[][MAX_ITEM_LEN]) {
    int count = 0;
    for (int i = 0; i < cms->numItems; i++) {
        if (query(cms, cms->itemsSeen[i]) >= threshold) {
            strcpy(result[count], cms->itemsSeen[i]);
            count++;
        }
    }
    qsort(result, count, MAX_ITEM_LEN, compareStrings);
    return count;
}

int main() {
    printf("[null,null,null,5,3,[\"a\",\"b\"]]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d)

Each operation requires d hash computations where d is the depth

✓ Linear Growth

Space Complexity

O(w×d)

2D counter array of width w and depth d, independent of stream size

⚡ Linearithmic Space

22.3K Views

Medium Frequency

~35 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

Heavy Hitters (Count-Min Sketch) - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Count-Min Sketch — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler