Design Hit Counter - Practice Coding Problems

Design Hit Counter - Problem

Array Binary Search Design Queue Data Stream Medium

Design a Hit Counter System

Imagine you're building a real-time analytics system that needs to track website hits or API requests. You need to design a HitCounter class that efficiently counts the number of hits received in the past 5 minutes (300 seconds).

Your system will receive timestamps in chronological order and needs to support two operations:
• hit(timestamp) - Record a hit at the given timestamp
• getHits(timestamp) - Return the count of hits in the past 300 seconds from the given timestamp

Key Challenge: Multiple hits can occur at the same timestamp, and you need to efficiently handle the sliding window of 300 seconds while maintaining good performance for both operations.

Example:
HitCounter counter = new HitCounter();
counter.hit(1); // hit at timestamp 1
counter.hit(2); // hit at timestamp 2
counter.hit(3); // hit at timestamp 3
counter.getHits(4); // returns 3 (hits at 1,2,3 are within [4-300, 4])
counter.hit(300); // hit at timestamp 300
counter.getHits(300); // returns 4 (all hits within [1, 300])
counter.getHits(301); // returns 1 (only hit at 300 within [2, 301])

Input & Output

basic_operations.py — Basic Hit Counter Usage

$ Input: HitCounter counter = new HitCounter(); counter.hit(1); counter.hit(2); counter.hit(3); counter.getHits(4); // query at timestamp 4 counter.hit(300); counter.getHits(300); // query at timestamp 300 counter.getHits(301); // query at timestamp 301

› Output: null null null null 3 null 4 1

💡 Note: At timestamp 4, all hits (1,2,3) are within [4-300+1, 4] = [-295, 4]. At timestamp 300, all hits (1,2,3,300) are within [1, 300]. At timestamp 301, only hit at 300 is within [2, 301].

multiple_hits_same_timestamp.py — Multiple Hits

$ Input: HitCounter counter = new HitCounter(); counter.hit(1); counter.hit(1); counter.hit(1); counter.hit(2); counter.getHits(2);

› Output: null null null null 4

💡 Note: Multiple hits can occur at the same timestamp. At timestamp 2, we have 3 hits at timestamp 1 and 1 hit at timestamp 2, totaling 4 hits within the window.

sliding_window_edge_case.py — Sliding Window

$ Input: HitCounter counter = new HitCounter(); counter.hit(100); counter.hit(200); counter.hit(300); counter.getHits(300); counter.getHits(399); counter.getHits(400);

› Output: null null null 3 3 2

💡 Note: At 300: hits 100,200,300 are within [1,300]. At 399: hits 100,200,300 are within [100,399]. At 400: only hits 200,300 are within [101,400], so count is 2.

Visualization

Tap to expand

Understanding the Visualization

Hit Recording

When a hit occurs at timestamp T, map it to bucket T % 300 in the circular array

Bucket Management

If the bucket is outdated (timestamp differs), reset it and store the new hit count

Query Processing

For getHits(T), scan all 300 buckets and sum counts from buckets with timestamps > T-300

Sliding Window

The circular array naturally maintains a 300-second sliding window, automatically aging out old data

Key Takeaway

🎯 Key Insight: The circular array approach transforms the sliding window problem into a fixed-size array problem, achieving optimal O(1) time and space complexity while naturally handling the time-based expiration of old data.

Time & Space Complexity

Time Complexity

⏱️

O(1) amortized

hit() is O(1), getHits() scans at most 300 buckets which is O(1) constant

✓ Linear Growth

Space Complexity

O(1)

Fixed space of 300 buckets regardless of number of hits

✓ Linear Space

Constraints

1 ≤ timestamp ≤ 2 × 10⁹
All the calls are being made to the system in chronological order (i.e., timestamp is monotonically increasing)
At most 300 calls will be made to hit and getHits
Follow up: What if the number of hits per second could be huge? Does your design scale?

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18 Apple 15

The optimal solution uses a circular array with 300 buckets to represent a sliding time window. Each bucket stores hit counts and timestamps for one second. This achieves O(1) amortized time complexity for both operations while using only O(1) space, making it highly efficient for real-time analytics systems.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(n)	O(n)	Store all hits in a list and count valid ones for each query
Circular Array (Optimal)	O(1) amortized	O(1)	Use a circular array with 300 buckets for O(1) operations
List + Binary Search	O(log n + k)	O(n)	Store hits in a list and use binary search to find the valid range

Brute Force (Linear Search) — Algorithm Steps

Initialize an empty list to store all hit timestamps
For hit(timestamp): append the timestamp to the list
For getHits(timestamp): iterate through all timestamps and count those >= (timestamp - 300)
Return the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Hit

Append new timestamp to the list

Query Hits

Scan all timestamps and count those within 300 seconds

Return Count

Return the total count of valid hits

Code -

solution.c — C

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

typedef struct {
    int* hits;
    int size;
    int capacity;
} HitCounter;

HitCounter* hitCounterCreate() {
    HitCounter* obj = malloc(sizeof(HitCounter));
    obj->capacity = 1000;
    obj->hits = malloc(obj->capacity * sizeof(int));
    obj->size = 0;
    return obj;
}

void hitCounterHit(HitCounter* obj, int timestamp) {
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        obj->hits = realloc(obj->hits, obj->capacity * sizeof(int));
    }
    obj->hits[obj->size++] = timestamp;
}

int hitCounterGetHits(HitCounter* obj, int timestamp) {
    int count = 0;
    for (int i = 0; i < obj->size; i++) {
        if (obj->hits[i] > timestamp - 300) {
            count++;
        }
    }
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each getHits() call requires scanning all n stored timestamps

✓ Linear Growth

Space Complexity

O(n)

Store all hit timestamps in memory indefinitely

⚡ Linearithmic Space

Constraints

1 ≤ timestamp ≤ 2 × 10⁹
All the calls are being made to the system in chronological order (i.e., timestamp is monotonically increasing)
At most 300 calls will be made to hit and getHits
Follow up: What if the number of hits per second could be huge? Does your design scale?

42.0K Views

High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler