Rate Limiter - Problem

Design and implement a rate limiter that controls the rate of requests using the sliding window algorithm. The rate limiter should allow exactly N requests per time window of W seconds.

Your rate limiter must support:

allow(timestamp) - Returns true if the request at the given timestamp is allowed, false otherwise
The sliding window should continuously move based on the current timestamp
Only requests within the current time window should be counted

The sliding window algorithm maintains a window that slides forward in time, removing old requests that fall outside the current window before deciding whether to allow new requests.

Input & Output

Example 1 — Basic Rate Limiting

$ Input: maxRequests = 2, windowSize = 10, requests = [1, 2, 15, 16]

› Output: [true, true, true, false]

💡 Note: First two requests (t=1, t=2) are allowed. At t=15, window [5-15] only contains t=15, so allowed. At t=16, window [6-16] contains t=15 and t=16, reaching limit of 2.

Example 2 — Window Sliding

$ Input: maxRequests = 3, windowSize = 5, requests = [1, 3, 5, 7, 9]

› Output: [true, true, true, true, false]

💡 Note: Requests at t=1,3,5 fill the limit. At t=7, window [2-7] contains t=3,5,7 (3 requests). At t=9, window [4-9] contains t=5,7 so t=9 would make it 3, but limit is 3, so rejected.

Example 3 — All Requests Allowed

$ Input: maxRequests = 5, windowSize = 3, requests = [1, 5, 10]

› Output: [true, true, true]

💡 Note: Each request is far enough apart that the sliding window never contains more than 1 request at a time, well under the limit of 5.

Constraints

1 ≤ maxRequests ≤ 100
1 ≤ windowSize ≤ 1000
1 ≤ requests.length ≤ 1000
1 ≤ requests[i] ≤ 10⁶
requests are sorted in non-decreasing order

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 N Netflix 28

The optimal approach uses a queue (deque) to maintain the sliding window efficiently. The key insight is that we only need to track requests within the current time window - expired requests can be removed from the front while new requests are added to the back. This gives us O(1) amortized time per request and O(k) space where k is the maximum number of requests allowed.

Common Approaches

✓ Brute Force - Check All Historical Requests

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

Keep a list of all request timestamps ever received. For each new request, iterate through the entire list to count how many requests fall within the current time window.

Optimized - Queue with Automatic Cleanup

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

Maintain requests in a queue structure where we only remove old requests when needed and add new ones at the end. This ensures we never store more than necessary.

Sliding Window - Clean Old Requests

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

Before processing each request, actively remove all expired timestamps that fall outside the current window, then check if we can accept the new request.

Brute Force - Check All Historical Requests — Algorithm Steps

Store every incoming request timestamp in a list
For each new request, scan entire list to count requests in current window
Allow request if count is less than maxRequests

Visualization

Tap to expand

Step-by-Step Walkthrough

Store All Requests

Keep every request timestamp in a growing list

Scan Entire History

For each new request, check all historical timestamps

Count Valid Requests

Count how many fall within current window and decide

Code -

solution.c — C

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

typedef struct {
    int maxRequests;
    int windowSize;
    int* requests;
    int count;
    int capacity;
} RateLimiter;

RateLimiter* createRateLimiter(int maxRequests, int windowSize) {
    RateLimiter* rl = malloc(sizeof(RateLimiter));
    rl->maxRequests = maxRequests;
    rl->windowSize = windowSize;
    rl->requests = malloc(1000 * sizeof(int));
    rl->count = 0;
    rl->capacity = 1000;
    return rl;
}

bool allow(RateLimiter* rl, int timestamp) {
    // Count all requests within current window
    int count = 0;
    for (int i = 0; i < rl->count; i++) {
        if (rl->requests[i] > timestamp - rl->windowSize) {
            count++;
        }
    }
    
    if (count < rl->maxRequests) {
        if (rl->count >= rl->capacity) {
            rl->capacity *= 2;
            rl->requests = realloc(rl->requests, rl->capacity * sizeof(int));
        }
        rl->requests[rl->count++] = timestamp;
        return true;
    }
    return false;
}

int main() {
    int maxRequests, windowSize;
    scanf("%d", &maxRequests);
    scanf("%d", &windowSize);
    
    char line[1000];
    scanf("%s", line);
    
    // Parse array manually
    int requests[100];
    int requestCount = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        requests[requestCount++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    RateLimiter* limiter = createRateLimiter(maxRequests, windowSize);
    printf("[");
    for (int i = 0; i < requestCount; i++) {
        bool result = allow(limiter, requests[i]);
        printf("%s", result ? "true" : "false");
        if (i < requestCount - 1) printf(",");
    }
    printf("]\n");
    
    free(limiter->requests);
    free(limiter);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

For each request, we scan through all n historical requests to count valid ones

✓ Linear Growth

Space Complexity

O(n)

We store every single request timestamp forever, growing without bound

✓ Linear Space

34.5K Views

High Frequency

~25 min Avg. Time

890 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

Rate Limiter - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Historical Requests — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler