Logger Rate Limiter

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, false]

💡 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 false ("foo" was printed 9 seconds ago, which is still less than 10).

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

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

✓ Sort First

⏱️ Time: N/A Space: N/A

Brute Force with List

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

For each new message, scan through all previously stored messages to find if the same message appeared within the last 10 seconds. Store every message-timestamp pair in a list.

Hash Map Optimization

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

Use a hash map where keys are message strings and values are their last seen timestamps. For each new message, check if it exists in the map and if the time difference is less than 10 seconds.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ 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