Coding interview answers you can say, explain, and justify

class Node:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None


class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}  # Map keys to nodes for O(1) lookup.

        self.head = Node()  # Most recently used items come after head.
        self.tail = Node()  # Least recently used items stay before tail.
        self.head.next = self.tail
        self.tail.prev = self.head

    def _remove(self, node: Node) -> None:
        # Unlink a node without scanning the list.
        node.prev.next = node.next
        node.next.prev = node.prev

    def _insert_at_front(self, node: Node) -> None:
        # Put the node first because it is now the most recently used.
        node.next = self.head.next
        node.prev = self.head
        self.head.next.prev = node
        self.head.next = node

    def get(self, key: int) -> int:
        if key not in self.cache:  # No node means this key is not cached.
            return -1

        node = self.cache[key]
        self._remove(node)
        self._insert_at_front(node)  # A read also refreshes recency.
        return node.value

    def put(self, key: int, value: int) -> None:
        if key in self.cache:  # Existing keys must leave their old list position.
            self._remove(self.cache[key])  # Remove the old position first.

        node = Node(key, value)
        self.cache[key] = node
        self._insert_at_front(node)

        if len(self.cache) > self.capacity:  # Evict only after exceeding capacity.
            least_recently_used = self.tail.prev  # Evict the oldest item.
            self._remove(least_recently_used)
            del self.cache[least_recently_used.key]