Number of Recent Calls

Number of Recent Calls - Problem

You have a RecentCounter class which counts the number of recent requests within a certain time frame.

Implement the RecentCounter class:

RecentCounter() Initializes the counter with zero recent requests.
int ping(int t) Adds a new request at time t, where t represents some time in milliseconds, and returns the number of requests that has happened in the past 3000 milliseconds (including the new request). Specifically, return the number of requests that have happened in the inclusive range [t - 3000, t].

It is guaranteed that every call to ping uses a strictly larger value of t than the previous call.

Input & Output

Example 1 — Basic Usage

$ Input: operations = ["RecentCounter", "ping", "ping", "ping", "ping"], values = [null, 1, 100, 3001, 3002]

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

💡 Note: RecentCounter() creates counter. ping(1) returns 1 (only request 1). ping(100) returns 2 (requests 1,100). ping(3001) returns 3 (requests 1,100,3001). ping(3002) returns 3 (requests 100,3001,3002 - request 1 expired)

Example 2 — All Requests Expire

$ Input: operations = ["RecentCounter", "ping", "ping"], values = [null, 1, 5000]

› Output: [null, 1, 1]

💡 Note: ping(1) returns 1. ping(5000) returns 1 because request at time 1 is outside range [5000-3000, 5000] = [2000, 5000]

Example 3 — Close Timestamps

$ Input: operations = ["RecentCounter", "ping", "ping", "ping"], values = [null, 1000, 2000, 3500]

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

💡 Note: All requests stay within 3000ms window: ping(3500) checks range [500, 3500] which includes 1000, 2000, 3500

Constraints

1 ≤ t ≤ 10⁹
Each test case will call ping with strictly increasing values of t
At most 10⁴ calls will be made to ping

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is that since requests come in chronological order, expired requests are always at the front of our data structure. The optimal approach uses a queue to store timestamps and removes expired ones from the front for each ping. Time: O(1) amortized, Space: O(W) where W is the window size.

Common Approaches

✓ Brute Force - Store All Requests

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

Keep a list of all request timestamps. For each ping, iterate through all stored timestamps to count how many fall within the [t-3000, t] range.

Queue-Based Solution

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

Since requests come in chronological order, expired requests are always at the front of the queue. For each ping, add the new request to the back and remove expired requests from the front.

Brute Force - Store All Requests — Algorithm Steps

Store each ping timestamp in a list
For each ping, scan entire list
Count timestamps in range [t-3000, t]

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Request

Add new timestamp to list

Scan All

Check each stored timestamp

Count Valid

Count requests in [t-3000, t] range

Code -

solution.c — C

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

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

RecentCounter* recentCounterCreate() {
    RecentCounter* counter = (RecentCounter*)malloc(sizeof(RecentCounter));
    counter->capacity = 10000;
    counter->requests = (int*)malloc(counter->capacity * sizeof(int));
    counter->size = 0;
    return counter;
}

int recentCounterPing(RecentCounter* obj, int t) {
    obj->requests[obj->size++] = t;
    int count = 0;
    for (int i = 0; i < obj->size; i++) {
        if (obj->requests[i] >= t - 3000 && obj->requests[i] <= t) {
            count++;
        }
    }
    return count;
}

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

void parseOperations(const char* str, char operations[][20], int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '"') p++;
        
        int i = 0;
        while (*p && *p != '"' && *p != ',' && *p != ']') {
            operations[*size][i++] = *p++;
        }
        operations[*size][i] = '\0';
        (*size)++;
        
        if (*p == '"') p++;
    }
}

void parseValues(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (strncmp(p, "null", 4) == 0) {
            arr[(*size)++] = 0;
            p += 4;
        } else if (*p == '[') {
            // Skip array content until closing bracket
            p++;
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            arr[(*size)++] = 0; // Placeholder for array
        } else {
            arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        }
    }
}

int main() {
    char line1[10000], line2[10000];
    if (!fgets(line1, sizeof(line1), stdin) || !fgets(line2, sizeof(line2), stdin)) {
        return 1;
    }
    
    char operations[1000][20];
    int operationsSize;
    int values[1000];
    int valuesSize;
    
    parseOperations(line1, operations, &operationsSize);
    parseValues(line2, values, &valuesSize);
    
    RecentCounter* counter = NULL;
    int valueIndex = 0;
    
    printf("[");
    for (int i = 0; i < operationsSize; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "RecentCounter") == 0) {
            counter = recentCounterCreate();
            printf("null");
            valueIndex++; // Skip the constructor's value
        } else if (strcmp(operations[i], "ping") == 0) {
            int result = recentCounterPing(counter, values[valueIndex]);
            printf("%d", result);
            valueIndex++;
        }
    }
    printf("]\n");
    
    if (counter) recentCounterFree(counter);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each ping scans all n previous requests

✓ Linear Growth

Space Complexity

O(n)

Stores all n requests even after they expire

⚡ Linearithmic Space

95.0K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force - Store All Requests — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler