Design Hit Counter

Design Hit Counter - Problem

Array Binary Search Design Queue Data Stream Medium

Design a hit counter which counts the number of hits received in the past 5 minutes (i.e., the past 300 seconds).

Your system should accept a timestamp parameter (in seconds granularity), and you may assume that calls are being made to the system in chronological order (i.e., timestamp is monotonically increasing). Several hits may arrive roughly at the same time.

Implement the HitCounter class:

HitCounter() Initializes the object of the hit counter system.
void hit(int timestamp) Records a hit that happened at timestamp (in seconds). Several hits may happen at the same timestamp.
int getHits(int timestamp) Returns the number of hits in the past 5 minutes from timestamp (i.e., the past 300 seconds).

Input & Output

Example 1 — Basic Hit Counter Usage

$ Input: operations = ["HitCounter", "hit", "hit", "hit", "getHits", "hit", "getHits", "getHits"], values = [[], [1], [2], [3], [4], [300], [300], [301]]

› Output: [null, null, null, null, 3, null, 4, 3]

💡 Note: Initialize counter, record hits at times 1,2,3. At time 4, all 3 hits are within 300 seconds. Hit at time 300. At time 300, all 4 hits are recent. At time 301, hit at time 1 is now 300+ seconds old, so only 3 hits remain.

Example 2 — Multiple Hits Same Time

$ Input: operations = ["HitCounter", "hit", "hit", "getHits"], values = [[], [1], [1], [2]]

› Output: [null, null, null, 2]

💡 Note: Two hits at the same timestamp (time 1). getHits(2) counts both hits since they occurred within the past 300 seconds.

Example 3 — Edge Case Window Boundary

$ Input: operations = ["HitCounter", "hit", "getHits", "getHits"], values = [[], [1], [300], [301]]

› Output: [null, null, 1, 0]

💡 Note: Hit at time 1. At time 300, the hit is exactly 299 seconds ago (within window). At time 301, the hit is exactly 300 seconds ago (outside window).

Constraints

1 ≤ timestamp ≤ 2 * 10⁹
All the calls are being made to the system in chronological order
At most 300 calls will be made to hit and getHits

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 f Facebook 18 M Microsoft 15

The key insight is to maintain only recent hits within a 5-minute sliding window. The sliding window with queue approach provides optimal balance: O(n) time for getHits with automatic cleanup, and O(n) space for recent hits only. For high-frequency scenarios, the bucket array approach offers O(1) operations with fixed O(300) space.

Common Approaches

✓ One Pass Hash

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

ArrayList Storage

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

Store every hit timestamp in an array/list. For getHits(), iterate through all stored timestamps and count those within the last 300 seconds.

Bucket Array (Fixed Window)

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

Create an array of 300 buckets, each representing one second. Use timestamp % 300 to map to bucket index. For getHits(), sum all buckets and clear outdated ones.

Sliding Window with Queue

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

Use a queue (deque) to store hit timestamps. For each getHits() call, remove expired timestamps from the front of the queue, then return the queue size.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_USERS 1000
#define MAX_TWEETS 10000
#define MAX_FEED 10

typedef struct {
    int timestamp;
    int tweetId;
} Tweet;

typedef struct {
    Tweet tweets[MAX_TWEETS];
    int tweetCount;
    int following[MAX_USERS];
    int followingCount;
} User;

typedef struct {
    User users[MAX_USERS];
    int timestamp;
} Twitter;

Twitter* twitterCreate() {
    Twitter* obj = (Twitter*)calloc(1, sizeof(Twitter));
    return obj;
}

void twitterPostTweet(Twitter* obj, int userId, int tweetId) {
    User* user = &obj->users[userId];
    user->tweets[user->tweetCount].timestamp = obj->timestamp++;
    user->tweets[user->tweetCount].tweetId = tweetId;
    user->tweetCount++;
}

// Simple heap implementation for top k tweets
void heapify(Tweet arr[], int n, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    
    if (left < n && arr[left].timestamp < arr[smallest].timestamp)
        smallest = left;
    
    if (right < n && arr[right].timestamp < arr[smallest].timestamp)
        smallest = right;
    
    if (smallest != i) {
        Tweet temp = arr[i];
        arr[i] = arr[smallest];
        arr[smallest] = temp;
        heapify(arr, n, smallest);
    }
}

int* twitterGetNewsFeed(Twitter* obj, int userId, int* returnSize) {
    Tweet heap[MAX_FEED];
    int heapSize = 0;
    
    // Collect all tweets and maintain min heap of size 10
    User* user = &obj->users[userId];
    
    // Process user's own tweets
    for (int i = 0; i < user->tweetCount; i++) {
        if (heapSize < MAX_FEED) {
            heap[heapSize++] = user->tweets[i];
            // Build min heap
            for (int j = heapSize / 2 - 1; j >= 0; j--) {
                heapify(heap, heapSize, j);
            }
        } else if (user->tweets[i].timestamp > heap[0].timestamp) {
            heap[0] = user->tweets[i];
            heapify(heap, heapSize, 0);
        }
    }
    
    // Process tweets from followees
    for (int f = 0; f < user->followingCount; f++) {
        int followeeId = user->following[f];
        User* followee = &obj->users[followeeId];
        
        for (int i = 0; i < followee->tweetCount; i++) {
            if (heapSize < MAX_FEED) {
                heap[heapSize++] = followee->tweets[i];
                for (int j = heapSize / 2 - 1; j >= 0; j--) {
                    heapify(heap, heapSize, j);
                }
            } else if (followee->tweets[i].timestamp > heap[0].timestamp) {
                heap[0] = followee->tweets[i];
                heapify(heap, heapSize, 0);
            }
        }
    }
    
    // Sort heap in descending order
    for (int i = heapSize - 1; i > 0; i--) {
        Tweet temp = heap[0];
        heap[0] = heap[i];
        heap[i] = temp;
        heapify(heap, i, 0);
    }
    
    int* result = (int*)malloc(heapSize * sizeof(int));
    *returnSize = heapSize;
    for (int i = 0; i < heapSize; i++) {
        result[i] = heap[heapSize - 1 - i].tweetId;
    }
    return result;
}

void twitterFollow(Twitter* obj, int followerId, int followeeId) {
    if (followerId != followeeId) {
        User* user = &obj->users[followerId];
        for (int i = 0; i < user->followingCount; i++) {
            if (user->following[i] == followeeId) return;
        }
        user->following[user->followingCount++] = followeeId;
    }
}

void twitterUnfollow(Twitter* obj, int followerId, int followeeId) {
    User* user = &obj->users[followerId];
    for (int i = 0; i < user->followingCount; i++) {
        if (user->following[i] == followeeId) {
            for (int j = i; j < user->followingCount - 1; j++) {
                user->following[j] = user->following[j + 1];
            }
            user->followingCount--;
            break;
        }
    }
}

void twitterFree(Twitter* obj) {
    free(obj);
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

35.0K Views

High Frequency

~25 min Avg. Time

980 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