Logger Rate Limiter - Practice Coding Problems

Logger Rate Limiter - Problem

Design a logger system that receives a stream of messages along with their timestamps. Each unique message should only be printed at most every 10 seconds (i.e. a message printed at timestamp t will prevent other identical messages from being printed until timestamp t + 10).

All messages will come in chronological order. Several messages may arrive at the same timestamp.

Implement the Logger class:

Logger() Initializes the logger object.
bool shouldPrintMessage(int timestamp, string message) Returns true if the message should be printed in the given timestamp, otherwise returns false.

Input & Output

Example 1 — Basic Logger Operations

$ Input: operations = ["Logger", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage", "shouldPrintMessage"], parameters = [[], [1, "foo"], [2, "bar"], [3, "foo"], [8, "bar"], [10, "foo"]]

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

💡 Note: Logger() initializes. shouldPrintMessage(1, "foo") returns true (first time). shouldPrintMessage(2, "bar") returns true (first time). shouldPrintMessage(3, "foo") returns false ("foo" was printed 2 seconds ago, less than 10). shouldPrintMessage(8, "bar") returns false ("bar" was printed 6 seconds ago). shouldPrintMessage(10, "foo") returns true ("foo" was printed 9 seconds ago, now exactly 10 seconds have passed).

Example 2 — Same Timestamp Messages

$ Input: operations = ["Logger", "shouldPrintMessage", "shouldPrintMessage"], parameters = [[], [5, "hello"], [5, "hello"]]

› Output: [null, true, false]

💡 Note: First "hello" at timestamp 5 is allowed. Second "hello" at same timestamp 5 is blocked because 5 - 5 = 0 < 10 seconds.

Example 3 — Exact 10 Second Boundary

$ Input: operations = ["Logger", "shouldPrintMessage", "shouldPrintMessage"], parameters = [[], [0, "test"], [10, "test"]]

› Output: [null, true, true]

💡 Note: "test" at timestamp 0 is allowed. "test" at timestamp 10 is allowed because 10 - 0 = 10 seconds (not less than 10).

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

Input Stream

Messages arrive with timestamps in chronological order

Rate Limiting

Block duplicate messages within 10 seconds

Output Decision

Return true/false for each shouldPrintMessage call

Key Takeaway

🎯 Key Insight: Only track the last timestamp per unique message using a hash map for O(1) rate limiting decisions

Asked in

G Google 25 a Amazon 18 M Microsoft 12 f Facebook 15

The key insight is that we only need to track the last timestamp for each unique message, not all occurrences. Best approach uses a hash map to store message → last_timestamp mappings for O(1) lookup and update. Time: O(1), Space: O(k) where k is the number of unique messages.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map Optimization	O(1)	O(k)	Store only the last timestamp for each unique message using hash map
Brute Force with List	O(n)	O(n)	Store all messages with timestamps and scan entire list for duplicates

Hash Map Optimization — Algorithm Steps

Check if message exists in hash map
Compare current timestamp with stored timestamp
Update hash map with new timestamp if message should be printed

Visualization

Tap to expand

Step-by-Step Walkthrough

Hash Map Lookup

Instantly find last timestamp for message

Time Comparison

Check if current time - last time >= 10

Update Map

Store new timestamp and return result

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.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 count;
} Logger;

Logger* createLogger() {
    Logger* logger = (Logger*)malloc(sizeof(Logger));
    logger->count = 0;
    return logger;
}

bool shouldPrintMessage(Logger* logger, int timestamp, char* message) {
    // Check if message exists and was seen within last 10 seconds
    for (int i = 0; i < logger->count; i++) {
        if (strcmp(logger->entries[i].message, message) == 0) {
            if (timestamp - logger->entries[i].timestamp < 10) {
                return false;
            }
            // Update existing entry
            logger->entries[i].timestamp = timestamp;
            return true;
        }
    }
    
    // Add new message entry
    strcpy(logger->entries[logger->count].message, message);
    logger->entries[logger->count].timestamp = timestamp;
    logger->count++;
    
    return true;
}

int main() {
    // Simplified for this example
    printf("[null,true,true,false,false,true]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Hash map lookup and update operations are constant time

✓ Linear Growth

Space Complexity

O(k)

Stores at most k unique messages in hash map, where k is number of distinct messages

✓ Linear Space

187.0K Views

Medium Frequency

~15 min Avg. Time

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

Hash Map Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler