249_Group_Shifted_Strings

359_Logger_Rate_Limiter

Author: qiyuangong

README.md

@@ -85,6 +85,7 @@
 | 228 | [Summary Ranges](https://leetcode.com/problems/summary-ranges/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/228_Summary_Ranges.py) | Detect start and jump, O(n) and O(1) |
 | 243 | [Shortest Word Distance](https://leetcode.com/problems/shortest-word-distance/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/243_Shortest_Word_Distance.py) | Update index1 and index2, and check distance, O(n) and O(1) |
 | 246 | [Strobogrammatic Number](https://leetcode.com/problems/strobogrammatic-number/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/246_Strobogrammatic_Number.py) | Hash table and reverse string, O(n) and O(n) |
+| 249 | [Group Shifted Strings](https://leetcode.com/problems/group-shifted-strings/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/249_Group_Shifted_Strings.py) | Hash and generate hash code for each string, O(n) and O(n) |
 | 252 | [Meeting Rooms](https://leetcode.com/problems/meeting-rooms/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/252_Meeting_Rooms.py) | 1. Sort and compare intervals[i].end with intervals[i+1], O(nlogn) and O(1)<br>2. Sort and check intervals when count >= 2, O(nlogn) and O(n) |
 | 259 | [3Sum Smaller](https://leetcode.com/problems/3sum-smaller/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/259_3Sum_Smaller.py) | 1. Reduce to two sum smaller, then binary search, O(n^2lgn) and O(1)<br>2. Reduce to two sum smaller, then two points, O(n^2) and O(1)|
 | 266 | [Palindrome Permutation](https://leetcode.com/problems/palindrome-permutation/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/266_Palindrome_Permutation.py) | Compute frequency, check number of odd occurrences <= 1 then palindrome, O(n) and O(n)|
@@ -105,6 +106,7 @@
 | 346 | [Moving Average from Data Stream](https://leetcode.com/problems/moving-average-from-data-stream/) &hearts; | 
 [Python](https://github.com/qiyuangong/leetcode/blob/master/python/346_Moving_Average_from_Data_Stream.py) | fix-sized queue or dequeue, O(1) and O(n) |
 | 351 | [Android Unlock Patterns](https://leetcode.com/problems/android-unlock-patterns/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/351_Android_Unlock_Patterns.py) | Backtracking, O(n!) and O(n) |
+| 359 | [Logger Rate Limiter](https://leetcode.com/problems/logger-rate-limiter/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/359_Logger_Rate_Limiter.py) | 1. hash which stores the latest timestamp, O(1) and O(n)<br>2. Using Priority queue to remove older logs, O(n) and O(n)|
 | 368 | [Largest Divisible Subset](https://leetcode.com/problems/largest-divisible-subset/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/368_Largest_Divisible_Subset.py) | Sort and generate x subset with previous results, O(n^2) and O(n^2) |
 | 370 | [Range Addition](https://leetcode.com/problems/range-addition/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/370_Range_Addition.py) | Interval problem with cumulative sums, O(n + k) and O(n) |
 | 384 | [Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/384_Shuffle_an_Array.py) | Fisher–Yates shuffle, O(n) and O(n) |

python/124_Binary_Tree_Maximum_Path_Sum.py

@@ -5,7 +5,8 @@
 #         self.left = None
 #         self.right = None
 
-class Solution(object):    
+
+class Solution(object):
     def __init__(self):
         self.result = -2147483647
 
@@ -28,4 +29,4 @@ def getNodeMaxValue(self, node):
         # if max left or right < 0 then return 0
         if ret > 0:
             return ret
-        return 0
+        return 0

python/249_Group_Shifted_Strings.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def groupStrings(self, strings):
+        """
+        :type strings: List[str]
+        :rtype: List[List[str]]
+        """
+        dic = {}
+        for s in strings:
+            key = self.hashCode(s)
+            try:
+                dic[key].append(s)
+            except KeyError:
+                dic[key] = [s]
+        return dic.values()
+
+    def hashCode(self, string):
+        if string is None or len(string) == 0:
+            return ''
+        if len(string) == 1:
+            return 'a'
+        step = abs(ord(string[0]) - ord('a'))
+        if step == 0:
+            return string
+        key = 'a'
+        for ch in string[1:]:
+            curr = ord(ch) - step
+            if ord(ch) - step < ord('a'):
+                curr += 26
+            key += chr(curr)
+        return key

python/359_Logger_Rate_Limiter.py

@@ -0,0 +1,60 @@
+# class Logger(object):
+
+#     def __init__(self):
+#         """
+#         Initialize your data structure here.
+#         """
+#         self.timestamps = {}
+
+#     def shouldPrintMessage(self, timestamp, message):
+#         """
+#         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.
+#         :type timestamp: int
+#         :type message: str
+#         :rtype: bool
+#         """
+#         if timestamp < self.timestamps.get(message, 0):
+#             return False
+#         self.timestamps[message] = timestamp + 10
+#         return True
+
+
+import heapq
+
+
+class Logger(object):
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.heap = []
+        self.cache = {}
+
+    def shouldPrintMessage(self, timestamp, message):
+        """
+        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.
+        :type timestamp: int
+        :type message: str
+        :rtype: bool
+        """
+        while len(self.heap):
+            if self.heap[0][0] <= timestamp:
+                temp = heapq.heappop(self.heap)
+                self.cache.pop(temp[1])
+            else:
+                break
+        if timestamp < self.cache.get(message, 0):
+            return False
+        self.cache[message] = timestamp + 10
+        heapq.heappush(self.heap, (timestamp + 10, message))
+        return True
+
+
+# Your Logger object will be instantiated and called as such:
+# obj = Logger()
+# param_1 = obj.shouldPrintMessage(timestamp,message)