FilesExpand file tree

 master

/

LoggerRateLimiter359.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

92 lines (82 loc) · 3.07 KB

 master

/

LoggerRateLimiter359.java

Copy path

Top

File metadata and controls

• Code
• Blame

92 lines (82 loc) · 3.07 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

/**

* Design a logger system that receive stream of messages along with its

* timestamps, each message should be printed if and only if it is not printed

* in the last 10 seconds.

*

* Given a message and a timestamp (in seconds granularity), return true if

* the message should be printed in the given timestamp, otherwise returns

* false.

*

* It is possible that several messages arrive roughly at the same time.

*

* Example:

*

* Logger logger = new Logger();

*

* // logging string "foo" at timestamp 1

* logger.shouldPrintMessage(1, "foo"); returns true;

*

* // logging string "bar" at timestamp 2

* logger.shouldPrintMessage(2,"bar"); returns true;

*

* // logging string "foo" at timestamp 3

* logger.shouldPrintMessage(3,"foo"); returns false;

*

* // logging string "bar" at timestamp 8

* logger.shouldPrintMessage(8,"bar"); returns false;

*

* // logging string "foo" at timestamp 10

* logger.shouldPrintMessage(10,"foo"); returns false;

*

* // logging string "foo" at timestamp 11

* logger.shouldPrintMessage(11,"foo"); returns true;

*/

public class LoggerRateLimiter359 {

class Logger {

Map<String, Integer> map = new HashMap<>();

/** Initialize your data structure here. */

public 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. */

public boolean shouldPrintMessage(int timestamp, String message) {

if (!map.containsKey(message) || map.get(message) + 10 <= timestamp) {

map.put(message, timestamp);

return true;

}

return false;

}

}

/**

* https://leetcode.com/problems/logger-rate-limiter/discuss/83254/Java-with-a-LinkedHashMap-and-using-removeEldestEntry

*/

class Logger2 {

public Map<String, Integer> map;

int lastSecond = 0;

/** Initialize your data structure here. */

public Logger() {

map = new LinkedHashMap<String, Integer>(100, 0.6f, true) {

protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {

return lastSecond - eldest.getValue() > 10;

}

};

}

/** 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) {

lastSecond = timestamp;

if(!map.containsKey(message)||timestamp - map.get(message) >= 10){

map.put(message,timestamp);

return true;

}

return false;

}

}

/**

* Your Logger object will be instantiated and called as such:

* Logger obj = new Logger();

* boolean param_1 = obj.shouldPrintMessage(timestamp,message);

*/

}