Logger Rate Limiter - Practice Coding Problems

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).

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!

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash table lookup and update operations are O(1) on average

✓ Linear Growth

Space Complexity

O(m)

Where m is the number of unique messages seen so far

✓ Linear Space

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

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
✓ Hash Table (Optimal)	O(1)	O(m)	Use hash table to store only the last timestamp of each message
Brute Force (Store All Messages)	O(n)	O(n)	Store every printed message with its timestamp in a list

Hash Table (Optimal) — Algorithm Steps

Initialize a hash table to map message → last_printed_timestamp
When shouldPrintMessage is called, check if message exists in hash table
If message doesn't exist or enough time has passed (≥10 seconds), allow printing
Update the hash table with the new timestamp and return true
Otherwise, return false without updating

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Table Lookup

Check if message exists and get last timestamp in O(1)

Time Check

Compare current timestamp with last printed time

Update/Insert

Update hash table with new timestamp if message can be printed

Code -

solution.c — C

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

#define MAX_MESSAGES 1000
#define MAX_MSG_LEN 100

typedef struct {
    char message[MAX_MSG_LEN];
    int timestamp;
} MessageEntry;

typedef struct {
    MessageEntry entries[MAX_MESSAGES];
    int size;
} Logger;

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

int findMessage(Logger* obj, char* message) {
    for (int i = 0; i < obj->size; i++) {
        if (strcmp(obj->entries[i].message, message) == 0) {
            return i;
        }
    }
    return -1;
}

bool loggerShouldPrintMessage(Logger* obj, int timestamp, char* message) {
    int index = findMessage(obj, message);
    
    // Check if message can be printed
    if (index == -1 || timestamp - obj->entries[index].timestamp >= 10) {
        if (index == -1) {
            // New message, add to entries
            strcpy(obj->entries[obj->size].message, message);
            obj->entries[obj->size].timestamp = timestamp;
            obj->size++;
        } else {
            // Update existing message timestamp
            obj->entries[index].timestamp = timestamp;
        }
        return true;
    }
    
    // Message is still in cooldown period
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash table lookup and update operations are O(1) on average

✓ Linear Growth

Space Complexity

O(m)

Where m is the number of unique messages seen so far

✓ Linear Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler