Codestin Search App

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.

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?

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.

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
✓ Circular Array (Optimal)	O(1) amortized	O(1)	Use a circular array with 300 buckets for O(1) operations
Brute Force (Linear Search)	O(n)	O(n)	Store all hits in a list and count valid ones for each query
List + Binary Search	O(log n + k)	O(n)	Store hits in a list and use binary search to find the valid range

Circular Array (Optimal) — Algorithm Steps

Initialize arrays of size 300: hits[] for counts, times[] for timestamps
For hit(timestamp): find bucket = timestamp % 300, clear if outdated, increment count
For getHits(timestamp): iterate through all 300 buckets, clear outdated ones, sum valid counts
A bucket is outdated if times[i] <= timestamp - 300

Visualization

Tap to expand

Step-by-Step Walkthrough

Map to Bucket

timestamp % 300 maps to array index

Update Bucket

Clear if outdated, then increment hit count

Sum Valid Buckets

Check all 300 buckets and sum valid ones

Code -

solution.c — C

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

typedef struct {
    int hits[300];
    int times[300];
} HitCounter;

HitCounter* hitCounterCreate() {
    HitCounter* obj = malloc(sizeof(HitCounter));
    memset(obj->hits, 0, sizeof(obj->hits));
    memset(obj->times, 0, sizeof(obj->times));
    return obj;
}

void hitCounterHit(HitCounter* obj, int timestamp) {
    int idx = timestamp % 300;
    if (obj->times[idx] != timestamp) {
        obj->times[idx] = timestamp;
        obj->hits[idx] = 1;
    } else {
        obj->hits[idx]++;
    }
}

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

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

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

Constraints

Visualization

Related Problems

Common Approaches

Circular Array (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler