Codestin Search App

Logger Rate Limiter - Problem

Design a Logger Rate Limiter System

You need to design a smart logging system that prevents spam by rate-limiting messages. The system receives a continuous stream of log messages along with their timestamps, and each unique message should only be printed at most every 10 seconds.

Here's how it works:
• If a message is printed at timestamp t, the same message cannot be printed again until timestamp t + 10
• All messages arrive in chronological order (timestamps are non-decreasing)
• Multiple different messages can arrive at the same timestamp

Your task: Implement the Logger class with:
• Logger() - Initialize the logger
• shouldPrintMessage(timestamp, message) - Return true if the message should be printed, false if it's still in the cooldown period

Example:
logger.shouldPrintMessage(1, "foo") → true (first time)
logger.shouldPrintMessage(2, "bar") → true (different message)
logger.shouldPrintMessage(3, "foo") → false (too soon, need to wait until timestamp 11)
logger.shouldPrintMessage(11, "foo") → true (cooldown period over)

Input & Output

example_1.py — Basic Usage

$ Input: Logger logger = new Logger(); logger.shouldPrintMessage(1, "foo"); logger.shouldPrintMessage(2, "bar"); logger.shouldPrintMessage(3, "foo");

› Output: true true false

💡 Note: First "foo" at t=1 is allowed. "bar" at t=2 is a different message, so allowed. Second "foo" at t=3 is only 2 seconds after the first (need 10), so blocked.

example_2.py — Cooldown Expiry

$ Input: Logger logger = new Logger(); logger.shouldPrintMessage(1, "foo"); logger.shouldPrintMessage(11, "foo"); logger.shouldPrintMessage(21, "foo");

› Output: true true true

💡 Note: "foo" at t=1, then at t=11 (exactly 10 seconds later - allowed), then at t=21 (10 seconds after t=11 - allowed).

example_3.py — Multiple Messages

$ Input: Logger logger = new Logger(); logger.shouldPrintMessage(0, "A"); logger.shouldPrintMessage(0, "B"); logger.shouldPrintMessage(1, "C"); logger.shouldPrintMessage(5, "A"); logger.shouldPrintMessage(10, "A");

› Output: true true true false true

💡 Note: Different messages at same timestamp are allowed. "A" is blocked at t=5 (only 5 seconds since t=0) but allowed at t=10 (exactly 10 seconds later).

Constraints

0 ≤ timestamp ≤ 10⁹
Every timestamp will be passed in non-decreasing order (chronological order)
1 ≤ message.length ≤ 30
At most 10⁴ calls will be made to shouldPrintMessage

Visualization

Tap to expand

Understanding the Visualization

Message Arrives

A new message arrives with timestamp

Check History

Look up when this message was last printed

Calculate Difference

Check if enough time (≥10 seconds) has passed

Update & Return

If allowed, update timestamp and return true

Key Takeaway

🎯 Key Insight: We only need to track the MOST RECENT timestamp for each message type - not the entire printing history. This transforms an O(n) linear search into an O(1) hash table lookup!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Facebook 28

The optimal solution uses a hash table to map each unique message to its last printed timestamp. This achieves O(1) time complexity for each operation by eliminating the need to store or search through historical data. The key insight is that we only need to remember the most recent timestamp for each message, not the entire printing history.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Store All Messages)	O(n)	O(n)	Store every printed message with its timestamp in a list
Hash Table (Optimal)	O(1)	O(m)	Use hash table to store only the last timestamp of each message

Brute Force (Store All Messages) — Algorithm Steps

Initialize an empty list to store all printed messages with timestamps
When shouldPrintMessage is called, iterate through the entire list
Check if any previous occurrence of the same message was within 10 seconds
If no recent occurrence found, add the message to the list and return true
Otherwise, return false without adding to the list

Visualization

Tap to expand

Step-by-Step Walkthrough

Store All Messages

Every printed message is added to a growing list

Linear Search

For each new message, scan entire list to check duplicates

Memory Growth

List grows indefinitely with every printed message

Code -

solution.c — C

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

typedef struct {
    int timestamp;
    char message[1000];
} LogEntry;

typedef struct {
    LogEntry* entries;
    int size;
    int capacity;
} Logger;

Logger* loggerCreate() {
    Logger* logger = (Logger*)malloc(sizeof(Logger));
    logger->entries = (LogEntry*)malloc(1000 * sizeof(LogEntry));
    logger->size = 0;
    logger->capacity = 1000;
    return logger;
}

bool loggerShouldPrintMessage(Logger* obj, int timestamp, char* message) {
    // Check if message was printed in last 10 seconds
    for (int i = 0; i < obj->size; i++) {
        if (strcmp(obj->entries[i].message, message) == 0 && 
            timestamp - obj->entries[i].timestamp < 10) {
            return false;
        }
    }
    
    // Message can be printed
    obj->entries[obj->size].timestamp = timestamp;
    strcpy(obj->entries[obj->size].message, message);
    obj->size++;
    return true;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

For each shouldPrintMessage call, we scan through all n previously printed messages

✓ Linear Growth

Space Complexity

O(n)

We store every printed message permanently, leading to unlimited growth

⚡ Linearithmic Space

48.0K Views

High Frequency

~15 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

Brute Force (Store All Messages) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler