Add problem 146 - LRU Cache

Author: anirudhology

problems/design/__init__.py

@@ -0,0 +1,73 @@
+class LRUCache:
+
+    def __init__(self, capacity: int):
+        # Capacity of the cache
+        self.capacity = capacity
+        # Size or total number of entries in the cache
+        self.size = 0
+        # Dictionary to store key and entry nodes
+        self.entries = {}
+        # Head and tail of the list to store entries
+        self.head = None
+        self.tail = None
+
+    def get(self, key: int) -> int:
+        # If the cache already contains the key
+        if key in self.entries:
+            # Get the entry corresponding to the key
+            entry = self.entries[key]
+            # Delete node from the current position and add it to head
+            self.delete_entry(entry)
+            self.update_head(entry)
+            return entry.value
+        return -1
+
+    def put(self, key: int, value: int) -> None:
+        # If the key is already in the cache
+        if key in self.entries:
+            # Update the value corresponding to the node
+            entry = self.entries[key]
+            entry.value = value
+            # Delete node from its current position and update head
+            self.delete_entry(entry)
+            self.update_head(entry)
+        else:
+            # Create new entry
+            entry = self.Entry(key, value)
+            if self.size >= self.capacity:
+                self.entries.pop(self.tail.key)
+                self.delete_entry(self.tail)
+            self.update_head(entry)
+            self.entries[key] = entry
+            self.size += 1
+
+    def delete_entry(self, entry):
+        # If given entry is not the head
+        if entry.previous is not None:
+            entry.previous.next = entry.next
+        else:
+            self.head = entry.next
+        # If given entry is not the tail
+        if entry.next is not None:
+            entry.next.previous = entry.previous
+        else:
+            self.tail = entry.previous
+
+    def update_head(self, entry):
+        # Make entry as the new node
+        entry.next = self.head
+        entry.previous = None
+        if self.head is not None:
+            self.head.previous = entry
+        # Update the head
+        self.head = entry
+        # If there is only one node
+        if self.tail is None:
+            self.tail = entry
+
+    class Entry:
+        def __init__(self, key: int, value: int):
+            self.key = key
+            self.value = value
+            self.previous = None
+            self.next = None

problems/design/lru__cache.py

@@ -0,0 +1,77 @@
+import unittest
+
+from problems.design.lru__cache import LRUCache
+
+
+class LRUCacheTest(unittest.TestCase):
+
+    def test_get_put(self):
+        cache = LRUCache(2)
+
+        # Test cache miss
+        self.assertEqual(cache.get(1), -1)
+
+        # Test cache put and get
+        cache.put(1, 1)
+        cache.put(2, 2)
+        self.assertEqual(cache.get(1), 1)
+
+        # Test cache update
+        cache.put(3, 3)
+        self.assertEqual(cache.get(2), -1)  # 2 should be evicted
+        self.assertEqual(cache.get(3), 3)
+
+        # Test cache eviction
+        cache.put(4, 4)
+        self.assertEqual(cache.get(1), -1)  # 1 should be evicted
+        self.assertEqual(cache.get(3), 3)
+        self.assertEqual(cache.get(4), 4)
+
+    def test_lru_order(self):
+        cache = LRUCache(2)
+
+        # Add items
+        cache.put(1, 1)
+        cache.put(2, 2)
+
+        # Access 1 to make it most recently used
+        self.assertEqual(cache.get(1), 1)
+
+        # Add another item, which should evict 2
+        cache.put(3, 3)
+        self.assertEqual(cache.get(2), -1)
+        self.assertEqual(cache.get(1), 1)
+        self.assertEqual(cache.get(3), 3)
+
+    def test_update_existing_key(self):
+        cache = LRUCache(2)
+
+        # Add and update item
+        cache.put(1, 1)
+        cache.put(2, 2)
+        cache.put(1, 10)
+
+        # Ensure value is updated
+        self.assertEqual(cache.get(1), 10)
+
+        # Add another item, which should evict 2 as 1 was updated recently
+        cache.put(3, 3)
+        self.assertEqual(cache.get(2), -1)
+        self.assertEqual(cache.get(1), 10)
+        self.assertEqual(cache.get(3), 3)
+
+    def test_capacity(self):
+        cache = LRUCache(1)
+
+        # Add item and ensure it is accessible
+        cache.put(1, 1)
+        self.assertEqual(cache.get(1), 1)
+
+        # Add another item, which should evict the first one
+        cache.put(2, 2)
+        self.assertEqual(cache.get(1), -1)
+        self.assertEqual(cache.get(2), 2)
+
+
+if __name__ == '__main__':
+    unittest.main()