Logger Rate Limiter

Design a class Logger that receives a stream of log messages, each tagged with a timestamp in seconds, and decides whether each one should actually be printed.

A message may be printed only if the same message text has not been printed in the last 10 seconds. More precisely, if a message is printed at time t, any identical message arriving before time t + 10 is suppressed, and one arriving at t + 10 or later is printed again. Suppressed messages do not reset the clock.

Implement:

• Logger() creates a logger with no history.
• shouldPrintMessage(timestamp, message) returns true if the message should be printed at timestamp, otherwise false.

Calls arrive in non-decreasing timestamp order, and several messages can share the same timestamp.

In the tests, each case is a list of operations and their arguments. The first operation constructs the logger, and the expected output lists what each call returns (null for the constructor).

The only thing you need to know about a message is when it is next allowed to print. Older history doesn't matter: once a message prints at time t, everything before t is irrelevant for that message.

So keep a map from message text to the earliest timestamp it may print again. On each call, look up the message. If the current time has reached that value (or the message is new), print it and store timestamp + 10. Otherwise return false and leave the map alone, because a suppressed message must not push its own window forward.

class Logger:
    def __init__(self):
        self.next_allowed = {}  # message -> earliest time it may print again

    def should_print_message(self, timestamp: int, message: str) -> bool:
        if timestamp < self.next_allowed.get(message, timestamp):
            return False
        self.next_allowed[message] = timestamp + 10
        return True

class Logger {
  constructor() {
    this.nextAllowed = new Map(); // message -> earliest time it may print again
  }

  shouldPrintMessage(timestamp, message) {
    if (this.nextAllowed.has(message) && timestamp < this.nextAllowed.get(message)) {
      return false;
    }
    this.nextAllowed.set(message, timestamp + 10);
    return true;
  }
}

Clarify the boundary first: "if it printed at 0, can it print at 10?" Then clarify whether suppressed messages extend the window. Interviewers often leave both ambiguous on purpose to see if you ask.

After the map solution, expect a question about memory: the map grows with every distinct message ever seen. Offer the queue-plus-set version or periodic cleanup of entries whose next allowed time has passed, and mention that a real service would also need thread safety.