class Node:
 """Doubly linked list node holding a cache entry (key, value)."""
 __slots__ = ("key", "value", "prev", "next")

 def __init__(self, key: int, value: int):
 self.key = key
 self.value = value
 self.prev = None
 self.next = None
class LRUCache:
 def __init__(self, capacity: int):
 if capacity <= 0:
 raise ValueError("Capacity must be positive")
 self.cap = capacity
 self.map: dict[int, Node] = {}

 # Dummy head/tail simplify edge case handling
 self.head = Node(0, 0) # Most recently used sentinel
 self.tail = Node(0, 0) # Least recently used sentinel
 self.head.next = self.tail
 self.tail.prev = self.head

 # ───────────────────────── Internal helpers ──────────────────────────
 def _add_to_front(self, node: Node) -> None:
 """Insert node right after head (MRU position)."""
 node.prev = self.head
 node.next = self.head.next
 self.head.next.prev = node
 self.head.next = node

 def _remove(self, node: Node) -> None:
 """Unlink node from list."""
 node.prev.next = node.next
 node.next.prev = node.prev

 # ───────────────────────── Public API ────────────────────────────────
 def get(self, key: int) -> int:
 """Return value if present; else 1. Marks entry as recently used."""
 if key not in self.map:
 return -1
 node = self.map[key]
 self._remove(node)
 self._add_to_front(node)
 return node.value

 def put(self, key: int, value: int) -> None:
 """
 Insert/update (key,value). 
 If capacity exceeded, evict the least recently used entry.
 """
 if key in self.map: # Update existing
 node = self.map[key]
 node.value = value
 self._remove(node)
 self._add_to_front(node)
 return

 # Insert new key
 node = Node(key, value)
 self.map[key] = node
 self._add_to_front(node)

 # Evict if over capacity
 if len(self.map) > self.cap:
 lru = self.tail.prev # Real LRU node
 self._remove(lru)
 del self.map[lru.key]

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

class LRUCache:
 def __init__(self, capacity: int):
 self.capacity = capacity
 self.cache = {} # key → Node
 # Dummy head/tail
 self.head = Node()
 self.tail = Node()
 self.head.next = self.tail
 self.tail.prev = self.head

 def _remove(self, node: Node):
 """Disconnect node from list."""
 prev, nxt = node.prev, node.next
 prev.next = nxt
 nxt.prev = prev

 def _add_to_front(self, node: Node):
 """Insert node right after head."""
 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:
 return -1
 node = self.cache[key]
 # Move to front
 self._remove(node)
 self._add_to_front(node)
 return node.value

 def put(self, key: int, value: int) -> None:
 if key in self.cache:
 # Update existing node and move it to front
 node = self.cache[key]
 node.value = value
 self._remove(node)
 self._add_to_front(node)
 else:
 # Insert new node
 new_node = Node(key, value)
 self.cache[key] = new_node
 self._add_to_front(new_node)
 # Evict LRU if over capacity
 if len(self.cache) > self.capacity:
 # Tail.prev is LRU
 lru = self.tail.prev
 self._remove(lru)
 del self.cache[lru.key]
（3）Gemini 2.5的編碼：
import collections
class Node:
 """Node for the doubly linked list."""
 def __init__(self, key, value):
 self.key = key
 self.value = value
 self.prev = None
 self.next = None

class LRUCache:

 def __init__(self, capacity: int):
 if capacity <= 0:
 raise ValueError("Capacity must be a positive integer")
 self.capacity = capacity
 self.cache = {} # Stores key -> Node mapping
 # Initialize sentinel nodes for the doubly linked list
 self.head = Node(0, 0) # Dummy head
 self.tail = Node(0, 0) # Dummy tail
 self.head.next = self.tail
 self.tail.prev = self.head

 def _remove_node(self, node: Node):
 """Removes an existing node from the linked list."""
 prev_node = node.prev
 next_node = node.next
 prev_node.next = next_node
 next_node.prev = prev_node
 # Optional: clear node pointers for garbage collection if needed
 # node.prev = None
 # node.next = None

 def _add_to_front(self, node: Node):
 """Adds a node right after the head (most recently used)."""
 node.prev = self.head
 node.next = self.head.next
 self.head.next.prev = node
 self.head.next = node

 def get(self, key: int) -> int:
 """
 Return the value of the key if it exists, otherwise return -1.
 Moves the accessed node to the front (most recently used).
 """
 if key in self.cache:
 node = self.cache[key]
 # Move accessed node to the front
 self._remove_node(node)
 self._add_to_front(node)
 return node.value
 else:
 return -1

 def put(self, key: int, value: int) -> None:
 """
 Update the value of the key if it exists, or insert the key-value pair.
 Moves the updated/inserted node to the front.
 Evicts the least recently used item if capacity is exceeded.
 """
 if key in self.cache:
 # Key exists, update value and move to front
 node = self.cache[key]
 node.value = value
 self._remove_node(node)
 self._add_to_front(node)
 else:
 # Key doesn't exist, insert new node
 new_node = Node(key, value)
 self.cache[key] = new_node
 self._add_to_front(new_node)

 # Check if capacity is exceeded
 if len(self.cache) > self.capacity:
 # Evict the least recently used item (node before tail)
 lru_node = self.tail.prev
 self._remove_node(lru_node)
 # Remove from cache as well
 del self.cache[lru_node.key]

# Example Usage:
try:
 cache = LRUCache(2)
 cache.put(1, 1) # cache is {1=1}
 print(f"Cache after put(1, 1): {[(k, v.value) for k, v in cache.cache.items()]}")
 cache.put(2, 2) # cache is {1=1, 2=2}
 print(f"Cache after put(2, 2): {[(k, v.value) for k, v in cache.cache.items()]}")
 print(f"get(1): {cache.get(1)}") # returns 1, cache is {2=2, 1=1} (1 is now MRU)
 print(f"Cache after get(1): {[(k, v.value) for k, v in cache.cache.items()]}") # Order in dict might not reflect LRU order
 cache.put(3, 3) # LRU key 2 was evicted, cache is {1=1, 3=3}
 print(f"Cache after put(3, 3): {[(k, v.value) for k, v in cache.cache.items()]}")
 print(f"get(2): {cache.get(2)}") # returns -1 (not found)
 cache.put(4, 4) # LRU key 1 was evicted, cache is {3=3, 4=4}
 print(f"Cache after put(4, 4): {[(k, v.value) for k, v in cache.cache.items()]}")
 print(f"get(1): {cache.get(1)}") # returns -1 (not found)
 print(f"get(3): {cache.get(3)}") # returns 3
 print(f"Cache after get(3): {[(k, v.value) for k, v in cache.cache.items()]}")
 print(f"get(4): {cache.get(4)}") # returns 4
 print(f"Cache after get(4): {[(k, v.value) for k, v in cache.cache.items()]}")

except ValueError as e:
 print(f"Error: {e}")

（Design a responsive personal portfolio webpage using HTML and CSS. The page should include the following sections:
1. Header: Display the user’s name and a brief tagline.
2. About Me: A short paragraph describing the user’s background and skills.
3. Projects: Showcase at least three projects with titles, descriptions, and links.
4. Contact: Provide contact information or a contact form.
Ensure the design is clean and mobile-friendly. Use semantic HTML elements and include basic CSS styling to enhance the visual appeal. Avoid using external CSS frameworks; write custom CSS for styling.
Implement the webpage in a single HTML file with embedded CSS.）