D. J.:

- Added the documentation of the leetcode problem 146
- Added the leetcode problem and solution for 933

Author: nobodyPerfecZ

README.md

@@ -255,6 +255,7 @@
 - [909 Snakes and Ladders](https://leetcode.com/problems/snakes-and-ladders/description/)
 - [918 Maximum Sum Circular Subarray](https://leetcode.com/problems/maximum-sum-circular-subarray/description/)
 - [931 Minimum Falling Path Sum](https://leetcode.com/problems/minimum-falling-path-sum/description/)
+- [933 Number of Recent Cells](https://leetcode.com/problems/number-of-recent-calls/description/)
 - [983 Minimum Cost for Tickets](https://leetcode.com/problems/minimum-cost-for-tickets/description/)
 - [1027 Longest Arithmetic Subsequence](https://leetcode.com/problems/longest-arithmetic-subsequence/description/)
 - [1035 Uncrossed Lines](https://leetcode.com/problems/uncrossed-lines/description/)

awesome_python_leetcode/_146_lru_cache.py

@@ -7,6 +7,20 @@ def __init__(self, key, val, prev=None, next=None):
 
 
 class LRUCache:
+    """
+    Design a data structure that follows the constraints of a Least Recently Used (LRU)
+    cache.
+
+    Implement the LRUCache class:
+    - LRUCache(int capacity) Initialize the LRU cache with positive size capacity.
+    - int get(int key) Return the value of the key if the key exists, otherwise return
+    -1.
+    - void put(int key, int value) Update the value of the key if the key exists.
+    Otherwise, add the key-value pair to the cache. If the number of keys exceeds the
+    capacity from this operation, evict the least recently used key.
+
+    The functions get and put must each run in O(1) average time complexity.
+    """
 
     def __init__(self, capacity: int):
         self.cap = capacity

awesome_python_leetcode/_933_number_of_recent_calls.py

@@ -0,0 +1,29 @@
+class RecentCounter:
+    """
+    You have a RecentCounter class which counts the number of recent requests within
+    a certain time frame.
+
+    Implement the RecentCounter class:
+    - RecentCounter() Initializes the counter with zero recent requests.
+    - int ping(int t) Adds a new request at time t, where t represents some time in
+    milliseconds, and returns the number of requests that has happened in the past
+    3000 milliseconds (including the new request). Specifically, return the number
+    of requests that have happened in the inclusive range [t - 3000, t].
+
+    It is guaranteed that every call to ping uses a strictly larger value of t than
+    the previous call.
+    """
+
+    def __init__(self):
+        self.pings = []
+
+    def ping(self, t: int) -> int:
+        # Remove all items that are smaller than t - 3000
+        while len(self.pings):
+            if self.pings[0] >= t - 3000:
+                break
+            self.pings.pop(0)
+
+        # Append new ping and return the length of the queue
+        self.pings.append(t)
+        return len(self.pings)

tests/test_933_number_of_recent_cells.py

@@ -0,0 +1,10 @@
+from awesome_python_leetcode._933_number_of_recent_calls import RecentCounter
+
+
+def test_func():
+    """Tests the solution of a LeetCode problem."""
+    counter = RecentCounter()
+    assert 1 == counter.ping(1)
+    assert 2 == counter.ping(100)
+    assert 3 == counter.ping(3001)
+    assert 3 == counter.ping(3002)