# Solution For Logger Rate Limiter

Logger Rate Limiter is a problem on LeetCode that asks you to implement a logger that can output messages, but limit the rate messages are output. Specifically, the logger should only output a message if it hasn’t been seen in the last 10 seconds.

To solve the Logger Rate Limiter problem, we can use a hash table to store the last timestamp that a given message was seen. We can then compare the current timestamp to the last seen timestamp for a message to determine whether or not that message should be logged.

Here’s an example solution in Python:

“`
class Logger:
def init(self):
self.timestamp = {}

``````def shouldPrintMessage(self, timestamp: int, message: str) -> bool:
if message in self.timestamp:
if timestamp - self.timestamp[message] < 10:
return False
self.timestamp[message] = timestamp
return True
``````

“`

In this solution, we create a hash table called `timestamp` to store the last seen timestamp for each message. In the `shouldPrintMessage` method, we check if the message has been seen before by checking if it’s in the `timestamp` hash table. If it is, we compare the current timestamp to the last seen timestamp for that message. If the difference is less than 10 seconds, we return `False` because we don’t want to print the message. Otherwise, we update the `timestamp` hash table with the current timestamp and return `True`, allowing the message to be printed.

Overall, this solution has a time complexity of O(n), where n is the number of messages seen by the logger, and a space complexity of O(m), where m is the number of unique messages seen by the logger. It’s a simple and efficient solution that satisfies the requirements of the Logger Rate Limiter problem.

## Step by Step Implementation For Logger Rate Limiter

```/**
* Your Logger object will be instantiated and called as such:
* Logger obj = new Logger();
* boolean param_1 = obj.shouldPrintMessage(timestamp,message);
*/

class Logger {

// We use a HashMap to store the messages that have been printed.
// The key is the message, and the value is the timestamp.
Map map;

/** Initialize your data structure here. */
public Logger() {
map = new HashMap<>();
}

/** Returns true if the message should be printed in the given timestamp, otherwise returns false.
If this method returns false, the message will not be printed.
The timestamp is in seconds granularity. */
public boolean shouldPrintMessage(int timestamp, String message) {
// If the message is not in the HashMap, we add it and return true.
if (!map.containsKey(message)) {
map.put(message, timestamp);
return true;
}
// Otherwise, we check if the message was printed within the last 10 seconds.
// If it was, we return false. Otherwise, we update the timestamp and return true.
else {
if (timestamp - map.get(message) >= 10) {
map.put(message, timestamp);
return true;
}
else
return false;
}
}
}```
```"""

# This is the Logger Rate Limiter class

class Logger:

def __init__(self):
"""
"""
self.log_dict = {}

def shouldPrintMessage(self, timestamp: int, message: str) -> bool:
"""
Returns true if the message should be printed in the given timestamp, otherwise returns false.
If this method returns false, the message will not be printed.
The timestamp is in seconds granularity.
"""
if message in self.log_dict:
if timestamp - self.log_dict[message] >= 10:
self.log_dict[message] = timestamp
return True
else:
return False
else:
self.log_dict[message] = timestamp
return True```
```/**
* Initialize your data structure here.
*/
var Logger = function() {
this.map = new Map();
};

/**
* Returns true if the message should be printed in the given timestamp, otherwise returns false.
If this method returns false, the message will not be printed.
The timestamp is in seconds granularity.
* @param {number} timestamp
* @param {string} message
* @return {boolean}
*/
Logger.prototype.shouldPrintMessage = function(timestamp, message) {
// check if message exists in map
if (this.map.has(message)) {
// check if 10 seconds have passed since last print
if (timestamp - this.map.get(message) >= 10) {
// update map with new timestamp
this.map.set(message, timestamp);
return true;
} else {
return false;
}
} else {
// set map with message and timestamp
this.map.set(message, timestamp);
return true;
}
};

/**
* Your Logger object will be instantiated and called as such:
* var obj = new Logger()
* var param_1 = obj.shouldPrintMessage(timestamp,message)
*/```
```class Logger {
public:
/** Initialize your data structure here. */
Logger() {

}

/** Returns true if the message should be printed in the given timestamp, otherwise returns false.
If this method returns false, the message will not be printed.
The timestamp is in seconds granularity. */
bool shouldPrintMessage(int timestamp, string message) {
if (message.empty()) {
return false;
}

if (mp.find(message) == mp.end()) {
// First time this message is printed.
mp[message] = timestamp;
return true;
} else {
// Message has been printed before.
if (timestamp - mp[message] >= 10) {
// Message can be printed again after 10 seconds.
mp[message] = timestamp;
return true;
} else {
// Message has been printed within 10 seconds.
return false;
}
}
}

private:
unordered_map mp; // message, timestamp
};```
```public class Logger {

private Dictionary _dict;

public Logger() {

_dict = new Dictionary();

}

public bool ShouldPrintMessage(int timestamp, string message) {

if (!_dict.ContainsKey(message)) {

return true;

}

int lastPrintedTimestamp = _dict[message];

if (timestamp - lastPrintedTimestamp >= 10) {

_dict[message] = timestamp;

return true;

}

return false;

}

}```

Scroll to Top
[gravityforms id="5" description="false" titla="false" ajax="true"]