Number of Recent Calls - Practice Coding Problems

Number of Recent Calls - Problem

You're building a real-time request monitoring system that tracks recent API calls within a sliding time window. Your task is to implement a RecentCounter class that efficiently counts requests within the past 3000 milliseconds.

Class Requirements:

RecentCounter() - Initialize the counter with zero recent requests
int ping(int t) - Add a new request at time t and return the count of all requests in the range [t-3000, t] (inclusive)

Key constraint: Each call to ping uses a strictly increasing value of t, making this a data stream problem where we process requests in chronological order.

Example: If requests come at times [1, 100, 3001, 3002], when we ping at time 3002, we only count requests from time 2 onwards, which gives us [3001, 3002] = 2 requests.

Input & Output

example_1.py — Basic Usage

$ Input: counter = RecentCounter() counter.ping(1) counter.ping(100) counter.ping(3001) counter.ping(3002)

› Output: [1, 2, 3, 3]

💡 Note: At t=1: count [1] = 1. At t=100: count [1,100] = 2. At t=3001: count [1,100,3001] = 3. At t=3002: count [3001,3002] = 3 (requests at 1,100 are older than 3000ms)

example_2.py — Large Time Gap

$ Input: counter = RecentCounter() counter.ping(1) counter.ping(10000) counter.ping(10001)

› Output: [1, 1, 2]

💡 Note: At t=1: count [1] = 1. At t=10000: count [10000] = 1 (t=1 expired). At t=10001: count [10000,10001] = 2

example_3.py — Exact Boundary

$ Input: counter = RecentCounter() counter.ping(1) counter.ping(3001) counter.ping(3002)

› Output: [1, 2, 2]

💡 Note: At t=3001: requests in [1,3001] both valid. At t=3002: window is [2,3002], so t=1 just expires, leaving [3001,3002]

Constraints

1 ≤ t ≤ 10⁹
Each call to ping uses a strictly larger value of t than the previous call
At most 10⁴ calls will be made to ping
Important: The time window is always [t-3000, t] inclusive

Visualization

Tap to expand

Understanding the Visualization

Person Enters

A new visitor enters the building at time t

Clean Old Records

System automatically removes entry records older than 50 minutes

Add New Record

New entry is added to the active monitoring list

Count Active Visitors

System reports how many people entered in the last 50 minutes

Key Takeaway

🎯 Key Insight: Using a queue for chronologically ordered data allows O(1) amortized operations - each request is processed exactly once when added and once when removed.

Asked in

A Amazon 35 G Google 28 M Microsoft 22 f Meta 18

The optimal solution uses a queue-based sliding window approach. Since requests arrive in chronological order, we maintain a queue of valid timestamps. For each new request, we remove expired timestamps from the front and add the new one to the back. This achieves O(1) amortized time per ping operation.

Common Approaches

Approach	Time	Space	Notes
✓ Queue-Based Sliding Window (Optimal)	O(1)	O(W)	Use a queue to maintain only valid requests within the sliding window
Brute Force (Check All Previous Requests)	O(n)	O(n)	Store all requests and check each one for every ping call

Queue-Based Sliding Window (Optimal) — Algorithm Steps

Initialize an empty queue to store request timestamps
For each new ping, first remove expired requests from queue front
Add the new request timestamp to the queue back
Return the current queue size as the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Remove Expired

Pop old requests from queue front

Add New Request

Push new request to queue back

Count Requests

Queue size equals valid request count

Code -

solution.c — C

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

typedef struct {
    int* requests;
    int front;
    int back;
    int size;
    int capacity;
} RecentCounter;

RecentCounter* recentCounterCreate() {
    RecentCounter* obj = malloc(sizeof(RecentCounter));
    obj->capacity = 1000;
    obj->requests = malloc(obj->capacity * sizeof(int));
    obj->front = 0;
    obj->back = 0;
    obj->size = 0;
    return obj;
}

int recentCounterPing(RecentCounter* obj, int t) {
    // Add current request
    if (obj->size >= obj->capacity) {
        obj->capacity *= 2;
        int* newRequests = malloc(obj->capacity * sizeof(int));
        int idx = 0;
        for (int i = obj->front; i != obj->back; i = (i + 1) % (obj->capacity / 2)) {
            newRequests[idx++] = obj->requests[i];
        }
        free(obj->requests);
        obj->requests = newRequests;
        obj->front = 0;
        obj->back = obj->size;
    }
    
    obj->requests[obj->back] = t;
    obj->back = (obj->back + 1) % obj->capacity;
    obj->size++;
    
    // Remove expired requests
    while (obj->size > 0 && obj->requests[obj->front] < t - 3000) {
        obj->front = (obj->front + 1) % obj->capacity;
        obj->size--;
    }
    
    return obj->size;
}

void recentCounterFree(RecentCounter* obj) {
    free(obj->requests);
    free(obj);
}

int main() {
    RecentCounter* counter = recentCounterCreate();
    int t;
    printf("[");
    int first = 1;
    
    while (scanf("%d", &t) == 1) {
        if (!first) printf(", ");
        printf("%d", recentCounterPing(counter, t));
        first = 0;
    }
    printf("]\n");
    
    recentCounterFree(counter);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each request is added once and removed once, amortized O(1) per ping

✓ Linear Growth

Space Complexity

O(W)

W is the maximum number of requests in any 3000ms window

✓ Linear Space

62.0K Views

Medium Frequency

~12 min Avg. Time

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

Queue-Based Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler