Low Level Design Question Bank
In 3 - My Interview Cookbook I mentioned a handful of "low level design" questions. To be fair, the type of low level design questions I'm referring to is a bit different to the "parking lot" design and others on hello interview's LLD section or questions that you'll find online.
It's worth reading the LLD section I wrote in 3 - My Interview Cookbook because that will give the background to how these interviews work, in my experience. This page is dedicated as a set of questions you can practice. At some point in the future, I might launch something like zyros.dev/learn (might not be a real URL, sorry) where I host these on an interactive editor in a more friendly way. That being said, these interviews are heavily in the direction of being focused on your ability to communicate.
A number of people I've met don't think these are worth practicing, and it's just ngmi if you can't make it. I don't really believe in that. Like anything, it's a skill you can build.
Disclaimer Basically all of these questions are generated by an LLM. Yep. Sorry. I can explain how I did this though. I have some other set of questions I have in mind (vague ideas, like ratelimiters) then described in detail what I want. I then had it generate 80 questions, and write 1-3 solutions and alternative solutions for each question. Finally, I went through and hand-picked these questions out of that bank as ones that I liked.

So, while it is heavily LLM-driven, I also human-reviewed it enough so it isn't slop. It's quite hard to find high quality sets of questions for this. Maybe at some point someone will consolidate it into patterns or something, but I dunno.
Questions
Question 1 - Skip List
- Difficulty: 9 / 10
- Approximate lines of code: 100 LoC
- Tags: data-structures
Description
A skip list is a probabilistic data structure that provides O(log n) expected time for search, insert, and delete operations, similar to a balanced BST, but using randomization instead of complex rebalancing logic. It consists of multiple levels of sorted linked lists stacked on top of each other. The bottom level (level 0) contains all elements. Each higher level contains a random subset of the elements below it, roughly half as many.
The key insight is the search pattern: start at the highest level and move right until you would overshoot, then drop down a level and repeat. This "express lane" approach lets you skip over many elements. The randomized level assignment (geometric distribution with p=0.5) ensures that on average, level k has half as many nodes as level k-1, giving O(log n) expected search time.
Part A: Structure and Search
{{fold}}{Problem: Part A}
Build the skip list structure with a sentinel header node and implement search(key). The header has forward pointers at all levels. To search, start at the highest level and traverse right while the next node's key is less than the target, then drop down.
sl = SkipList()
sl.insert(3)
sl.insert(6)
sl.insert(7)
sl.insert(9)
sl.insert(12)
# Possible structure (levels are random):
# Level 2: HEAD -----------------> 6 -----------------> 12 --> None
# Level 1: HEAD ------> 3 ------> 6 ------> 9 ------> 12 --> None
# Level 0: HEAD -> 3 -> 6 -> 7 -> 9 -> 12 --> None
# Search for 9:
# Level 2: HEAD -> 6 (6 < 9, advance) -> 12 (12 > 9, drop down)
# Level 1: 6 -> 9 (found!)
# Returns True
sl.search(9) # True
sl.search(8) # False - would stop between 7 and 9 at level 0{{/fold}}
Part B: Insert
{{fold}}{Problem: Part B}
To insert a key, first determine its random level using a geometric distribution (flip coins until tails). As you search for the insertion point, track which nodes at each level will need their forward pointers updated. After finding the position, splice in the new node at all levels up to its assigned level.
sl = SkipList(max_level=4, p=0.5)
# Before inserting 8:
# Level 1: HEAD -> 6 ---------> 12 --> None
# Level 0: HEAD -> 6 -> 9 -> 12 --> None
sl.insert(8) # Randomly gets level 1
# The "update" array tracks predecessors at each level:
# update[1] = HEAD (at level 1, HEAD.forward[1] = 6, but 6 < 8, so we advance...
# 6.forward[1] = 12, but 12 > 8, so update[1] = 6)
# update[0] = 6 (at level 0, we stop at 6 since 9 > 8)
# After insert:
# Level 1: HEAD -> 6 -> 8 ---------> 12 --> None
# Level 0: HEAD -> 6 -> 8 -> 9 -> 12 --> None
# New node's forward pointers:
# new_node.forward[0] = 9 (was update[0].forward[0])
# new_node.forward[1] = 12 (was update[1].forward[1]){{/fold}}
Part C: Delete
{{fold}}{Problem: Part C}
Find the node using the same traversal pattern, tracking update nodes at each level. Remove the node by updating each predecessor's forward pointer to skip over it. If the deleted node was at the highest level and that level is now empty, decrease the skip list's level.
sl = SkipList()
# Level 2: HEAD -> 6 -----------------> 19 --> None
# Level 1: HEAD -> 6 ------> 12 ------> 19 --> None
# Level 0: HEAD -> 6 -> 9 -> 12 -> 17 -> 19 --> None
sl.delete(12)
# update array: update[0] = node(9), update[1] = node(6)
# Unlink at each level where update[i].forward[i] == target
# After delete:
# Level 2: HEAD -> 6 -----------------> 19 --> None
# Level 1: HEAD -> 6 -----------------> 19 --> None
# Level 0: HEAD -> 6 -> 9 -> 17 ------> 19 --> None
sl.delete(19) # If level 2 becomes empty (HEAD.forward[2] == None),
# decrease sl.level to 1{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when you insert a duplicate key? (Either reject or update value)
- What if the new node's random level exceeds the current max level? (Extend update array, increase list level)
- What probability do you use for level generation? (p=0.5 is typical, gives log base 2 behavior)
- How do you shrink the level after deleting the only high-level node?
Common mistakes:
- Off-by-one errors in level iteration:
range(self.level, -1, -1)vsrange(self.level - 1, -1, -1) - Forgetting to update the skip list's
levelwhen highest levels become empty - Using uniform distribution instead of geometric for level generation (must use coin flips)
- Not initializing update array correctly for new levels above current max
- Infinite loop when search doesn't properly handle the sentinel's key
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 is a classic implementation with a sentinel node and geometric level distribution. Solution 2 extends this with generic key-value storage and update semantics. Solution 3 adds iterator support, __len__, __contains__, and range queries. The key difference is the feature set: basic operations vs. key-value mapping vs. full collection interface with range queries.
Core techniques: probabilistic data structure, geometric distribution, multi-level linked list, sentinel node.
Solution 1: Classic implementation with sentinel node Classic implementation with sentinel node. Uses geometric distribution for level generation. Clean separation of search traversal pattern used by all operations.
"""Skip List Implementation - Classic Approach with Sentinel Node."""
from dataclasses import dataclass, field
from typing import Optional
import random
@dataclass
class SkipNode:
"""Node in a skip list with multiple forward pointers."""
key: int
forward: list["SkipNode"] = field(default_factory=list)
@dataclass
class SkipList:
"""Probabilistic sorted data structure with O(log n) expected operations."""
max_level: int = 16
p: float = 0.5
level: int = 0
header: SkipNode = field(default_factory=lambda: SkipNode(key=-1))
def __post_init__(self) -> None:
self.header.forward = [None] * self.max_level
def _random_level(self) -> int:
"""Generate random level with geometric distribution."""
lvl = 0
while random.random() < self.p and lvl < self.max_level - 1:
lvl += 1
return lvl
def search(self, key: int) -> bool:
"""Return True if key exists in the skip list."""
current = self.header
for i in range(self.level, -1, -1):
while current.forward[i] and current.forward[i].key < key:
current = current.forward[i]
current = current.forward[0]
return current is not None and current.key == key
def insert(self, key: int) -> None:
"""Insert a key into the skip list."""
update = [None] * self.max_level
current = self.header
for i in range(self.level, -1, -1):
while current.forward[i] and current.forward[i].key < key:
current = current.forward[i]
update[i] = current
current = current.forward[0]
if current and current.key == key:
return # Key already exists
new_level = self._random_level()
if new_level > self.level:
for i in range(self.level + 1, new_level + 1):
update[i] = self.header
self.level = new_level
new_node = SkipNode(key=key, forward=[None] * (new_level + 1))
for i in range(new_level + 1):
new_node.forward[i] = update[i].forward[i]
update[i].forward[i] = new_node
def delete(self, key: int) -> bool:
"""Delete a key from the skip list. Returns True if deleted."""
update = [None] * self.max_level
current = self.header
for i in range(self.level, -1, -1):
while current.forward[i] and current.forward[i].key < key:
current = current.forward[i]
update[i] = current
current = current.forward[0]
if current is None or current.key != key:
return False
for i in range(self.level + 1):
if update[i].forward[i] != current:
break
update[i].forward[i] = current.forward[i]
while self.level > 0 and self.header.forward[self.level] is None:
self.level -= 1
return TrueSolution 2: Generic implementation with key-value storage Generic implementation with key-value storage. Supports updating existing keys and uses type parameters for flexibility.
"""Skip List Implementation - Generic with Value Storage."""
from dataclasses import dataclass, field
from typing import Generic, Optional, TypeVar
import random
K = TypeVar("K", bound=int)
V = TypeVar("V")
@dataclass
class Node(Generic[K, V]):
"""Skip list node storing key-value pair."""
key: K
value: V
forward: list[Optional["Node[K, V]"]] = field(default_factory=list)
def __post_init__(self) -> None:
if not self.forward:
self.forward = [None]
class SkipList(Generic[K, V]):
"""Skip list with key-value storage and configurable parameters."""
def __init__(self, max_level: int = 16, probability: float = 0.5) -> None:
self.max_level = max_level
self.probability = probability
self.level = 0
self.head: Node[K, V] = Node(key=None, value=None) # type: ignore
self.head.forward = [None] * max_level
def _random_level(self) -> int:
level = 0
while random.random() < self.probability and level < self.max_level - 1:
level += 1
return level
def _find_update_path(self, key: K) -> tuple[list[Node[K, V]], Optional[Node[K, V]]]:
"""Find path of nodes to update and the target node."""
update: list[Optional[Node[K, V]]] = [None] * self.max_level
current = self.head
for i in range(self.level, -1, -1):
while current.forward[i] and current.forward[i].key < key:
current = current.forward[i]
update[i] = current
return update, current.forward[0]
def get(self, key: K) -> Optional[V]:
"""Retrieve value for key, or None if not found."""
_, target = self._find_update_path(key)
if target and target.key == key:
return target.value
return None
def insert(self, key: K, value: V) -> None:
"""Insert or update a key-value pair."""
update, target = self._find_update_path(key)
if target and target.key == key:
target.value = value # Update existing
return
new_level = self._random_level()
if new_level > self.level:
for i in range(self.level + 1, new_level + 1):
update[i] = self.head
self.level = new_level
new_node: Node[K, V] = Node(key=key, value=value)
new_node.forward = [None] * (new_level + 1)
for i in range(new_level + 1):
new_node.forward[i] = update[i].forward[i]
update[i].forward[i] = new_node
def delete(self, key: K) -> bool:
"""Remove key from skip list. Returns True if removed."""
update, target = self._find_update_path(key)
if target is None or target.key != key:
return False
for i in range(self.level + 1):
if update[i].forward[i] != target:
break
update[i].forward[i] = target.forward[i]
while self.level > 0 and self.head.forward[self.level] is None:
self.level -= 1
return TrueSolution 3: Iterator support and range queries Extended implementation with iterator support, __len__, __contains__, and range queries. Tracks size explicitly for O(1) length.
"""Skip List Implementation - Iterator Support and Range Queries."""
from dataclasses import dataclass, field
from typing import Iterator, Optional
import random
@dataclass
class SkipNode:
"""Node with key and multi-level forward pointers."""
key: int
forward: list[Optional["SkipNode"]] = field(default_factory=list)
class SkipList:
"""Skip list with iteration and range query support."""
MAX_LEVEL = 16
P = 0.5
def __init__(self) -> None:
self.level = 0
self.head = SkipNode(key=float("-inf")) # type: ignore
self.head.forward = [None] * self.MAX_LEVEL
self._size = 0
def __len__(self) -> int:
return self._size
def __iter__(self) -> Iterator[int]:
"""Iterate through all keys in sorted order."""
node = self.head.forward[0]
while node:
yield node.key
node = node.forward[0]
def __contains__(self, key: int) -> bool:
return self.search(key)
def _random_level(self) -> int:
lvl = 0
while random.random() < self.P and lvl < self.MAX_LEVEL - 1:
lvl += 1
return lvl
def search(self, key: int) -> bool:
"""Check if key exists."""
node = self.head
for i in range(self.level, -1, -1):
while node.forward[i] and node.forward[i].key < key:
node = node.forward[i]
node = node.forward[0]
return node is not None and node.key == key
def insert(self, key: int) -> bool:
"""Insert key. Returns True if inserted, False if already exists."""
update = [self.head] * self.MAX_LEVEL
node = self.head
for i in range(self.level, -1, -1):
while node.forward[i] and node.forward[i].key < key:
node = node.forward[i]
update[i] = node
if node.forward[0] and node.forward[0].key == key:
return False
new_lvl = self._random_level()
if new_lvl > self.level:
self.level = new_lvl
new_node = SkipNode(key=key, forward=[None] * (new_lvl + 1))
for i in range(new_lvl + 1):
new_node.forward[i] = update[i].forward[i]
update[i].forward[i] = new_node
self._size += 1
return True
def delete(self, key: int) -> bool:
"""Delete key. Returns True if deleted."""
update = [self.head] * self.MAX_LEVEL
node = self.head
for i in range(self.level, -1, -1):
while node.forward[i] and node.forward[i].key < key:
node = node.forward[i]
update[i] = node
target = node.forward[0]
if target is None or target.key != key:
return False
for i in range(len(target.forward)):
update[i].forward[i] = target.forward[i]
while self.level > 0 and self.head.forward[self.level] is None:
self.level -= 1
self._size -= 1
return True
def range_query(self, low: int, high: int) -> list[int]:
"""Return all keys in [low, high] inclusive."""
result = []
node = self.head
for i in range(self.level, -1, -1):
while node.forward[i] and node.forward[i].key < low:
node = node.forward[i]
node = node.forward[0]
while node and node.key <= high:
result.append(node.key)
node = node.forward[0]
return result{{/fold}}
Question 2 - Request Coalescer
- Difficulty: 6 / 10
- Approximate lines of code: 80 LoC
- Tags: concurrency
Description
{{fold}}{Concurrency Cheat Sheet}
# asyncio basics
async def fetch(key):
return await some_io()
result = asyncio.run(main())
# asyncio.Future
future = asyncio.get_event_loop().create_future()
future.set_result(value)
future.set_exception(exc)
result = await future
# asyncio.Event
event = asyncio.Event()
event.set()
event.clear()
await event.wait()
# asyncio.Lock
lock = asyncio.Lock()
async with lock:
# critical section
# asyncio.gather
results = await asyncio.gather(coro1(), coro2(), return_exceptions=True)
# threading equivalents
from concurrent.futures import Future
future = Future()
future.set_result(value)
result = future.result() # blocks
import threading
lock = threading.Lock()
with lock:
# critical section{{/fold}}
A request coalescer deduplicates concurrent requests for the same resource. When multiple callers request the same key simultaneously, only one actual fetch occurs - all other callers wait for and share the result. This pattern is common in caching layers, API gateways, and database connection pools to prevent thundering herd problems where many identical requests overwhelm a backend service.
The core data structures are: (1) an in-flight map tracking keys currently being fetched, mapping each key to a Future/Event that waiters can await, and (2) a cache storing results with TTL. The critical insight is lock scope: you hold the lock only to check/update the in-flight map, never during the actual fetch.
Part A: Request Coalescing
{{fold}}{Problem: Part A}
Implement a get(key) method that fetches a resource. If a request for that key is already in-flight, wait for it instead of starting a new fetch.
coalescer = RequestCoalescer(fetch_func=fetch_from_db)
# Three concurrent requests for same key
results = await asyncio.gather(
coalescer.get("user:123"),
coalescer.get("user:123"),
coalescer.get("user:123"),
)
# fetch_from_db called exactly ONCE
# All three get the same result
# Internal state during fetch:
# _in_flight = {"user:123": <Future pending>}
# After completion:
# _in_flight = {}{{/fold}}
Part B: TTL Cache
{{fold}}{Problem: Part B}
Add caching with time-to-live. After a successful fetch, cache the result. Subsequent requests within TTL return the cached value without checking in-flight or fetching.
coalescer = RequestCoalescer(fetch_func=fetch, cache_ttl=60.0)
await coalescer.get("user:123") # Fetches, caches result
# _cache = {"user:123": CacheEntry(value=..., expires_at=now+60)}
await coalescer.get("user:123") # Cache hit, no fetch
time.sleep(61)
await coalescer.get("user:123") # Cache expired, fetches again{{/fold}}
Part C: Error Propagation
{{fold}}{Problem: Part C}
When a fetch fails, propagate the exception to ALL waiters, not just the initiator. Optionally cache errors (negative caching) to prevent repeated failing requests.
async def failing_fetch(key):
raise ConnectionError("Database down")
coalescer = RequestCoalescer(fetch_func=failing_fetch)
# All three waiters receive the same exception
results = await asyncio.gather(
coalescer.get("user:123"),
coalescer.get("user:123"),
coalescer.get("user:123"),
return_exceptions=True
)
# results = [ConnectionError, ConnectionError, ConnectionError]
# Only ONE actual fetch attempt was made{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if the first request times out but others are still waiting?
- How do you handle the race between cache expiry check and in-flight check?
- Should errors be cached? For how long?
- What if
cache_ttl=0- does coalescing still work?
Common mistakes:
- Holding the lock during the actual fetch (blocks all other keys)
- Not propagating exceptions to all waiters (only first caller sees error)
- Race condition: cache expires between check and in-flight registration
- Forgetting to remove key from in-flight map on error
- Using
time.time()instead oftime.monotonic()(clock can jump)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses asyncio with a lock and dictionary of Futures for coordination. Solution 2 replaces Futures with asyncio.Event plus a result holder dataclass. Solution 3 provides a thread-safe synchronous version using threading primitives and ThreadPoolExecutor. These vary in their coordination mechanism (Future vs Event vs threading Future) and async vs sync model. Core techniques: double-checked locking, Future/Event-based waiting, spawning background tasks for actual fetch work.
Solution 1: asyncio with locks and Futures Uses asyncio with a lock and dictionary of Futures. Double-checks cache after acquiring lock to handle races. Creates a Future for waiters and spawns a task to do the actual fetch.
"""
Request Coalescer - Solution 1: Basic asyncio with locks and cache.
Uses a simple dictionary-based approach with asyncio primitives.
"""
import asyncio
import time
from dataclasses import dataclass, field
from typing import Any, Awaitable, Callable, Dict, Optional
FetchFunc = Callable[[str], Awaitable[Any]]
@dataclass
class CacheEntry:
value: Any
expires_at: float
error: Optional[Exception] = None
@dataclass
class RequestCoalescer:
fetch_func: FetchFunc
cache_ttl: float = 5.0
_cache: Dict[str, CacheEntry] = field(default_factory=dict)
_in_flight: Dict[str, asyncio.Future] = field(default_factory=dict)
_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
async def get(self, key: str) -> Any:
# Check cache first (no lock needed for read)
if key in self._cache:
entry = self._cache[key]
if time.monotonic() < entry.expires_at:
if entry.error:
raise entry.error
return entry.value
del self._cache[key]
async with self._lock:
# Double-check cache after acquiring lock
if key in self._cache:
entry = self._cache[key]
if time.monotonic() < entry.expires_at:
if entry.error:
raise entry.error
return entry.value
del self._cache[key]
# Join existing in-flight request
if key in self._in_flight:
future = self._in_flight[key]
else:
# Start new request
future = asyncio.get_event_loop().create_future()
self._in_flight[key] = future
asyncio.create_task(self._do_fetch(key, future))
# Wait for result outside the lock
return await future
async def _do_fetch(self, key: str, future: asyncio.Future) -> None:
try:
result = await self.fetch_func(key)
self._cache[key] = CacheEntry(
value=result, expires_at=time.monotonic() + self.cache_ttl
)
future.set_result(result)
except Exception as e:
self._cache[key] = CacheEntry(
value=None, expires_at=time.monotonic() + self.cache_ttl, error=e
)
future.set_exception(e)
finally:
async with self._lock:
self._in_flight.pop(key, None)Solution 2: asyncio.Event for coordination Uses asyncio.Event instead of Future for coordination. The PendingRequest dataclass holds both the event and the result/error, with waiters checking the result after the event is set.
"""
Request Coalescer - Solution 2: Using asyncio.Event for coordination.
Demonstrates an alternative pattern using Events instead of Futures.
"""
import asyncio
import time
from dataclasses import dataclass, field
from typing import Any, Awaitable, Callable, Dict, Optional, Tuple
FetchFunc = Callable[[str], Awaitable[Any]]
@dataclass
class PendingRequest:
event: asyncio.Event
result: Any = None
error: Optional[Exception] = None
@dataclass
class CachedResult:
value: Any
error: Optional[Exception]
expires_at: float
def is_valid(self) -> bool:
return time.monotonic() < self.expires_at
def get_or_raise(self) -> Any:
if self.error:
raise self.error
return self.value
@dataclass
class RequestCoalescer:
fetch_func: FetchFunc
cache_ttl: float = 5.0
_cache: Dict[str, CachedResult] = field(default_factory=dict)
_pending: Dict[str, PendingRequest] = field(default_factory=dict)
_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
async def get(self, key: str) -> Any:
# Fast path: check cache
cached = self._cache.get(key)
if cached and cached.is_valid():
return cached.get_or_raise()
async with self._lock:
# Re-check after lock
cached = self._cache.get(key)
if cached and cached.is_valid():
return cached.get_or_raise()
# Clean stale cache
if cached:
del self._cache[key]
# Join or create pending request
if key in self._pending:
pending = self._pending[key]
else:
pending = PendingRequest(event=asyncio.Event())
self._pending[key] = pending
asyncio.create_task(self._execute_fetch(key, pending))
# Wait outside lock
await pending.event.wait()
if pending.error:
raise pending.error
return pending.result
async def _execute_fetch(self, key: str, pending: PendingRequest) -> None:
try:
result = await self.fetch_func(key)
pending.result = result
self._cache[key] = CachedResult(
value=result, error=None, expires_at=time.monotonic() + self.cache_ttl
)
except Exception as e:
pending.error = e
self._cache[key] = CachedResult(
value=None, error=e, expires_at=time.monotonic() + self.cache_ttl
)
finally:
pending.event.set()
async with self._lock:
self._pending.pop(key, None)Solution 3: Thread-safe synchronous version Thread-safe synchronous version using threading primitives and ThreadPoolExecutor. Suitable for non-async codebases. Uses concurrent.futures.Future for coordination between threads.
"""
Request Coalescer - Solution 3: Thread-safe version using threading primitives.
Suitable for synchronous code or mixed async/sync environments.
"""
import threading
import time
from concurrent.futures import Future, ThreadPoolExecutor
from dataclasses import dataclass, field
from typing import Any, Callable, Dict, Optional
FetchFunc = Callable[[str], Any]
@dataclass
class CacheEntry:
value: Any
error: Optional[Exception]
expires_at: float
@property
def is_expired(self) -> bool:
return time.monotonic() >= self.expires_at
@dataclass
class RequestCoalescer:
fetch_func: FetchFunc
cache_ttl: float = 5.0
max_workers: int = 4
_cache: Dict[str, CacheEntry] = field(default_factory=dict)
_in_flight: Dict[str, Future] = field(default_factory=dict)
_lock: threading.Lock = field(default_factory=threading.Lock)
_executor: ThreadPoolExecutor = field(init=False)
def __post_init__(self):
self._executor = ThreadPoolExecutor(max_workers=self.max_workers)
def get(self, key: str) -> Any:
# Check cache (acquire lock for thread safety)
with self._lock:
if key in self._cache:
entry = self._cache[key]
if not entry.is_expired:
if entry.error:
raise entry.error
return entry.value
del self._cache[key]
# Join existing request or start new one
if key in self._in_flight:
future = self._in_flight[key]
else:
future = Future()
self._in_flight[key] = future
self._executor.submit(self._do_fetch, key, future)
# Wait for result (outside lock to allow concurrency)
return future.result()
def _do_fetch(self, key: str, future: Future) -> None:
try:
result = self.fetch_func(key)
with self._lock:
self._cache[key] = CacheEntry(
value=result, error=None,
expires_at=time.monotonic() + self.cache_ttl
)
future.set_result(result)
except Exception as e:
with self._lock:
self._cache[key] = CacheEntry(
value=None, error=e,
expires_at=time.monotonic() + self.cache_ttl
)
future.set_exception(e)
finally:
with self._lock:
self._in_flight.pop(key, None)
def shutdown(self):
self._executor.shutdown(wait=True){{/fold}}
Question 3 - Lock-Free Queue
- Difficulty: 10 / 10
- Approximate lines of code: 80 LoC
- Tags: concurrency, data-structures
Description
{{fold}}{Concurrency Cheat Sheet}
This problem involves concurrency. Here is a cheat sheet of relevant Python syntax. You may not need all of these; this list is not exhaustive or suggestive for the problem.
# threading.Thread
t = threading.Thread(target=func, args=(arg1, arg2))
t.start()
t.join()
# threading.Lock
lock = threading.Lock()
lock.acquire()
lock.release()
with lock:
# critical section
# threading.Condition
cond = threading.Condition()
with cond:
cond.wait() # release lock, wait for notify
cond.notify() # wake one waiter
cond.notify_all() # wake all waiters
# threading.Semaphore
sem = threading.Semaphore(value=3)
sem.acquire()
sem.release()
# threading.Event
event = threading.Event()
event.set() # signal
event.clear() # reset
event.wait() # block until set
event.is_set() # check without blocking
# queue.Queue (thread-safe)
from queue import Queue
q = Queue()
q.put(item)
item = q.get() # blocks
item = q.get_nowait() # raises Empty if none
# Atomic operations concept
# Python's GIL makes single bytecode ops atomic
# For true atomics, use: threading.Lock or ctypes/cffi
# CAS pattern: if current == expected: current = new{{/fold}}
A lock-free queue allows multiple threads to enqueue and dequeue concurrently without using traditional locks (mutexes). Instead of blocking threads, it uses atomic compare-and-swap (CAS) operations: "if the value is still X, change it to Y; otherwise retry." This enables progress guarantees - at least one thread makes progress even if others stall.
The classic implementation is the Michael-Scott queue: a linked list with head and tail pointers. A sentinel (dummy) node simplifies empty-queue handling. The key insight is that CAS operations can fail when another thread modifies the data, so operations run in retry loops. The algorithm also requires "helping" - if one thread sees the tail pointer lagging behind, it advances the tail before proceeding.
Part A: Basic Queue
{{fold}}{Problem: Part A}
Implement a thread-safe queue with enqueue(value) and dequeue() using CAS. Use a linked list with a sentinel node (head and tail both point to it initially).
q = LockFreeQueue()
# Initial state: head -> [sentinel] <- tail
# next=None
q.enqueue(1)
# State: head -> [sentinel] -> [1] <- tail
# next=[1] next=None
q.enqueue(2)
# State: head -> [sentinel] -> [1] -> [2] <- tail
val = q.dequeue() # Returns 1
# State: head -> [1] -> [2] <- tail
# (old sentinel removed, [1] is new sentinel, value returned was [1]'s value)Key operations:
- Enqueue: CAS the tail node's
nextpointer from None to new node, then CAS tail to point to new node - Dequeue: CAS head pointer from sentinel to sentinel.next, return the value from the new sentinel
{{/fold}}
Part B: The ABA Problem
{{fold}}{Problem: Part B}
A subtle bug: if pointer A changes to B then back to A, a CAS sees "still A" but the underlying data changed. Example: Thread 1 reads head=NodeA, gets preempted. Thread 2 dequeues NodeA, dequeues NodeB, re-enqueues a recycled NodeA. Thread 1 resumes, CAS succeeds (head is "still" NodeA), but the queue structure is corrupted.
Solve with tagged pointers (version stamps): pair each pointer with an incrementing counter. CAS checks both pointer AND stamp - even if pointer recycles, the stamp won't match.
@dataclass
class StampedRef:
ref: Node
stamp: int # Increments on every modification
# CAS now checks: (ref == expected_ref AND stamp == expected_stamp)
# Even if ref is recycled, stamp won't match the old value{{/fold}}
Part C: Memory Reclamation
{{fold}}{Problem: Part C}
In a real system, you can't free dequeued nodes immediately - another thread might still be reading them. Options:
- Hazard pointers: Each thread publishes pointers it's currently accessing; don't free those
- Epoch-based reclamation: Track which "epoch" each thread is in; only free nodes from old epochs when all threads have advanced
- Reference counting: Atomic reference counts (but adds overhead to every operation)
# Hazard pointer sketch:
class ThreadLocal:
hazard_pointer: Node = None # "I'm currently looking at this node"
def dequeue():
while True:
head = self.head
# Publish hazard pointer BEFORE dereferencing
thread_local.hazard_pointer = head
if head != self.head:
continue # head changed, retry
# Now safe to read head.next
...{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if dequeue is called on an empty queue? (Return None, don't block)
- Why do you need a sentinel node? (Simplifies empty case - head and tail always point to valid nodes)
- What if enqueue CAS succeeds but advancing tail fails? (Another thread must help advance it)
- How do you know if the queue is empty? (head == tail AND head.next is None)
Common mistakes:
- Forgetting the sentinel node (leads to null pointer edge cases)
- Missing the "helping" mechanism in enqueue (if tail.next isn't None, advance tail first)
- Wrong CAS order: must CAS next pointer BEFORE advancing tail
- Using raw pointers without version stamps (ABA vulnerability)
- Not handling the case where head.next is null in dequeue (empty queue)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 implements the classic Michael-Scott queue using a linked list with stamped references to solve the ABA problem. Solution 2 uses an array-based bounded circular buffer with sequence numbers for ABA prevention, offering better cache locality. Solution 3 is a wait-free SPSC (Single-Producer Single-Consumer) queue that eliminates CAS retry loops by restricting to one producer and one consumer. These vary in their concurrency model (MPMC vs SPSC) and data structure (linked list vs array). Core techniques: compare-and-swap (CAS), stamped/tagged pointers, sequence numbers, memory barriers.
Solution 1: Michael-Scott queue with stamped references Michael-Scott queue with stamped references to solve ABA. Uses a lock to simulate atomic CAS operations (real implementations use hardware atomics). Includes the full "helping" mechanism where enqueue advances a lagging tail pointer.
"""
Lock-Free Queue - Solution 1: Michael-Scott Queue with Tagged Pointers
Uses stamped references to solve the ABA problem.
"""
from __future__ import annotations
from dataclasses import dataclass
from typing import Generic, TypeVar, Optional
import threading
T = TypeVar("T")
@dataclass
class StampedRef(Generic[T]):
"""Stamped reference to solve ABA problem."""
ref: Optional[Node[T]]
stamp: int = 0
@dataclass
class Node(Generic[T]):
value: Optional[T]
next: StampedRef[T] = None # type: ignore
def __post_init__(self) -> None:
if self.next is None:
self.next = StampedRef(None, 0)
class LockFreeQueue(Generic[T]):
"""Lock-free queue using CAS with stamped references."""
def __init__(self) -> None:
sentinel = Node[T](None)
self._head = StampedRef(sentinel, 0)
self._tail = StampedRef(sentinel, 0)
self._lock = threading.Lock() # Simulates CAS atomicity
def _cas(self, target: StampedRef[T], expected_ref: Optional[Node[T]],
expected_stamp: int, new_ref: Optional[Node[T]], new_stamp: int) -> bool:
"""Simulated compare-and-swap with stamp check."""
with self._lock:
if target.ref is expected_ref and target.stamp == expected_stamp:
target.ref = new_ref
target.stamp = new_stamp
return True
return False
def enqueue(self, value: T) -> None:
"""Add item to the back of the queue."""
new_node = Node(value)
while True:
tail = self._tail
tail_node = tail.ref
next_ref = tail_node.next
if tail.ref is self._tail.ref and tail.stamp == self._tail.stamp:
if next_ref.ref is None:
if self._cas(tail_node.next, None, next_ref.stamp,
new_node, next_ref.stamp + 1):
self._cas(self._tail, tail_node, tail.stamp,
new_node, tail.stamp + 1)
return
else:
self._cas(self._tail, tail_node, tail.stamp,
next_ref.ref, tail.stamp + 1)
def dequeue(self) -> Optional[T]:
"""Remove and return item from front. Returns None if empty."""
while True:
head = self._head
tail = self._tail
head_node = head.ref
next_ref = head_node.next
if head.ref is self._head.ref and head.stamp == self._head.stamp:
if head_node is tail.ref:
if next_ref.ref is None:
return None
self._cas(self._tail, tail.ref, tail.stamp,
next_ref.ref, tail.stamp + 1)
else:
value = next_ref.ref.value
if self._cas(self._head, head_node, head.stamp,
next_ref.ref, head.stamp + 1):
return valueSolution 2: Array-based bounded queue Array-based bounded queue using a circular buffer with atomic indices. Each slot has a sequence number for ABA prevention. The sequence discipline: a slot is ready for enqueue when seq == tail, ready for dequeue when seq == head + 1. More cache-friendly than linked lists.
"""
Lock-Free Queue - Solution 2: Array-based Bounded Queue with CAS
Fixed-size circular buffer using atomic indices.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Generic, TypeVar, Optional
import threading
T = TypeVar("T")
@dataclass
class AtomicInt:
"""Simulated atomic integer with CAS operation."""
_value: int = 0
_lock: threading.Lock = field(default_factory=threading.Lock)
def get(self) -> int:
with self._lock:
return self._value
def cas(self, expected: int, new: int) -> bool:
with self._lock:
if self._value == expected:
self._value = new
return True
return False
@dataclass
class Slot(Generic[T]):
"""Slot with sequence number for ABA prevention."""
sequence: AtomicInt
value: Optional[T] = None
class BoundedLockFreeQueue(Generic[T]):
"""Bounded lock-free queue using array with sequences."""
def __init__(self, capacity: int = 64) -> None:
self._capacity = capacity
self._mask = capacity - 1
assert capacity > 0 and (capacity & self._mask) == 0, "Must be power of 2"
self._slots: list[Slot[T]] = [
Slot(AtomicInt(i)) for i in range(capacity)
]
self._head = AtomicInt(0)
self._tail = AtomicInt(0)
def enqueue(self, value: T) -> bool:
"""Add item. Returns False if queue is full."""
while True:
tail = self._tail.get()
slot = self._slots[tail & self._mask]
seq = slot.sequence.get()
diff = seq - tail
if diff == 0:
if self._tail.cas(tail, tail + 1):
slot.value = value
slot.sequence.cas(seq, seq + 1)
return True
elif diff < 0:
return False # Queue is full
def dequeue(self) -> Optional[T]:
"""Remove and return item. Returns None if empty."""
while True:
head = self._head.get()
slot = self._slots[head & self._mask]
seq = slot.sequence.get()
diff = seq - (head + 1)
if diff == 0:
if self._head.cas(head, head + 1):
value = slot.value
slot.sequence.cas(seq, seq + self._capacity - 1)
return value
elif diff < 0:
return None # Queue is emptySolution 3: Wait-free SPSC queue Wait-free Single-Producer Single-Consumer (SPSC) queue. When only one thread enqueues and one dequeues, the algorithm simplifies dramatically - no CAS loops needed, just atomic loads and stores with cached indices for performance. Demonstrates the power of restricting the concurrency model.
"""
Lock-Free Queue - Solution 3: Wait-Free SPSC Queue
Single-Producer Single-Consumer queue - simpler but restricted use case.
Demonstrates progression from MPMC to SPSC optimization.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Generic, TypeVar, Optional
import threading
T = TypeVar("T")
@dataclass
class AtomicRef(Generic[T]):
"""Simulated atomic reference for memory ordering."""
_value: T
_lock: threading.Lock = field(default_factory=threading.Lock)
def load(self) -> T:
with self._lock:
return self._value
def store(self, value: T) -> None:
with self._lock:
self._value = value
class SPSCQueue(Generic[T]):
"""Wait-free single-producer single-consumer queue."""
def __init__(self, capacity: int = 64) -> None:
assert capacity > 0 and (capacity & (capacity - 1)) == 0
self._capacity = capacity
self._mask = capacity - 1
self._buffer: list[Optional[T]] = [None] * capacity
self._head = AtomicRef(0) # Consumer reads this
self._tail = AtomicRef(0) # Producer writes this
self._cached_head = 0 # Producer's cached view
self._cached_tail = 0 # Consumer's cached view
def enqueue(self, value: T) -> bool:
"""Producer adds item. Returns False if full."""
tail = self._tail.load()
next_tail = (tail + 1) & self._mask
if next_tail == self._cached_head:
self._cached_head = self._head.load()
if next_tail == self._cached_head:
return False
self._buffer[tail] = value
self._tail.store(next_tail)
return True
def dequeue(self) -> Optional[T]:
"""Consumer removes item. Returns None if empty."""
head = self._head.load()
if head == self._cached_tail:
self._cached_tail = self._tail.load()
if head == self._cached_tail:
return None
value = self._buffer[head]
self._buffer[head] = None
self._head.store((head + 1) & self._mask)
return value
def is_empty(self) -> bool:
return self._head.load() == self._tail.load(){{/fold}}
Question 4 - Count-Min Sketch
- Difficulty: 8 / 10
- Approximate lines of code: 70 LoC
- Tags: probabilistic, data-structures
Description
A Count-Min Sketch is a probabilistic data structure for estimating the frequency of items in a data stream using sublinear space. Unlike a hash map that stores exact counts, a CMS uses a 2D array of counters with multiple hash functions. Each item hashes to one position per row, and all those positions get incremented. To query, you take the minimum across all rows - this gives an estimate that may overcount (due to hash collisions) but never undercounts.
The structure uses O(w * d) space where w is width and d is depth (number of hash functions). With proper sizing, you get: with probability >= 1 - delta, the estimate is at most true_count + epsilon * N, where N is total items seen. The formulas are w = ceil(e/epsilon) and d = ceil(ln(1/delta)).
Part A: Basic Structure
{{fold}}{Problem: Part A}
Implement a Count-Min Sketch with increment(item, count=1) and query(item) methods.
cms = CountMinSketch(width=100, depth=5)
# Increment counts
cms.increment("apple", 10)
cms.increment("banana", 5)
cms.increment("apple", 3)
# Query returns minimum across all rows
cms.query("apple") # >= 13 (exact or overestimate)
cms.query("banana") # >= 5
cms.query("cherry") # >= 0 (never seen, but may have collisions)Internal state (width=5, depth=3 for illustration):
After adding "apple" 13 times and "banana" 5 times:
Row 0: [0, 13, 5, 0, 0] <- "apple" hashes to col 1, "banana" to col 2
Row 1: [5, 0, 13, 0, 0] <- different hash: apple->2, banana->0
Row 2: [0, 13, 0, 5, 0] <- apple->1, banana->3
query("apple") = min(13, 13, 13) = 13
query("banana") = min(5, 5, 5) = 5{{/fold}}
Part B: Optimal Parameters
{{fold}}{Problem: Part B}
Implement a method to calculate optimal width and depth given desired error bounds.
epsilon: error factor (estimate <= true + epsilon * N)delta: failure probability (confidence = 1 - delta)
# For 1% error with 99% confidence:
width, depth = CountMinSketch.optimal_params(epsilon=0.01, delta=0.01)
# width = ceil(e / 0.01) = 272
# depth = ceil(ln(1/0.01)) = 5{{/fold}}
Part C: Merge and Analysis
{{fold}}{Problem: Part C}
Add support for merging two sketches (useful for distributed counting) and explain the no-undercount guarantee.
cms1 = CountMinSketch(width=100, depth=5)
cms2 = CountMinSketch(width=100, depth=5)
cms1.add("apple", 1000)
cms2.add("apple", 500)
cms1.merge(cms2) # Element-wise max of all counters
cms1.query("apple") # >= 1000 (from cms1's counters)Why no undercount? Because query() takes the minimum. Even if some positions have extra counts from collisions, the true item was incremented at all positions, so at least one position has only that item's count (in the ideal case).
{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when querying an item never added? (Returns 0 or collision noise)
- Why use min() instead of max() or average?
- How would you handle deletions? (You cannot - counts only go up)
- What's the space complexity vs. a hash map?
Common mistakes:
- Using max() instead of min() for query (defeats the purpose)
- Using a single hash function (no way to reduce collision error)
- Using Python's built-in
hash()which is non-deterministic across runs - Forgetting that the sketch can only overestimate, never underestimate
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 is a classic implementation using MD5 hashing with seeded rows. Solution 2 uses a universal hash family h(x) = ((a*x + b) mod p) mod w for better theoretical collision bounds. Solution 3 implements the conservative update variant that reduces overestimation by only incrementing counters up to min + count. These vary in their hash function choice and update strategy. Core techniques: multiple hash functions, 2D counter array, min-query for estimates.
Solution 1: Classic MD5 hashing Classic implementation using MD5 hashing with seed per row. Tracks total count for error bound calculation. Simple and readable.
"""
Count-Min Sketch - Solution 1: Classic Implementation
A probabilistic data structure for frequency estimation.
Uses multiple hash functions to provide approximate counts with
guaranteed no underestimation.
"""
from dataclasses import dataclass, field
from typing import List
import hashlib
@dataclass
class CountMinSketch:
"""
Count-Min Sketch for approximate frequency counting.
Args:
width: Number of counters per row (controls accuracy)
depth: Number of hash functions/rows (controls confidence)
"""
width: int
depth: int
table: List[List[int]] = field(init=False)
total_count: int = field(default=0, init=False)
def __post_init__(self) -> None:
self.table = [[0] * self.width for _ in range(self.depth)]
def _hash(self, item: str, seed: int) -> int:
"""Generate a hash for the item with a given seed."""
data = f"{seed}:{item}".encode("utf-8")
digest = hashlib.md5(data).hexdigest()
return int(digest, 16) % self.width
def increment(self, item: str, count: int = 1) -> None:
"""Add an item to the sketch with optional count."""
for row in range(self.depth):
col = self._hash(item, row)
self.table[row][col] += count
self.total_count += count
def query(self, item: str) -> int:
"""
Estimate the count of an item.
Returns the minimum across all hash positions.
May overestimate but never underestimates.
"""
min_count = float("inf")
for row in range(self.depth):
col = self._hash(item, row)
min_count = min(min_count, self.table[row][col])
return int(min_count)
def error_bound(self, epsilon: float = None) -> float:
"""
Expected error is at most (epsilon * total_count).
epsilon = e / width, where e is Euler's number.
"""
import math
eps = math.e / self.width
return eps * self.total_countSolution 2: Universal hash family Uses universal hash family h(x) = ((a*x + b) mod p) mod w for better theoretical guarantees. Provides detailed error analysis with epsilon, delta, and confidence calculations.
"""
Count-Min Sketch - Solution 2: Using Universal Hashing
This version uses a family of universal hash functions (ax + b mod p mod w)
for better theoretical guarantees on collision probability.
"""
from dataclasses import dataclass, field
from typing import List, Hashable
import random
@dataclass
class UniversalHashFamily:
"""Universal hash function family: h(x) = ((a*x + b) mod p) mod width."""
width: int
depth: int
prime: int = field(default=2**61 - 1, init=False) # Large Mersenne prime
a_values: List[int] = field(init=False)
b_values: List[int] = field(init=False)
def __post_init__(self) -> None:
random.seed(42) # Deterministic for reproducibility
self.a_values = [random.randint(1, self.prime - 1) for _ in range(self.depth)]
self.b_values = [random.randint(0, self.prime - 1) for _ in range(self.depth)]
def hash(self, item: Hashable, row: int) -> int:
x = hash(item)
return ((self.a_values[row] * x + self.b_values[row]) % self.prime) % self.width
@dataclass
class CountMinSketch:
"""
Count-Min Sketch with universal hashing.
Error bounds:
- With probability >= 1 - delta, estimate <= true_count + epsilon * N
- epsilon = e / width
- delta = e^(-depth)
"""
width: int
depth: int
hash_family: UniversalHashFamily = field(init=False)
table: List[List[int]] = field(init=False)
_total: int = field(default=0, init=False)
def __post_init__(self) -> None:
self.table = [[0] * self.width for _ in range(self.depth)]
self.hash_family = UniversalHashFamily(self.width, self.depth)
def add(self, item: Hashable, count: int = 1) -> None:
"""Increment the count for an item."""
for row in range(self.depth):
col = self.hash_family.hash(item, row)
self.table[row][col] += count
self._total += count
def estimate(self, item: Hashable) -> int:
"""Return the estimated count (minimum across all rows)."""
return min(
self.table[row][self.hash_family.hash(item, row)]
for row in range(self.depth)
)
@property
def total_count(self) -> int:
return self._total
def theoretical_error(self) -> dict:
"""Return theoretical error analysis."""
import math
epsilon = math.e / self.width
delta = math.exp(-self.depth)
return {
"epsilon": epsilon,
"delta": delta,
"max_overestimate": epsilon * self._total,
"confidence": 1 - delta,
}Solution 3: Conservative update variant Conservative update variant that reduces overestimation. Only increments counters up to min + count rather than blindly adding to all. Includes merge and optimal parameter calculation.
"""
Count-Min Sketch - Solution 3: Conservative Update Variant
Conservative update reduces overestimation by only incrementing
counters up to the current minimum + count, rather than always adding.
"""
from dataclasses import dataclass, field
from typing import List, Tuple
import hashlib
@dataclass
class ConservativeCountMinSketch:
"""
Count-Min Sketch with conservative update optimization.
Conservative update: instead of blindly incrementing all counters,
only increment up to max(current_estimate, new_count).
This reduces overestimation while maintaining the no-undercount guarantee.
"""
width: int
depth: int
seed: int = 0
table: List[List[int]] = field(init=False)
_n: int = field(default=0, init=False)
def __post_init__(self) -> None:
self.table = [[0] * self.width for _ in range(self.depth)]
def _hash(self, item: str, row: int) -> int:
"""Generate hash for item at given row."""
data = f"{self.seed + row}:{item}".encode("utf-8")
digest = hashlib.sha256(data).hexdigest()
return int(digest[:16], 16) % self.width
def _get_positions(self, item: str) -> List[Tuple[int, int]]:
"""Get (row, col) positions for an item."""
return [(row, self._hash(item, row)) for row in range(self.depth)]
def add(self, item: str, count: int = 1) -> None:
"""Add item with conservative update."""
positions = self._get_positions(item)
# Get current minimum estimate
current_counts = [self.table[r][c] for r, c in positions]
min_count = min(current_counts)
# Conservative update: set all positions to max of their current value
# and (min_count + count)
new_target = min_count + count
for r, c in positions:
self.table[r][c] = max(self.table[r][c], new_target)
self._n += count
def query(self, item: str) -> int:
"""Estimate count for item."""
positions = self._get_positions(item)
return min(self.table[r][c] for r, c in positions)
def merge(self, other: "ConservativeCountMinSketch") -> None:
"""Merge another sketch into this one (element-wise max)."""
assert self.width == other.width and self.depth == other.depth
for r in range(self.depth):
for c in range(self.width):
self.table[r][c] = max(self.table[r][c], other.table[r][c])
self._n += other._n
@staticmethod
def optimal_params(epsilon: float, delta: float) -> Tuple[int, int]:
"""Calculate optimal width and depth for desired error bounds."""
import math
width = int(math.ceil(math.e / epsilon))
depth = int(math.ceil(math.log(1 / delta)))
return width, depth{{/fold}}
Question 5 - Double-Entry Ledger
- Difficulty: 4 / 10
- Approximate lines of code: 90 LoC
- Tags: storage
Description
Double-entry bookkeeping is the foundation of modern accounting. Every transaction affects at least two accounts: one is debited, one is credited, and the total debits must equal total credits. This invariant makes errors detectable - if your books don't balance, something is wrong. Assets and expenses have "debit normal" balances (debits increase them), while liabilities, equity, and revenue have "credit normal" balances (credits increase them).
The core data structures are: accounts (with names and types), transactions (with descriptions and multiple entries), and a ledger that validates and stores everything. A trial balance report sums all account balances to verify the books still balance. Use Decimal for money - floating point arithmetic will eventually produce rounding errors that break the balance invariant.
Part A: Accounts and Transactions
{{fold}}{Problem: Part A}
Implement account creation and transaction posting. Each transaction has multiple entries, and debits must equal credits before the transaction can be recorded.
ledger = Ledger()
ledger.create_account("Cash", AccountType.ASSET)
ledger.create_account("Revenue", AccountType.REVENUE)
# Record a sale: debit Cash (asset increases), credit Revenue
txn = Transaction("Cash sale", entries=[
Entry("Cash", 100.00, is_debit=True),
Entry("Revenue", 100.00, is_debit=False)
])
ledger.record_transaction(txn)
# Internal state:
# accounts = {"Cash": ASSET, "Revenue": REVENUE}
# transactions = [Transaction("Cash sale", [...])]
ledger.get_balance("Cash") # 100.00 (debit balance)
ledger.get_balance("Revenue") # -100.00 (credit balance, shown as negative)
# Unbalanced transaction should fail:
bad_txn = Transaction("Bad", [Entry("Cash", 50, is_debit=True)])
ledger.record_transaction(bad_txn) # Raises ValueError!{{/fold}}
Part B: Trial Balance
{{fold}}{Problem: Part B}
Generate a trial balance report that lists all accounts with their debit and credit balances. Total debits must equal total credits.
ledger.post_entry("Cash", "Revenue", 500.0, "Cash sale")
ledger.post_entry("Accounts Receivable", "Revenue", 300.0, "Credit sale")
ledger.post_entry("Rent Expense", "Cash", 200.0, "Paid rent")
balances, is_balanced = ledger.trial_balance()
# balances:
# Cash: DR 500, CR 200 -> Net DR 300
# Revenue: DR 0, CR 800 -> Net CR 800
# Accounts Receivable: DR 300, CR 0 -> Net DR 300
# Rent Expense: DR 200, CR 0 -> Net DR 200
#
# Total DR: 300 + 300 + 200 = 800
# Total CR: 800
# is_balanced = True{{/fold}}
Part C: Multi-Leg Transactions
{{fold}}{Problem: Part C}
Support transactions with multiple debits and credits (not just pairs). Example: selling inventory involves four entries - debit Cash (receive payment), credit Revenue (recognize sale), debit COGS (expense the cost), credit Inventory (reduce stock).
gl = GeneralLedger()
for acct in ["Cash", "Inventory", "Revenue", "COGS"]:
gl.open_account(acct)
sale = Transaction("Sold inventory")
sale.add_debit("Cash", Decimal("150.00")) # Receive $150
sale.add_credit("Revenue", Decimal("150.00")) # Recognize revenue
sale.add_debit("COGS", Decimal("80.00")) # Cost of goods sold
sale.add_credit("Inventory", Decimal("80.00")) # Reduce inventory
gl.commit(sale)
# Total debits: 150 + 80 = 230
# Total credits: 150 + 80 = 230
# Transaction is balanced and committed{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if you try to post to a non-existent account?
- How do you handle negative amounts in entries?
- Can the same account appear multiple times in one transaction?
- How do you display credit-normal accounts (negative debit balance)?
Common mistakes:
- Using
floatinstead ofDecimalfor monetary amounts - Confusing debit/credit signs (debits are not always positive)
- Not validating that accounts exist before posting
- Forgetting that credit-normal accounts show as "negative" debit balances
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses a simple dictionary-based approach where balances are calculated on-demand by iterating through all transactions (O(n) per query). Solution 2 takes an account-centric design where each account maintains running debit/credit totals for O(1) balance queries. Solution 3 supports multi-leg transactions with arbitrary numbers of debits and credits, using Decimal for precise money handling. These vary in their approach to balance tracking and transaction complexity: Solution 1 prioritizes simplicity, Solution 2 optimizes for read performance, and Solution 3 handles real-world accounting scenarios. Core techniques: dictionary storage, running balance tracking, Decimal arithmetic with ROUND_HALF_UP, transaction validation.
Solution 1: Simple Dictionary-Based Approach Simple dictionary-based approach. Stores accounts as a dict mapping name to type, transactions as a list. Calculates balances by iterating through all transactions - O(n) per balance query. Clean and correct but not optimized for frequent queries.
"""
Double-Entry Ledger - Solution 1: Simple Dictionary-Based Approach
Uses dictionaries to track accounts and a list for transactions.
"""
from dataclasses import dataclass, field
from typing import Dict, List, Tuple
from enum import Enum
class AccountType(Enum):
ASSET = "asset"
LIABILITY = "liability"
EQUITY = "equity"
REVENUE = "revenue"
EXPENSE = "expense"
@dataclass
class Entry:
account: str
amount: float
is_debit: bool
@dataclass
class Transaction:
description: str
entries: List[Entry] = field(default_factory=list)
def is_balanced(self) -> bool:
debits = sum(e.amount for e in self.entries if e.is_debit)
credits = sum(e.amount for e in self.entries if not e.is_debit)
return abs(debits - credits) < 0.001
class Ledger:
def __init__(self) -> None:
self.accounts: Dict[str, AccountType] = {}
self.transactions: List[Transaction] = []
def create_account(self, name: str, account_type: AccountType) -> None:
self.accounts[name] = account_type
def record_transaction(self, transaction: Transaction) -> None:
if not transaction.is_balanced():
raise ValueError("Transaction must balance: debits must equal credits")
for entry in transaction.entries:
if entry.account not in self.accounts:
raise ValueError(f"Account '{entry.account}' does not exist")
self.transactions.append(transaction)
def get_balance(self, account_name: str) -> float:
if account_name not in self.accounts:
raise ValueError(f"Account '{account_name}' does not exist")
balance = 0.0
for txn in self.transactions:
for entry in txn.entries:
if entry.account == account_name:
if entry.is_debit:
balance += entry.amount
else:
balance -= entry.amount
return balance
def trial_balance(self) -> Tuple[Dict[str, float], float, float]:
balances: Dict[str, float] = {}
total_debits, total_credits = 0.0, 0.0
for account in self.accounts:
bal = self.get_balance(account)
balances[account] = bal
if bal >= 0:
total_debits += bal
else:
total_credits += abs(bal)
return balances, total_debits, total_creditsSolution 2: Account-Centric with Balance Tracking Account-centric design with running balance tracking. Each Account object maintains separate debit and credit totals, enabling O(1) balance queries. Transactions are simpler (just debit account, credit account, amount) since each entry affects exactly two accounts.
"""
Double-Entry Ledger - Solution 2: Account-Centric with Balance Tracking
Each account maintains its own running balance for O(1) balance queries.
"""
from dataclasses import dataclass, field
from typing import Dict, List, Tuple
from datetime import datetime
@dataclass
class LedgerEntry:
debit_account: str
credit_account: str
amount: float
description: str
timestamp: datetime = field(default_factory=datetime.now)
@dataclass
class Account:
name: str
debit_balance: float = 0.0
credit_balance: float = 0.0
def debit(self, amount: float) -> None:
self.debit_balance += amount
def credit(self, amount: float) -> None:
self.credit_balance += amount
@property
def net_balance(self) -> float:
return self.debit_balance - self.credit_balance
class DoubleEntryLedger:
def __init__(self) -> None:
self.accounts: Dict[str, Account] = {}
self.journal: List[LedgerEntry] = []
def add_account(self, name: str) -> Account:
if name in self.accounts:
raise ValueError(f"Account '{name}' already exists")
account = Account(name)
self.accounts[name] = account
return account
def post_entry(
self, debit_acct: str, credit_acct: str, amount: float, description: str = ""
) -> LedgerEntry:
if amount <= 0:
raise ValueError("Amount must be positive")
if debit_acct not in self.accounts:
raise ValueError(f"Debit account '{debit_acct}' not found")
if credit_acct not in self.accounts:
raise ValueError(f"Credit account '{credit_acct}' not found")
self.accounts[debit_acct].debit(amount)
self.accounts[credit_acct].credit(amount)
entry = LedgerEntry(debit_acct, credit_acct, amount, description)
self.journal.append(entry)
return entry
def get_balance(self, account_name: str) -> float:
if account_name not in self.accounts:
raise ValueError(f"Account '{account_name}' not found")
return self.accounts[account_name].net_balance
def trial_balance(self) -> Tuple[List[Tuple[str, float, float]], bool]:
rows: List[Tuple[str, float, float]] = []
total_debit, total_credit = 0.0, 0.0
for name, acct in sorted(self.accounts.items()):
rows.append((name, acct.debit_balance, acct.credit_balance))
total_debit += acct.debit_balance
total_credit += acct.credit_balance
is_balanced = abs(total_debit - total_credit) < 0.001
return rows, is_balanced
def print_trial_balance(self) -> None:
rows, balanced = self.trial_balance()
print(f"{'Account':<20} {'Debit':>12} {'Credit':>12}")
print("-" * 46)
for name, dr, cr in rows:
print(f"{name:<20} {dr:>12.2f} {cr:>12.2f}")
print("-" * 46)
print(f"Balanced: {balanced}")Solution 3: Multi-Leg Transactions with Validation Multi-leg transactions with Decimal precision. Uses an enum for debit/credit sides and immutable Leg dataclass. Supports complex transactions with arbitrary numbers of debits and credits. Includes proper money rounding with ROUND_HALF_UP.
"""
Double-Entry Ledger - Solution 3: Multi-Leg Transactions with Validation
Supports complex transactions with multiple debits and credits.
"""
from dataclasses import dataclass, field
from typing import Dict, List, Optional
from decimal import Decimal, ROUND_HALF_UP
from enum import Enum, auto
class Side(Enum):
DEBIT = auto()
CREDIT = auto()
@dataclass(frozen=True)
class Leg:
account: str
amount: Decimal
side: Side
@dataclass
class Transaction:
memo: str
legs: List[Leg] = field(default_factory=list)
def add_debit(self, account: str, amount: Decimal) -> "Transaction":
self.legs.append(Leg(account, amount, Side.DEBIT))
return self
def add_credit(self, account: str, amount: Decimal) -> "Transaction":
self.legs.append(Leg(account, amount, Side.CREDIT))
return self
def total_debits(self) -> Decimal:
return sum((leg.amount for leg in self.legs if leg.side == Side.DEBIT), Decimal(0))
def total_credits(self) -> Decimal:
return sum((leg.amount for leg in self.legs if leg.side == Side.CREDIT), Decimal(0))
def is_balanced(self) -> bool:
return self.total_debits() == self.total_credits()
class GeneralLedger:
def __init__(self) -> None:
self._accounts: Dict[str, List[Leg]] = {}
self._transactions: List[Transaction] = []
def open_account(self, name: str) -> None:
if name in self._accounts:
raise ValueError(f"Account '{name}' already exists")
self._accounts[name] = []
def commit(self, txn: Transaction) -> None:
if not txn.is_balanced():
diff = txn.total_debits() - txn.total_credits()
raise ValueError(f"Unbalanced transaction: off by {diff}")
for leg in txn.legs:
if leg.account not in self._accounts:
raise KeyError(f"Unknown account: {leg.account}")
for leg in txn.legs:
self._accounts[leg.account].append(leg)
self._transactions.append(txn)
def balance(self, account: str) -> Decimal:
if account not in self._accounts:
raise KeyError(f"Unknown account: {account}")
total = Decimal(0)
for leg in self._accounts[account]:
if leg.side == Side.DEBIT:
total += leg.amount
else:
total -= leg.amount
return total.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
def trial_balance_report(self) -> str:
lines = ["TRIAL BALANCE", "=" * 50]
total_dr, total_cr = Decimal(0), Decimal(0)
for acct in sorted(self._accounts.keys()):
bal = self.balance(acct)
dr = bal if bal > 0 else Decimal(0)
cr = abs(bal) if bal < 0 else Decimal(0)
total_dr += dr
total_cr += cr
lines.append(f"{acct:<25} DR:{dr:>10.2f} CR:{cr:>10.2f}")
lines.append("=" * 50)
lines.append(f"{'TOTALS':<25} DR:{total_dr:>10.2f} CR:{total_cr:>10.2f}")
lines.append(f"Balanced: {total_dr == total_cr}")
return "\n".join(lines){{/fold}}
Question 6 - Task DAG Executor
- Difficulty: 9 / 10
- Approximate lines of code: 70 LoC
- Tags: scheduling, concurrency
Description
{{fold}}{Concurrency Cheat Sheet}
This problem involves concurrency. Here is a cheat sheet of relevant Python syntax. You may not need all of these; this list is not exhaustive or suggestive for the problem.
# threading.Thread
t = threading.Thread(target=fn, args=(arg1,))
t.start()
t.join()
# threading.Lock
lock = threading.Lock()
lock.acquire()
lock.release()
with lock:
# critical section
# threading.Condition
cond = threading.Condition()
with cond:
cond.wait() # release lock, wait, reacquire
cond.notify() # wake one waiting thread
cond.notify_all() # wake all waiting threads
# threading.Semaphore
sem = threading.Semaphore(value=3)
sem.acquire()
sem.release()
# threading.Event
event = threading.Event()
event.set() # set flag to True
event.clear() # set flag to False
event.wait() # block until flag is True
event.is_set() # check flag
# concurrent.futures.ThreadPoolExecutor
with ThreadPoolExecutor(max_workers=4) as executor:
future = executor.submit(fn, arg1, arg2)
result = future.result()
futures = [executor.submit(fn, x) for x in items]
for f in as_completed(futures):
result = f.result()
# queue.Queue (thread-safe)
q = queue.Queue()
q.put(item)
item = q.get() # blocks until available
q.task_done()
q.join() # block until all tasks done{{/fold}}
A Task DAG (Directed Acyclic Graph) Executor is the core of build systems like Make, Bazel, and Gradle. Tasks have dependencies: Task B depends on Task A means A must complete before B can start. The executor must find a valid execution order (topological sort) or detect if the dependencies form a cycle (impossible to execute). This is fundamentally a topological sorting problem.
Two main approaches exist: Kahn's algorithm (BFS-based) counts incoming edges and processes nodes with zero in-degree; DFS-based post-order traversal visits dependencies recursively and appends nodes after all dependencies are visited. Both run in O(V + E) time. Internal state typically includes a task map (name -> task), an adjacency list (task -> list of dependents), and in-degree counts or visit state.
Part A: Basic Execution Order
{{fold}}{Problem: Part A}
Given tasks with dependencies, return a valid execution order. If there's a cycle, raise an error.
tasks = [
Task("compile", lambda: "compiled", dependencies=[]),
Task("test", lambda: "tested", dependencies=["compile"]),
Task("package", lambda: "packaged", dependencies=["compile"]),
Task("deploy", lambda: "deployed", dependencies=["test", "package"]),
]
execute_tasks(tasks)
# Valid orders:
# ["compile", "test", "package", "deploy"]
# ["compile", "package", "test", "deploy"]
# "compile" must come first, "deploy" must come last
# Cycle detection:
tasks = [
Task("A", lambda: "a", dependencies=["B"]),
Task("B", lambda: "b", dependencies=["A"]),
]
execute_tasks(tasks) # raises CircularDependencyError{{/fold}}
Part B: Parallel Batches
{{fold}}{Problem: Part B}
Instead of a flat list, return batches of tasks that can run in parallel. First batch has no dependencies. Second batch only depends on first batch. Etc.
tasks = [
Task("A", fn_a, dependencies=[]),
Task("B", fn_b, dependencies=[]),
Task("C", fn_c, dependencies=["A"]),
Task("D", fn_d, dependencies=["A", "B"]),
Task("E", fn_e, dependencies=["C", "D"]),
]
get_parallel_batches(tasks)
# Returns: [["A", "B"], ["C", "D"], ["E"]]
# Batch 1: A and B have no deps, run in parallel
# Batch 2: C and D only depend on batch 1
# Batch 3: E depends on batch 2{{/fold}}
Part C: Actual Parallel Execution
{{fold}}{Problem: Part C}
Execute tasks concurrently using a thread pool. Each task waits for its dependencies to complete before running. Handle failures gracefully - if a task fails, tasks that depend on it should be skipped or marked as failed.
def slow_compile():
time.sleep(1.0)
return "compiled"
def slow_test():
time.sleep(1.0)
return "tested"
tasks = [
Task("compile", slow_compile, dependencies=[]),
Task("test", slow_test, dependencies=["compile"]),
Task("lint", slow_lint, dependencies=[]), # independent
]
# Sequential would take 3+ seconds
# Parallel: compile and lint run together (1s), then test (1s) = 2s total
start = time.time()
results = execute_tasks(tasks, max_workers=4)
elapsed = time.time() - start # ~2 seconds, not 3{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if a dependency doesn't exist in the task list?
- What about self-loops (task depends on itself)?
- What if the graph has disconnected components (independent task groups)?
- How do you handle a task that fails mid-execution?
Common mistakes:
- Only starting DFS from one node (misses disconnected components)
- Using simple visited set for cycle detection (only detects revisits, not back-edges - need three-color WHITE/GRAY/BLACK)
- Not validating that dependencies exist before execution
- Forgetting to handle the "no tasks" case
- In parallel version: not waiting for all dependencies before starting a task
- In parallel version: submitting tasks before all futures are registered (race condition)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses Kahn's algorithm (BFS-based), counting in-degrees and processing tasks with zero in-degree in batches. Solution 2 uses DFS with three-color marking (UNVISITED/VISITING/VISITED) for cycle detection and handles disconnected components. Solution 3 adds concurrent execution with ThreadPoolExecutor, where each task waits on its dependency futures before executing. The key difference is sequential vs parallel execution and BFS vs DFS traversal. Core techniques: topological sort, Kahn's algorithm, DFS cycle detection, thread pools.
Solution 1: Kahn's algorithm (BFS-based) Kahn's algorithm (BFS-based). Builds in-degree map and processes tasks with zero in-degree. Each iteration represents a parallel batch. Detects cycles when not all tasks are executed.
"""
Solution 1: Kahn's Algorithm (BFS-based topological sort)
Uses in-degree counting and a queue to process tasks level by level.
"""
from dataclasses import dataclass, field
from typing import Callable, Any
from collections import deque
@dataclass
class Task:
name: str
fn: Callable[[], Any]
dependencies: list[str] = field(default_factory=list)
class CircularDependencyError(Exception):
pass
def execute_tasks(tasks: list[Task]) -> dict[str, Any]:
"""Execute tasks in topological order using Kahn's algorithm."""
task_map = {t.name: t for t in tasks}
in_degree = {t.name: 0 for t in tasks}
dependents: dict[str, list[str]] = {t.name: [] for t in tasks}
# Build graph and calculate in-degrees
for task in tasks:
for dep in task.dependencies:
if dep not in task_map:
raise ValueError(f"Unknown dependency: {dep}")
dependents[dep].append(task.name)
in_degree[task.name] += 1
# Start with tasks that have no dependencies
queue = deque([name for name, degree in in_degree.items() if degree == 0])
results: dict[str, Any] = {}
executed_count = 0
while queue:
# All tasks in current queue can run in parallel
parallel_batch = list(queue)
queue.clear()
for name in parallel_batch:
task = task_map[name]
results[name] = task.fn()
executed_count += 1
# Reduce in-degree for dependent tasks
for dependent in dependents[name]:
in_degree[dependent] -= 1
if in_degree[dependent] == 0:
queue.append(dependent)
if executed_count != len(tasks):
raise CircularDependencyError("Circular dependency detected")
return resultsSolution 2: DFS with three-color marking DFS-based with three-color marking (UNVISITED/VISITING/VISITED). Detects cycles by finding back-edges (revisiting a VISITING node). Handles disconnected components by iterating all unvisited nodes.
"""
Solution 2: DFS-based topological sort with cycle detection
Uses recursion with three-color marking (white/gray/black) for cycle detection.
"""
from dataclasses import dataclass, field
from typing import Callable, Any
from enum import Enum
class State(Enum):
UNVISITED = 0
VISITING = 1 # Currently in recursion stack (gray)
VISITED = 2 # Fully processed (black)
@dataclass
class Task:
name: str
fn: Callable[[], Any]
dependencies: list[str] = field(default_factory=list)
class CircularDependencyError(Exception):
pass
def execute_tasks(tasks: list[Task]) -> dict[str, Any]:
"""Execute tasks using DFS topological sort with cycle detection."""
task_map = {t.name: t for t in tasks}
state: dict[str, State] = {t.name: State.UNVISITED for t in tasks}
execution_order: list[str] = []
def dfs(name: str) -> None:
if state[name] == State.VISITING:
raise CircularDependencyError(f"Cycle detected at task: {name}")
if state[name] == State.VISITED:
return
state[name] = State.VISITING
task = task_map[name]
for dep in task.dependencies:
if dep not in task_map:
raise ValueError(f"Unknown dependency: {dep}")
dfs(dep)
state[name] = State.VISITED
execution_order.append(name)
# Visit all tasks (handles disconnected components)
for task in tasks:
if state[task.name] == State.UNVISITED:
dfs(task.name)
# Execute in topological order and collect results
results: dict[str, Any] = {}
for name in execution_order:
results[name] = task_map[name].fn()
return resultsSolution 3: Concurrent execution with ThreadPoolExecutor Concurrent execution with ThreadPoolExecutor. Submits all tasks upfront, each task waits on its dependency futures before executing. Uses a gate lock to ensure all futures are registered before any task checks dependencies (avoids race condition).
"""
Solution 3: Concurrent execution with ThreadPoolExecutor
Actually parallelizes independent tasks using threading.
"""
from dataclasses import dataclass, field
from typing import Callable, Any
from concurrent.futures import ThreadPoolExecutor, Future
from threading import Lock
import time
@dataclass
class Task:
name: str
fn: Callable[[], Any]
dependencies: list[str] = field(default_factory=list)
class CircularDependencyError(Exception):
pass
def detect_cycle(tasks: list[Task]) -> bool:
"""Detect cycles using DFS with coloring."""
task_map = {t.name: t for t in tasks}
WHITE, GRAY, BLACK = 0, 1, 2
color = {t.name: WHITE for t in tasks}
def dfs(name: str) -> bool:
color[name] = GRAY
for dep in task_map[name].dependencies:
if dep not in task_map:
raise ValueError(f"Unknown dependency: {dep}")
if color[dep] == GRAY:
return True # Back edge = cycle
if color[dep] == WHITE and dfs(dep):
return True
color[name] = BLACK
return False
return any(color[t.name] == WHITE and dfs(t.name) for t in tasks)
def execute_tasks(tasks: list[Task], max_workers: int = 4) -> dict[str, Any]:
"""Execute tasks concurrently, respecting dependencies."""
if detect_cycle(tasks):
raise CircularDependencyError("Circular dependency detected")
task_map = {t.name: t for t in tasks}
results: dict[str, Any] = {}
futures: dict[str, Future] = {}
lock = Lock()
ready = Lock() # Gate to ensure all futures are registered before execution
def run_task(name: str) -> Any:
with ready: # Wait until all futures are registered
pass
task = task_map[name]
# Wait for all dependencies to complete
for dep in task.dependencies:
futures[dep].result()
result = task.fn()
with lock:
results[name] = result
return result
with ThreadPoolExecutor(max_workers=max_workers) as executor:
with ready: # Hold the gate while submitting
for task in tasks:
futures[task.name] = executor.submit(run_task, task.name)
# Gate released, tasks can now execute
for future in futures.values():
future.result()
return results{{/fold}}
Question 7 - Quadtree
- Difficulty: 7 / 10
- Approximate lines of code: 90 LoC
- Tags: data-structures, game/simulation
Description
A quadtree is a tree data structure where each internal node has exactly four children, used to partition a 2D space by recursively subdividing it into four quadrants. It is commonly used in collision detection (games), spatial indexing (GIS), and image compression. Each node represents a rectangular region; when a node contains too many objects, it splits into four children (NW, NE, SW, SE). The key insight is that spatial queries can skip entire subtrees whose bounding boxes do not intersect the query region.
Internal state example after inserting points (10,10), (20,20), (80,80):
Root [boundary: (0,0)-(100,100), capacity: 4]
points: [(10,10), (20,20), (80,80)] # Not yet subdivided
After inserting 2 more points, capacity exceeded:
Root [divided=True]
NW [boundary: (0,50)-(50,100)] -> points: []
NE [boundary: (50,50)-(100,100)] -> points: [(80,80)]
SW [boundary: (0,0)-(50,50)] -> points: [(10,10), (20,20)]
SE [boundary: (50,0)-(100,50)] -> points: []Part A: Point Storage and Region Queries
{{fold}}{Problem: Part A}
Implement a quadtree that stores 2D points and supports rectangle queries.
qt = QuadTree(boundary=Rectangle(50, 50, 50, 50), capacity=4)
qt.insert(Point(10, 10))
qt.insert(Point(20, 20))
qt.insert(Point(80, 80))
# Query: find all points in region [(5,5) to (25,25)]
results = qt.query(Rectangle(15, 15, 10, 10))
# Returns: [Point(10,10), Point(20,20)]
# Internal state: if capacity not exceeded, points stored in leaf
# If exceeded, node subdivides and redistributes points to childrenKey operations:
insert(point): Add point to appropriate leaf; subdivide if capacity exceededquery(region): Return all points within the given rectanglesubdivide(): Split node into four children (NW, NE, SW, SE)
{{/fold}}
Part B: Rectangle Storage and Collision Detection
{{fold}}{Problem: Part B}
Extend the quadtree to store rectangles (axis-aligned bounding boxes) instead of points. Find all stored rectangles that intersect a query rectangle.
qt = QuadTree(bounds=AABB(0, 0, 100, 100))
qt.insert(Entity(id=1, bounds=AABB(10, 10, 20, 20)))
qt.insert(Entity(id=2, bounds=AABB(15, 15, 25, 25)))
qt.insert(Entity(id=3, bounds=AABB(80, 80, 90, 90)))
# Find rectangles colliding with query region
collisions = qt.query_collisions(AABB(12, 12, 22, 22))
# Returns: [Entity(1), Entity(2)] # Both overlap with queryKey difference from Part A: A rectangle may span multiple quadrants, so it must be inserted into all children it intersects (or kept at the parent level).
{{/fold}}
Part C: Deletion and Rebalancing
{{fold}}{Problem: Part C}
Implement deletion of objects and optional merging of sparse nodes back into their parent.
qt = QuadTree(Bounds(0, 0, 100), capacity=2)
for i in range(20):
qt.insert(Point(i*4+5, i*4+5, id=i))
assert qt.depth() >= 3 # Tree has grown deep
# Rebuild with larger capacity to reduce depth
rebuilt = qt.rebuild(new_capacity=8)
assert rebuilt.depth() < qt.depth()
# Check if tree needs rebalancing
if qt.needs_rebalance(max_depth=10):
qt = qt.rebuild()Consider: When should you merge children back? A common heuristic is when total objects in all four children falls below capacity.
{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when a point falls exactly on a quadrant boundary?
- How do you handle objects that span multiple quadrants?
- What if all points cluster in one corner (degenerate case)?
- Does
queryhandle regions that extend outside the tree boundary?
Common mistakes:
- Off-by-one errors in boundary checks (using
<vs<=) - Infinite recursion when a point sits exactly on a subdivision boundary
- Forgetting to redistribute existing points after subdivision
- Not pruning search when query region does not intersect node boundary
- For rectangles: only inserting into one child instead of all overlapping children
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 implements a basic point-based quadtree using center+half-width rectangle representation with recursive subdivision. Solution 2 extends to rectangle storage using min/max corner AABB representation for collision detection, where objects can span multiple quadrants. Solution 3 adds rebuild and rebalancing capabilities to maintain tree efficiency after many operations. The key difference is what they store (points vs rectangles) and whether they support tree maintenance operations.
Core techniques: recursive spatial subdivision, bounding box intersection tests, capacity-based subdivision triggers.
Solution 1: Basic point-based quadtree Basic point-based quadtree using center+half-width rectangle representation. Stores points in leaf nodes until capacity is exceeded, then subdivides and redistributes. Query recursively checks intersection before descending.
"""Quadtree implementation - Basic point-based quadtree with region queries."""
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class Point:
x: float
y: float
data: any = None
@dataclass
class Rectangle:
x: float # center x
y: float # center y
w: float # half-width
h: float # half-height
def contains(self, point: Point) -> bool:
return (self.x - self.w <= point.x <= self.x + self.w and
self.y - self.h <= point.y <= self.y + self.h)
def intersects(self, other: "Rectangle") -> bool:
return not (other.x - other.w > self.x + self.w or
other.x + other.w < self.x - self.w or
other.y - other.h > self.y + self.h or
other.y + other.h < self.y - self.h)
@dataclass
class QuadTree:
boundary: Rectangle
capacity: int = 4
points: list[Point] = field(default_factory=list)
divided: bool = False
nw: Optional["QuadTree"] = None
ne: Optional["QuadTree"] = None
sw: Optional["QuadTree"] = None
se: Optional["QuadTree"] = None
def subdivide(self) -> None:
x, y, w, h = self.boundary.x, self.boundary.y, self.boundary.w / 2, self.boundary.h / 2
self.nw = QuadTree(Rectangle(x - w, y + h, w, h), self.capacity)
self.ne = QuadTree(Rectangle(x + w, y + h, w, h), self.capacity)
self.sw = QuadTree(Rectangle(x - w, y - h, w, h), self.capacity)
self.se = QuadTree(Rectangle(x + w, y - h, w, h), self.capacity)
self.divided = True
def insert(self, point: Point) -> bool:
if not self.boundary.contains(point):
return False
if len(self.points) < self.capacity and not self.divided:
self.points.append(point)
return True
if not self.divided:
self.subdivide()
for p in self.points:
self._insert_into_children(p)
self.points = []
return self._insert_into_children(point)
def _insert_into_children(self, point: Point) -> bool:
return (self.nw.insert(point) or self.ne.insert(point) or
self.sw.insert(point) or self.se.insert(point))
def query(self, region: Rectangle, found: list[Point] = None) -> list[Point]:
if found is None:
found = []
if not self.boundary.intersects(region):
return found
for p in self.points:
if region.contains(p):
found.append(p)
if self.divided:
self.nw.query(region, found)
self.ne.query(region, found)
self.sw.query(region, found)
self.se.query(region, found)
return foundSolution 2: Rectangle-based quadtree with collision detection Rectangle-based quadtree using min/max corner AABB representation. Designed for collision detection with entities that have bounding boxes. Objects spanning multiple quadrants are inserted into all relevant children.
"""Quadtree implementation - Rectangle storage with collision detection."""
from dataclasses import dataclass, field
from typing import Optional
@dataclass(frozen=True)
class AABB:
"""Axis-aligned bounding box."""
min_x: float
min_y: float
max_x: float
max_y: float
@property
def center(self) -> tuple[float, float]:
return ((self.min_x + self.max_x) / 2, (self.min_y + self.max_y) / 2)
def contains_point(self, x: float, y: float) -> bool:
return self.min_x <= x <= self.max_x and self.min_y <= y <= self.max_y
def intersects(self, other: "AABB") -> bool:
return not (self.max_x < other.min_x or self.min_x > other.max_x or
self.max_y < other.min_y or self.min_y > other.max_y)
@dataclass
class Entity:
id: int
bounds: AABB
@dataclass
class QuadTree:
bounds: AABB
max_objects: int = 4
max_depth: int = 8
depth: int = 0
objects: list[Entity] = field(default_factory=list)
children: Optional[list["QuadTree"]] = None
def _split(self) -> None:
cx, cy = self.bounds.center
self.children = [
QuadTree(AABB(self.bounds.min_x, cy, cx, self.bounds.max_y),
self.max_objects, self.max_depth, self.depth + 1),
QuadTree(AABB(cx, cy, self.bounds.max_x, self.bounds.max_y),
self.max_objects, self.max_depth, self.depth + 1),
QuadTree(AABB(self.bounds.min_x, self.bounds.min_y, cx, cy),
self.max_objects, self.max_depth, self.depth + 1),
QuadTree(AABB(cx, self.bounds.min_y, self.bounds.max_x, cy),
self.max_objects, self.max_depth, self.depth + 1),
]
def insert(self, entity: Entity) -> bool:
if not self.bounds.intersects(entity.bounds):
return False
if self.children is None and (len(self.objects) < self.max_objects or
self.depth >= self.max_depth):
self.objects.append(entity)
return True
if self.children is None:
self._split()
for obj in self.objects:
for child in self.children:
child.insert(obj)
self.objects = []
for child in self.children:
child.insert(entity)
return True
def query_collisions(self, target: AABB) -> list[Entity]:
results = []
if not self.bounds.intersects(target):
return results
for obj in self.objects:
if obj.bounds.intersects(target):
results.append(obj)
if self.children:
for child in self.children:
results.extend(child.query_collisions(target))
return results
def clear(self) -> None:
self.objects.clear()
self.children = NoneSolution 3: Point-based quadtree with rebuild/rebalance Point-based quadtree with rebuild and rebalance support. Tracks total point count, supports iterating all points, and can rebuild with different capacity to reduce tree depth after many insertions/deletions.
"""Quadtree implementation - With rebuild/rebalance support."""
from dataclasses import dataclass, field
from typing import Optional, Iterator
@dataclass
class Point:
x: float
y: float
id: int = 0
@dataclass
class Bounds:
x: float
y: float
size: float # Square region for simplicity
def contains(self, p: Point) -> bool:
return self.x <= p.x < self.x + self.size and self.y <= p.y < self.y + self.size
def intersects_rect(self, rx: float, ry: float, rw: float, rh: float) -> bool:
return not (rx > self.x + self.size or rx + rw < self.x or
ry > self.y + self.size or ry + rh < self.y)
@dataclass
class QuadTree:
bounds: Bounds
capacity: int = 4
points: list[Point] = field(default_factory=list)
children: Optional[list["QuadTree"]] = None
_total_points: int = 0
def _subdivide(self) -> None:
x, y, half = self.bounds.x, self.bounds.y, self.bounds.size / 2
self.children = [
QuadTree(Bounds(x, y + half, half), self.capacity),
QuadTree(Bounds(x + half, y + half, half), self.capacity),
QuadTree(Bounds(x, y, half), self.capacity),
QuadTree(Bounds(x + half, y, half), self.capacity),
]
def insert(self, point: Point) -> bool:
if not self.bounds.contains(point):
return False
self._total_points += 1
if self.children is None and len(self.points) < self.capacity:
self.points.append(point)
return True
if self.children is None:
self._subdivide()
for p in self.points:
for child in self.children:
if child.insert(p):
break
self.points = []
for child in self.children:
if child.insert(point):
return True
return False
def query_region(self, rx: float, ry: float, rw: float, rh: float) -> list[Point]:
results = []
if not self.bounds.intersects_rect(rx, ry, rw, rh):
return results
for p in self.points:
if rx <= p.x <= rx + rw and ry <= p.y <= ry + rh:
results.append(p)
if self.children:
for child in self.children:
results.extend(child.query_region(rx, ry, rw, rh))
return results
def all_points(self) -> Iterator[Point]:
yield from self.points
if self.children:
for child in self.children:
yield from child.all_points()
def rebuild(self, new_capacity: Optional[int] = None) -> "QuadTree":
"""Rebuild tree, optionally with new capacity."""
cap = new_capacity if new_capacity else self.capacity
new_tree = QuadTree(self.bounds, cap)
for p in self.all_points():
new_tree.insert(p)
return new_tree
def depth(self) -> int:
if self.children is None:
return 1
return 1 + max(child.depth() for child in self.children)
def needs_rebalance(self, max_depth: int = 10) -> bool:
return self.depth() > max_depth{{/fold}}
Question 8 - Two-Phase Commit
- Difficulty: 10 / 10
- Approximate lines of code: 90 LoC
- Tags: distributed-systems, concurrency
Description
{{fold}}{Concurrency Cheat Sheet}
This problem involves concurrency. Here is a cheat sheet of relevant Python syntax. You may not need all of these; this list is not exhaustive or suggestive for the problem.
# threading.Thread
t = threading.Thread(target=func, args=(arg1, arg2))
t.start()
t.join()
# threading.Lock
lock = threading.Lock()
lock.acquire()
lock.release()
with lock:
# critical section
# threading.Condition
cond = threading.Condition()
with cond:
cond.wait() # release lock, wait for notify
cond.notify() # wake one waiter
cond.notify_all() # wake all waiters
# threading.Semaphore
sem = threading.Semaphore(value=3)
sem.acquire()
sem.release()
# threading.Event
event = threading.Event()
event.set() # signal
event.clear() # reset
event.wait() # block until set
event.is_set() # check without blocking
# queue.Queue (thread-safe)
from queue import Queue
q = Queue()
q.put(item)
item = q.get() # blocks
item = q.get_nowait() # raises Empty if none
# Atomic operations concept
# Python's GIL makes single bytecode ops atomic
# For true atomics, use: threading.Lock or ctypes/cffi
# CAS pattern: if current == expected: current = new{{/fold}}
Two-Phase Commit (2PC) is a protocol for coordinating distributed transactions across multiple nodes (databases, services, etc.). When a transaction spans multiple systems, you need all of them to either commit or abort together - partial commits corrupt data. The coordinator orchestrates the protocol, and participants vote on whether they can commit.
The two phases are: (1) Prepare: coordinator asks all participants "can you commit?", participants lock resources and vote YES or NO; (2) Commit/Abort: if all voted YES, coordinator tells everyone to COMMIT, otherwise tells everyone to ABORT. The key insight: once a participant votes YES, it must be able to commit later (resources stay locked until the coordinator's decision arrives).
Part A: Happy Path
{{fold}}{Problem: Part A}
Implement Coordinator and Participant classes. The coordinator sends PREPARE to all participants, collects votes, then sends COMMIT if all voted YES or ABORT if any voted NO.
# Setup
p1 = Participant("db1")
p2 = Participant("db2")
p3 = Participant("db3")
coordinator = Coordinator([p1, p2, p3])
# Execute transaction
result = coordinator.execute_transaction("txn-001")
# Phase 1 (Prepare):
# coordinator -> p1.prepare("txn-001") -> Vote.COMMIT
# coordinator -> p2.prepare("txn-001") -> Vote.COMMIT
# coordinator -> p3.prepare("txn-001") -> Vote.COMMIT
# All voted COMMIT
# Phase 2 (Commit):
# coordinator -> p1.commit("txn-001")
# coordinator -> p2.commit("txn-001")
# coordinator -> p3.commit("txn-001")
result # True (all committed)
p1.state # ParticipantState.COMMITTEDIf any participant votes NO:
p2 = Participant("db2", fail_on_prepare=True) # Will vote NO
coordinator = Coordinator([p1, p2, p3])
result = coordinator.execute_transaction("txn-002")
# Phase 1: p2 votes ABORT
# Phase 2: coordinator sends ABORT to all
result # False
# All participants in ABORTED state{{/fold}}
Part B: Participant Failures
{{fold}}{Problem: Part B}
Handle failures during the protocol. Key rules:
- Failure during PREPARE: Simply abort the transaction (participant couldn't prepare)
- Failure during COMMIT (after all voted YES): Coordinator must retry indefinitely - the decision is made and MUST be honored
# Participant fails during commit phase
p1 = Participant("db1")
p2 = Participant("db2", fail_on_commit=True) # Prepare succeeds, commit fails
coordinator = Coordinator([p1, p2])
result = coordinator.run_2pc("txn-003")
# Phase 1: Both vote COMMIT
# Phase 2: p2.commit() fails!
# Coordinator MUST retry p2.commit() until it succeeds
# Cannot abort - p1 already committed!Timeout handling:
p1 = Participant("db1", simulate_timeout=True)
# Phase 1: p1 times out during prepare
# Coordinator aborts entire transaction (safe - no one committed yet){{/fold}}
Part C: Write-Ahead Logging
{{fold}}{Problem: Part C}
Add durability. Before responding to any message, participants and coordinator must log their state. This enables crash recovery.
# Participant logging:
def prepare(self, txn_id):
# Do work to prepare...
self.log.write(txn_id, "PREPARED") # LOG BEFORE responding
return Vote.COMMIT
def commit(self, txn_id):
self.log.write(txn_id, "COMMITTED") # LOG BEFORE applying
# Apply changes...
# Coordinator logging:
def run_2pc(self, txn_id):
votes = [p.prepare(txn_id) for p in participants]
decision = COMMIT if all_yes else ABORT
self.log.write(txn_id, decision) # LOG DECISION before sending
# Now send commit/abort to all participantsRecovery after crash:
# Participant recovery:
state = log.get_state(txn_id)
if state == PREPARED:
# Ask coordinator for decision (might block!)
elif state == COMMITTED:
# Re-apply if needed (idempotent)
elif state == None:
# Never prepared, safe to abort{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if coordinator crashes after all participants voted COMMIT but before sending commit? (Participants are BLOCKED - this is 2PC's fundamental limitation)
- What if a participant crashes after voting YES but before receiving commit? (Must recover and ask coordinator for decision)
- Can you ever abort after someone voted YES? (Only if coordinator also failed and you use a timeout-based presumed abort)
Common mistakes:
- Not retrying forever on commit failure (once decided, must commit)
- Forgetting write-ahead logging (crashes corrupt data without it)
- Not understanding the blocking problem (2PC can block indefinitely)
- Confusing 2PC with consensus (2PC is for transactions, not leader election)
- Sending commit before logging the decision (crash loses decision)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 is a basic synchronous implementation with failure simulation flags, showing the core protocol flow without logging or retries. Solution 2 adds timeout handling and write-ahead logging for crash recovery, with participants logging state before responding. Solution 3 is an async implementation using asyncio for concurrent participant coordination, with retry logic for the commit phase. These differ in their handling of failures (none vs timeouts vs retries) and execution model (sync vs async). Core techniques: state machines, write-ahead logging, timeout handling, retry with backoff.
Solution 1: Basic synchronous implementation Basic synchronous implementation with failure simulation flags. Clean state machine for participants. No logging or retry logic - just the core protocol flow.
"""
Two-Phase Commit Protocol - Basic Implementation
Clean synchronous implementation with failure simulation.
"""
from dataclasses import dataclass
from enum import Enum
from typing import Callable
import random
class Vote(Enum):
COMMIT = "commit"
ABORT = "abort"
class ParticipantState(Enum):
INITIAL = "initial"
PREPARED = "prepared"
COMMITTED = "committed"
ABORTED = "aborted"
@dataclass
class Participant:
name: str
state: ParticipantState = ParticipantState.INITIAL
fail_on_prepare: bool = False
fail_on_commit: bool = False
def prepare(self, transaction_id: str) -> Vote:
if self.fail_on_prepare:
return Vote.ABORT
self.state = ParticipantState.PREPARED
return Vote.COMMIT
def commit(self, transaction_id: str) -> bool:
if self.fail_on_commit:
return False
self.state = ParticipantState.COMMITTED
return True
def abort(self, transaction_id: str) -> bool:
self.state = ParticipantState.ABORTED
return True
@dataclass
class Coordinator:
participants: list[Participant]
transaction_id: str = ""
def execute_transaction(self, txn_id: str) -> bool:
self.transaction_id = txn_id
# Phase 1: Prepare
votes = []
for p in self.participants:
vote = p.prepare(txn_id)
votes.append(vote)
# Decision
all_commit = all(v == Vote.COMMIT for v in votes)
# Phase 2: Commit or Abort
if all_commit:
for p in self.participants:
p.commit(txn_id)
return True
else:
for p in self.participants:
p.abort(txn_id)
return FalseSolution 2: With timeout and recovery Adds timeout handling and write-ahead logging for crash recovery. Participants log state transitions before responding. Coordinator logs decision before sending commit/abort. Includes recovery method to restore state from log.
"""
Two-Phase Commit Protocol - With Timeout and Recovery
Handles coordinator/participant failures with timeout simulation.
"""
from dataclasses import dataclass, field
from enum import Enum
from typing import Optional
import time
class TxnState(Enum):
INIT = "init"
PREPARED = "prepared"
COMMITTED = "committed"
ABORTED = "aborted"
TIMEOUT = "timeout"
@dataclass
class TransactionLog:
"""Write-ahead log for crash recovery."""
entries: list[tuple[str, str, TxnState]] = field(default_factory=list)
def write(self, txn_id: str, participant: str, state: TxnState) -> None:
self.entries.append((txn_id, participant, state))
def get_state(self, txn_id: str, participant: str) -> Optional[TxnState]:
for t, p, s in reversed(self.entries):
if t == txn_id and p == participant:
return s
return None
@dataclass
class Participant:
name: str
log: TransactionLog = field(default_factory=TransactionLog)
state: TxnState = TxnState.INIT
simulate_timeout: bool = False
def prepare(self, txn_id: str, timeout_ms: int = 1000) -> TxnState:
if self.simulate_timeout:
return TxnState.TIMEOUT
self.state = TxnState.PREPARED
self.log.write(txn_id, self.name, TxnState.PREPARED)
return TxnState.PREPARED
def commit(self, txn_id: str) -> TxnState:
self.state = TxnState.COMMITTED
self.log.write(txn_id, self.name, TxnState.COMMITTED)
return TxnState.COMMITTED
def abort(self, txn_id: str) -> TxnState:
self.state = TxnState.ABORTED
self.log.write(txn_id, self.name, TxnState.ABORTED)
return TxnState.ABORTED
def recover(self, txn_id: str) -> Optional[TxnState]:
return self.log.get_state(txn_id, self.name)
@dataclass
class Coordinator:
participants: list[Participant]
log: TransactionLog = field(default_factory=TransactionLog)
timeout_ms: int = 1000
def run_2pc(self, txn_id: str) -> bool:
# Phase 1: Prepare with timeout handling
prepared = []
for p in self.participants:
result = p.prepare(txn_id, self.timeout_ms)
if result == TxnState.TIMEOUT:
self._abort_all(txn_id)
return False
prepared.append(result == TxnState.PREPARED)
# Log decision before Phase 2
decision = all(prepared)
self.log.write(txn_id, "coordinator", TxnState.COMMITTED if decision else TxnState.ABORTED)
# Phase 2: Execute decision
if decision:
for p in self.participants:
p.commit(txn_id)
return True
else:
self._abort_all(txn_id)
return False
def _abort_all(self, txn_id: str) -> None:
for p in self.participants:
p.abort(txn_id)Solution 3: Async with retries Async implementation with concurrent participant coordination and retry logic. Uses asyncio for parallel prepare/commit phases. Implements retry with backoff for commit phase failures (once decided, must succeed).
"""
Two-Phase Commit Protocol - Async with Retries
Production-style implementation with async coordination and retry logic.
"""
from dataclasses import dataclass, field
from enum import Enum
from typing import Callable, Optional
import asyncio
class Phase(Enum):
PREPARE = "prepare"
COMMIT = "commit"
ABORT = "abort"
class Result(Enum):
OK = "ok"
FAIL = "fail"
TIMEOUT = "timeout"
@dataclass
class Participant:
id: str
fail_phase: Optional[Phase] = None
delay_ms: int = 0
async def prepare(self) -> Result:
await asyncio.sleep(self.delay_ms / 1000)
if self.fail_phase == Phase.PREPARE:
return Result.FAIL
return Result.OK
async def commit(self) -> Result:
await asyncio.sleep(self.delay_ms / 1000)
if self.fail_phase == Phase.COMMIT:
return Result.FAIL
return Result.OK
async def abort(self) -> Result:
return Result.OK
@dataclass
class TwoPhaseCommit:
participants: list[Participant]
timeout_sec: float = 1.0
max_retries: int = 3
async def execute(self, txn_id: str) -> bool:
# Phase 1: Prepare all participants concurrently
prepare_results = await self._run_phase(Phase.PREPARE)
if all(r == Result.OK for r in prepare_results):
# Phase 2a: Commit all
commit_results = await self._run_phase_with_retry(Phase.COMMIT)
return all(r == Result.OK for r in commit_results)
else:
# Phase 2b: Abort all
await self._run_phase(Phase.ABORT)
return False
async def _run_phase(self, phase: Phase) -> list[Result]:
async def run_one(p: Participant) -> Result:
try:
method = getattr(p, phase.value)
return await asyncio.wait_for(method(), self.timeout_sec)
except asyncio.TimeoutError:
return Result.TIMEOUT
tasks = [run_one(p) for p in self.participants]
return await asyncio.gather(*tasks)
async def _run_phase_with_retry(self, phase: Phase) -> list[Result]:
"""Retry phase for participants that failed (commit must eventually succeed)."""
results = [Result.FAIL] * len(self.participants)
for attempt in range(self.max_retries):
for i, p in enumerate(self.participants):
if results[i] != Result.OK:
method = getattr(p, phase.value)
try:
results[i] = await asyncio.wait_for(method(), self.timeout_sec)
except asyncio.TimeoutError:
results[i] = Result.TIMEOUT
if all(r == Result.OK for r in results):
break
return results{{/fold}}
Question 9 - Connection Pool
- Difficulty: 8 / 10
- Approximate lines of code: 100 LoC
- Tags: concurrency, storage
Description
{{fold}}{Concurrency Cheat Sheet}
This problem involves concurrency. Here is a cheat sheet of relevant Python syntax. You may not need all of these; this list is not exhaustive or suggestive for the problem.
# threading.Thread
t = threading.Thread(target=fn, args=(arg1,))
t.start()
t.join()
# threading.Lock
lock = threading.Lock()
lock.acquire()
lock.release()
with lock:
# critical section
# threading.Condition
cond = threading.Condition()
with cond:
cond.wait() # release lock, block until notify
cond.wait(timeout=5) # wait with timeout
cond.notify() # wake one waiter
cond.notify_all() # wake all waiters
# threading.Semaphore
sem = threading.Semaphore(3) # allow 3 concurrent
sem.acquire()
sem.release()
sem.acquire(timeout=5) # returns False on timeout
# queue.Queue (thread-safe)
q = queue.Queue(maxsize=10)
q.put(item)
q.put(item, timeout=5)
item = q.get()
item = q.get(timeout=5)
q.get_nowait() # raises Empty
q.put_nowait() # raises Full
# Context managers
class Pool:
def __enter__(self):
return self.checkout()
def __exit__(self, exc_type, exc_val, exc_tb):
self.checkin()
return False # don't suppress exceptions{{/fold}}
A connection pool manages reusable database connections to avoid the overhead of creating new connections for every request. The pool maintains a fixed maximum size, hands out connections on checkout, and accepts them back on checkin. Key challenges include thread-safety (multiple threads requesting connections concurrently), validation (detecting broken connections), and timeouts (what happens when the pool is exhausted).
Internally, you need: a collection of available connections, a set tracking checked-out connections, a lock for thread-safety, and a condition variable for blocking when the pool is exhausted. Connections should be validated before being returned to ensure they're still usable.
Part A: Basic Pool
{{fold}}{Problem: Part A}
Implement checkout() that returns a connection (creating one if needed, up to max size) and checkin(conn) that returns a connection to the pool. If all connections are in use and max size is reached, block until one becomes available.
pool = ConnectionPool(max_size=2)
c1 = pool.checkout() # Creates new connection (id=0)
c2 = pool.checkout() # Creates new connection (id=1)
# Internal state:
# available: []
# in_use: {Connection(0), Connection(1)}
# total: 2 (at max)
c3 = pool.checkout(timeout=0.1) # Returns None (pool exhausted, timeout)
pool.checkin(c1)
# Internal state:
# available: [Connection(0)]
# in_use: {Connection(1)}
c4 = pool.checkout() # Returns Connection(0) from available pool{{/fold}}
Part B: Validation
{{fold}}{Problem: Part B}
Before returning a connection on checkout, verify it's still valid. If invalid, discard it and try the next available connection (or create a new one). Also validate on checkin - don't return broken connections to the pool.
pool = ConnectionPool(max_size=2, validator=lambda c: c.is_valid)
c1 = pool.checkout() # id=0
c1.is_valid = False # Simulate broken connection
pool.checkin(c1) # Connection discarded, not returned to pool
# Internal state:
# available: []
# in_use: {}
# total connections: 0 (broken one was discarded)
c2 = pool.checkout() # Creates new connection (id=1){{/fold}}
Part C: Timeout
{{fold}}{Problem: Part C}
Implement blocking with timeout when the pool is exhausted. Use a condition variable to efficiently wait for a connection to become available rather than busy-polling.
pool = ConnectionPool(max_size=1, timeout=5.0)
c1 = pool.checkout() # Gets connection immediately
# In another thread:
c2 = pool.checkout(timeout=2.0)
# Blocks for up to 2 seconds waiting for c1 to be returned
# Returns None if timeout expires
# Back in first thread:
pool.checkin(c1) # Wakes up waiting thread via condition.notify(){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if someone calls checkin twice with the same connection? (Guard against double-checkin)
- What if checkin is called with a connection that was never checked out? (Ignore or error)
- What about connection staleness (idle too long)? (Add max_idle_time check)
- What happens if validation itself throws an exception? (Treat as invalid)
Common mistakes:
- Race condition: checking pool size and creating connection not atomic
- Holding lock during connection creation (blocks other threads unnecessarily)
- Not using condition variable (busy-waiting wastes CPU)
- Double-checkin causing pool to grow beyond max_size
- Resource leak if validation fails after checkout but before user gets connection
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 uses Lock and Condition with a list/set for available and in-use tracking. Solution 2 switches to queue.Queue with context manager support and staleness detection. Solution 3 uses Semaphore for cleaner concurrency limiting with deque for FIFO reuse and health checks. The key difference is the synchronization primitive: Condition for flexible blocking, Queue for built-in thread-safety, Semaphore for simple capacity limiting. Core techniques: locks, condition variables, semaphores, context managers.
Solution 1: Lock and Condition Basic implementation using threading.Lock and Condition. Uses list for available connections and set for in-use tracking. Simple and correct with proper condition variable usage for blocking.
"""
Connection Pool - Solution 1: Basic Threading with Lock
Uses a simple list-based pool with threading.Lock for synchronization.
"""
from dataclasses import dataclass, field
from threading import Lock, Condition
from typing import Optional, Callable
import time
@dataclass
class Connection:
"""Represents a database connection."""
id: int
created_at: float = field(default_factory=time.time)
is_valid: bool = True
def __hash__(self) -> int:
return hash(self.id)
def __eq__(self, other: object) -> bool:
return isinstance(other, Connection) and self.id == other.id
def close(self) -> None:
self.is_valid = False
@dataclass
class ConnectionPool:
"""Thread-safe connection pool with timeout and validation."""
max_size: int
timeout: float = 30.0
validator: Callable[[Connection], bool] = lambda c: c.is_valid
_available: list[Connection] = field(default_factory=list, init=False)
_in_use: set[Connection] = field(default_factory=set, init=False)
_lock: Lock = field(default_factory=Lock, init=False)
_condition: Condition = field(default_factory=Condition, init=False)
_next_id: int = field(default=0, init=False)
def _create_connection(self) -> Connection:
conn = Connection(id=self._next_id)
self._next_id += 1
return conn
def checkout(self, timeout: Optional[float] = None) -> Optional[Connection]:
"""Get a connection from the pool. Returns None if timeout expires."""
wait_timeout = timeout if timeout is not None else self.timeout
deadline = time.time() + wait_timeout
with self._condition:
while True:
# Try to get a valid connection from available pool
while self._available:
conn = self._available.pop()
if self.validator(conn):
self._in_use.add(conn)
return conn
conn.close() # Discard invalid connection
# Create new connection if under limit
if len(self._in_use) < self.max_size:
conn = self._create_connection()
self._in_use.add(conn)
return conn
# Wait for a connection to be returned
remaining = deadline - time.time()
if remaining <= 0:
return None
self._condition.wait(timeout=remaining)
def checkin(self, conn: Connection) -> None:
"""Return a connection to the pool."""
with self._condition:
if conn in self._in_use:
self._in_use.remove(conn)
if self.validator(conn):
self._available.append(conn)
else:
conn.close()
self._condition.notify()
def size(self) -> int:
"""Return total connections (available + in use)."""
with self._lock:
return len(self._available) + len(self._in_use)Solution 2: Queue-Based with Context Manager Queue-based implementation with context manager support. Adds staleness detection (max_idle_time) and provides a with pool.connection() interface for automatic checkout/checkin with guaranteed cleanup.
"""
Connection Pool - Solution 2: Queue-Based with Context Manager
Uses queue.Queue for thread-safety and provides context manager interface.
"""
from dataclasses import dataclass, field
from queue import Queue, Empty, Full
from threading import Lock
from typing import Optional, Callable, Iterator
from contextlib import contextmanager
import time
@dataclass
class Connection:
"""Represents a pooled connection."""
id: int
created_at: float = field(default_factory=time.time)
last_used: float = field(default_factory=time.time)
_closed: bool = field(default=False, init=False)
def is_valid(self) -> bool:
return not self._closed
def close(self) -> None:
self._closed = True
def touch(self) -> None:
self.last_used = time.time()
@dataclass
class ConnectionPool:
"""Queue-based connection pool with context manager support."""
max_size: int
timeout: float = 30.0
max_idle_time: float = 300.0
validator: Callable[[Connection], bool] = field(default=lambda c: c.is_valid())
_pool: Queue[Connection] = field(init=False)
_in_use: int = field(default=0, init=False)
_next_id: int = field(default=0, init=False)
_lock: Lock = field(default_factory=Lock, init=False)
def __post_init__(self) -> None:
self._pool = Queue(maxsize=self.max_size)
def _create_connection(self) -> Connection:
conn = Connection(id=self._next_id)
self._next_id += 1
return conn
def _is_stale(self, conn: Connection) -> bool:
return time.time() - conn.last_used > self.max_idle_time
def checkout(self, timeout: Optional[float] = None) -> Optional[Connection]:
"""Acquire a connection from the pool."""
wait_time = timeout if timeout is not None else self.timeout
deadline = time.time() + wait_time
while True:
# Try to get from pool first
try:
conn = self._pool.get_nowait()
if self.validator(conn) and not self._is_stale(conn):
conn.touch()
with self._lock:
self._in_use += 1
return conn
conn.close()
continue # Try again
except Empty:
pass
# Pool empty - try to create new connection
with self._lock:
if self._in_use + self._pool.qsize() < self.max_size:
self._in_use += 1
return self._create_connection()
# At max capacity, wait for return
remaining = deadline - time.time()
if remaining <= 0:
return None
try:
conn = self._pool.get(timeout=remaining)
if self.validator(conn) and not self._is_stale(conn):
conn.touch()
with self._lock:
self._in_use += 1
return conn
conn.close()
except Empty:
return None
def checkin(self, conn: Connection) -> None:
"""Return a connection to the pool."""
with self._lock:
self._in_use -= 1
if not self.validator(conn):
conn.close()
return
conn.touch()
try:
self._pool.put_nowait(conn)
except Full:
conn.close()
@contextmanager
def connection(self, timeout: Optional[float] = None) -> Iterator[Connection]:
"""Context manager for automatic checkout/checkin."""
conn = self.checkout(timeout=timeout)
if conn is None:
raise TimeoutError("Could not acquire connection from pool")
try:
yield conn
finally:
self.checkin(conn)Solution 3: Semaphore-Based with Health Checks Semaphore-based implementation with health checks. Uses semaphore to limit concurrent connections (cleaner than manual counting). Includes deque for FIFO connection reuse and explicit health check method on connections.
"""
Connection Pool - Solution 3: Semaphore-Based with Health Checks
Uses semaphores for limiting concurrent connections and periodic health checks.
"""
from dataclasses import dataclass, field
from threading import Semaphore, Lock
from typing import Optional, Callable
from collections import deque
import time
@dataclass
class Connection:
"""Connection with health check support."""
id: int
created_at: float = field(default_factory=time.time)
_healthy: bool = field(default=True, init=False)
def ping(self) -> bool:
"""Simulate health check."""
return self._healthy
def execute(self, query: str) -> str:
"""Simulate query execution."""
if not self._healthy:
raise ConnectionError("Connection is unhealthy")
return f"Result from conn-{self.id}: {query}"
def close(self) -> None:
self._healthy = False
@dataclass
class ConnectionPool:
"""Semaphore-based pool with health checking."""
max_size: int
timeout: float = 30.0
health_check: Callable[[Connection], bool] = field(default=lambda c: c.ping())
_semaphore: Semaphore = field(init=False)
_connections: deque[Connection] = field(default_factory=deque, init=False)
_checked_out: set[int] = field(default_factory=set, init=False)
_lock: Lock = field(default_factory=Lock, init=False)
_next_id: int = field(default=0, init=False)
def __post_init__(self) -> None:
self._semaphore = Semaphore(self.max_size)
def _create_connection(self) -> Connection:
conn = Connection(id=self._next_id)
self._next_id += 1
return conn
def checkout(self, timeout: Optional[float] = None) -> Optional[Connection]:
"""Acquire a healthy connection."""
wait_time = timeout if timeout is not None else self.timeout
if not self._semaphore.acquire(timeout=wait_time):
return None
with self._lock:
# Try to find a healthy connection in the pool
attempts = len(self._connections)
while attempts > 0:
if not self._connections:
break
conn = self._connections.popleft()
attempts -= 1
if self.health_check(conn):
self._checked_out.add(conn.id)
return conn
conn.close()
# Create new connection
conn = self._create_connection()
self._checked_out.add(conn.id)
return conn
def checkin(self, conn: Connection) -> None:
"""Return connection to pool after health check."""
with self._lock:
if conn.id not in self._checked_out:
return # Already returned or never checked out
self._checked_out.remove(conn.id)
if self.health_check(conn):
self._connections.append(conn)
else:
conn.close()
self._semaphore.release()
def stats(self) -> dict[str, int]:
"""Return pool statistics."""
with self._lock:
return {
"available": len(self._connections),
"in_use": len(self._checked_out),
"total_created": self._next_id,
}{{/fold}}
Question 10 - Trie Autocomplete
- Difficulty: 3 / 10
- Approximate lines of code: 80 LoC
- Tags: data-structures
Description
A trie (prefix tree) is a tree data structure where each node represents a character, and paths from root to nodes spell out prefixes. Each node contains a dictionary mapping characters to child nodes, plus metadata like is_end (marks complete words) and optional ranking data (frequency, recency). Tries enable O(k) prefix lookup where k is the prefix length, making them ideal for autocomplete systems.
The core operations are: (1) insert by walking/creating nodes for each character, (2) search by walking nodes and checking is_end, and (3) autocomplete by finding the prefix node then collecting all words in that subtree via DFS.
Part A: Basic Trie Operations
{{fold}}{Problem: Part A}
Implement insert(word) and search(word). Insert creates nodes as needed and marks the final node as a word ending. Search traverses nodes and returns True only if the path exists AND ends at a complete word.
trie = Trie()
trie.insert("apple")
trie.insert("app")
# Internal state:
# root -> 'a' -> 'p' -> 'p' (is_end=True) -> 'l' -> 'e' (is_end=True)
trie.search("app") # True (is_end=True at this node)
trie.search("apple") # True
trie.search("ap") # False (node exists but is_end=False)
trie.search("apricot") # False (path doesn't exist)
trie.starts_with("ap") # True (prefix exists){{/fold}}
Part B: Prefix Autocomplete
{{fold}}{Problem: Part B}
Implement autocomplete(prefix) that returns all words starting with the given prefix. Navigate to the prefix node, then DFS to collect all complete words in that subtree.
trie = Trie()
trie.insert("apple")
trie.insert("app")
trie.insert("application")
trie.insert("banana")
suggestions = trie.autocomplete("ap")
# Returns ["app", "apple", "application"] (order may vary)
suggestions = trie.autocomplete("app")
# Returns ["app", "apple", "application"]
suggestions = trie.autocomplete("xyz")
# Returns [] (prefix not found){{/fold}}
Part C: Ranking by Frequency
{{fold}}{Problem: Part C}
Track how many times each word is inserted and rank autocomplete results by frequency (most frequent first). Repeated insertions of the same word increment its count.
trie = Trie()
trie.insert("app")
trie.insert("app")
trie.insert("app") # frequency=3
trie.insert("apple") # frequency=1
trie.insert("application") # frequency=1
suggestions = trie.autocomplete("ap", limit=2)
# Returns ["app", "apple"] - "app" first due to higher frequency{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- Empty string prefix (should return all words)?
- Case sensitivity handling?
- What if limit exceeds available matches?
- Single-character words?
Common mistakes:
- Forgetting
is_endflag (treating every node as a word) - Inefficient string concatenation in DFS (use list + join)
- Not handling empty prefix case
- Returning nodes instead of reconstructed strings
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 implements a basic trie with frequency-based ranking, collecting all words via DFS then sorting. Solution 2 uses recency-based ranking with a monotonic timestamp counter, also supporting soft delete. Solution 3 combines frequency and recency into a weighted hybrid score and uses a min-heap to efficiently maintain top-k results during collection. These vary in their ranking strategy: pure frequency vs pure recency vs weighted hybrid. Core techniques: tries, DFS traversal, min-heaps for top-k.
Solution 1: Basic Trie with Frequency Ranking A basic trie with frequency-based ranking. Nodes track is_end and frequency. Autocomplete collects all words via DFS then sorts by frequency descending.
"""
Trie Autocomplete - Solution 1: Basic Trie with Frequency Ranking
A straightforward trie implementation using a dictionary for children.
Ranks suggestions by insertion frequency.
"""
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class TrieNode:
children: dict[str, "TrieNode"] = field(default_factory=dict)
is_end: bool = False
frequency: int = 0
class Trie:
def __init__(self) -> None:
self.root = TrieNode()
def insert(self, word: str) -> None:
"""Insert a word into the trie. Increments frequency if word exists."""
node = self.root
for char in word:
if char not in node.children:
node.children[char] = TrieNode()
node = node.children[char]
node.is_end = True
node.frequency += 1
def search(self, word: str) -> bool:
"""Return True if word exists in the trie."""
node = self._find_node(word)
return node is not None and node.is_end
def starts_with(self, prefix: str) -> bool:
"""Return True if any word starts with the given prefix."""
return self._find_node(prefix) is not None
def autocomplete(self, prefix: str, limit: int = 10) -> list[str]:
"""Return words with given prefix, ranked by frequency (descending)."""
node = self._find_node(prefix)
if node is None:
return []
results: list[tuple[str, int]] = []
self._collect_words(node, prefix, results)
results.sort(key=lambda x: -x[1])
return [word for word, _ in results[:limit]]
def _find_node(self, prefix: str) -> Optional[TrieNode]:
"""Traverse to the node representing the prefix."""
node = self.root
for char in prefix:
if char not in node.children:
return None
node = node.children[char]
return node
def _collect_words(
self, node: TrieNode, prefix: str, results: list[tuple[str, int]]
) -> None:
"""DFS to collect all words under a node."""
if node.is_end:
results.append((prefix, node.frequency))
for char, child in node.children.items():
self._collect_words(child, prefix + char, results)Solution 2: Trie with Recency Ranking A recency-based trie where more recently inserted/accessed words rank higher. Uses a monotonic timestamp counter. Also implements soft delete by clearing is_end.
"""
Trie Autocomplete - Solution 2: Trie with Recency Ranking
Uses a timestamp-based approach to rank suggestions by recency.
More recent insertions appear first in autocomplete results.
"""
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class TrieNode:
children: dict[str, "TrieNode"] = field(default_factory=dict)
is_end: bool = False
last_used: int = 0
class RecencyTrie:
def __init__(self) -> None:
self.root = TrieNode()
self._timestamp = 0
def insert(self, word: str) -> None:
"""Insert a word, updating its recency timestamp."""
self._timestamp += 1
node = self.root
for char in word:
if char not in node.children:
node.children[char] = TrieNode()
node = node.children[char]
node.is_end = True
node.last_used = self._timestamp
def search(self, word: str) -> bool:
"""Return True if word exists. Updates recency on access."""
node = self._find_node(word)
if node is not None and node.is_end:
self._timestamp += 1
node.last_used = self._timestamp
return True
return False
def delete(self, word: str) -> bool:
"""Soft delete a word from the trie."""
node = self._find_node(word)
if node is not None and node.is_end:
node.is_end = False
node.last_used = 0
return True
return False
def autocomplete(self, prefix: str, limit: int = 10) -> list[str]:
"""Return words with given prefix, ranked by recency (most recent first)."""
node = self._find_node(prefix)
if node is None:
return []
results: list[tuple[str, int]] = []
self._collect_words(node, prefix, results)
results.sort(key=lambda x: -x[1])
return [word for word, _ in results[:limit]]
def _find_node(self, prefix: str) -> Optional[TrieNode]:
"""Traverse to the node representing the prefix."""
node = self.root
for char in prefix:
if char not in node.children:
return None
node = node.children[char]
return node
def _collect_words(
self, node: TrieNode, prefix: str, results: list[tuple[str, int]]
) -> None:
"""DFS to collect all words under a node."""
if node.is_end:
results.append((prefix, node.last_used))
for char, child in node.children.items():
self._collect_words(child, prefix + char, results)Solution 3: Hybrid Ranking with Top-K Heap A hybrid approach combining frequency and recency with a weighted score. Uses a min-heap to efficiently maintain top-k results during DFS collection, avoiding a full sort.
"""
Trie Autocomplete - Solution 3: Hybrid Ranking with Top-K Heap
Combines frequency and recency using a weighted score.
Uses a heap to efficiently get top-k suggestions.
"""
import heapq
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class TrieNode:
children: dict[str, "TrieNode"] = field(default_factory=dict)
is_end: bool = False
frequency: int = 0
last_used: int = 0
class HybridTrie:
def __init__(self, recency_weight: float = 0.3) -> None:
self.root = TrieNode()
self._timestamp = 0
self._recency_weight = recency_weight
def insert(self, word: str) -> None:
"""Insert a word, updating frequency and recency."""
self._timestamp += 1
node = self.root
for char in word:
if char not in node.children:
node.children[char] = TrieNode()
node = node.children[char]
node.is_end = True
node.frequency += 1
node.last_used = self._timestamp
def search(self, word: str) -> bool:
"""Return True if word exists."""
node = self._find_node(word)
return node is not None and node.is_end
def get_frequency(self, word: str) -> int:
"""Return the frequency of a word, or 0 if not found."""
node = self._find_node(word)
return node.frequency if node and node.is_end else 0
def autocomplete(self, prefix: str, limit: int = 10) -> list[str]:
"""Return top-k words ranked by hybrid score (frequency + recency)."""
node = self._find_node(prefix)
if node is None:
return []
# Use min-heap to track top-k efficiently
heap: list[tuple[float, str]] = []
self._collect_with_heap(node, prefix, heap, limit)
# Extract results in descending order
results = []
while heap:
_, word = heapq.heappop(heap)
results.append(word)
return results[::-1]
def _score(self, node: TrieNode) -> float:
"""Compute hybrid score: weighted combination of frequency and recency."""
freq_score = node.frequency
recency_score = node.last_used / max(1, self._timestamp)
return freq_score + self._recency_weight * recency_score
def _find_node(self, prefix: str) -> Optional[TrieNode]:
"""Traverse to the node representing the prefix."""
node = self.root
for char in prefix:
if char not in node.children:
return None
node = node.children[char]
return node
def _collect_with_heap(
self, node: TrieNode, prefix: str, heap: list[tuple[float, str]], limit: int
) -> None:
"""DFS collecting words, maintaining a min-heap of top-k."""
if node.is_end:
score = self._score(node)
if len(heap) < limit:
heapq.heappush(heap, (score, prefix))
elif score > heap[0][0]:
heapq.heapreplace(heap, (score, prefix))
for char, child in node.children.items():
self._collect_with_heap(child, prefix + char, heap, limit){{/fold}}
Question 11 - Chess Validator
- Difficulty: 5 / 10
- Approximate lines of code: 90 LoC
- Tags: game/simulation
Description
A chess move validator determines whether a proposed move is legal according to the rules of chess. This involves checking piece-specific movement patterns, path blocking for sliding pieces (rook, bishop, queen), and special moves like castling and en passant. The validator does not need to track game state across moves - it validates a single move given the current board position.
The board is represented as an 8x8 grid (row 0-7, col 0-7) with pieces identified by color and type. Key data structures: a dictionary mapping positions to pieces, and optionally castling rights and en passant target square. The core logic involves computing delta (dr, dc) between start and end positions and validating against piece-specific rules.
Part A: Basic Piece Movement
{{fold}}{Problem: Part A}
Implement movement validation for all piece types. Knights move in L-shapes, bishops move diagonally, rooks move in straight lines, queens combine both, kings move one square any direction, and pawns move forward (with initial two-square option).
board = Board(squares={
(0, 4): Piece(WHITE, 'K'), # White king on e1
(1, 4): Piece(WHITE, 'P'), # White pawn on e2
(3, 3): Piece(BLACK, 'N'), # Black knight on d4
})
# Knight: L-shaped moves (2+1 or 1+2)
validate_move(board, (3, 3), (1, 2), BLACK) # d4 to c2: True
validate_move(board, (3, 3), (2, 2), BLACK) # d4 to c3: False (not L-shape)
# Pawn: forward one, or two from starting row
validate_move(board, (1, 4), (2, 4), WHITE) # e2 to e3: True
validate_move(board, (1, 4), (3, 4), WHITE) # e2 to e4: True (initial double)
validate_move(board, (1, 4), (2, 5), WHITE) # e2 to f3: False (diagonal without capture){{/fold}}
Part B: Path Blocking and Captures
{{fold}}{Problem: Part B}
Sliding pieces (rook, bishop, queen) cannot jump over other pieces. Validate that the path between start and end is clear. Also validate that captures target opponent pieces only.
board = Board(squares={
(0, 0): Piece(WHITE, 'R'), # White rook on a1
(0, 3): Piece(WHITE, 'B'), # White bishop on d1 (blocking)
(0, 7): Piece(BLACK, 'R'), # Black rook on h1
})
# Rook blocked by own piece
validate_move(board, (0, 0), (0, 5), WHITE) # a1 to f1: False (blocked by bishop)
validate_move(board, (0, 0), (0, 2), WHITE) # a1 to c1: True (path clear)
# Cannot capture own piece
validate_move(board, (0, 0), (0, 3), WHITE) # a1 to d1: False (own bishop there)
# Can capture opponent piece
board2 = Board(squares={
(0, 0): Piece(WHITE, 'R'),
(0, 5): Piece(BLACK, 'P'),
})
validate_move(board2, (0, 0), (0, 5), WHITE) # a1 to f1: True (captures black pawn){{/fold}}
Part C: Special Moves
{{fold}}{Problem: Part C}
Implement castling (king moves two squares toward rook, rook jumps over), en passant (pawn captures pawn that just moved two squares), and pawn promotion (reaching last rank).
# Castling: King moves 2 squares, path must be clear, rights must exist
board = Board(
squares={(0, 4): Piece(WHITE, 'K'), (0, 7): Piece(WHITE, 'R')},
castling_rights={WHITE: {"kingside": True, "queenside": True}}
)
validate_move(board, (0, 4), (0, 6), WHITE) # e1 to g1 (kingside castle): True
# En passant: capture pawn that just double-moved
board = Board(
squares={(4, 4): Piece(WHITE, 'P'), (4, 5): Piece(BLACK, 'P')},
en_passant_target=(5, 5) # Black pawn just moved d7-d5
)
validate_move(board, (4, 4), (5, 5), WHITE) # e5 to f6 (en passant): True{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- Can a pawn capture forward? (No - only diagonal captures)
- What about pawn double-move when blocked on first square?
- Can you castle through check? Out of check? (No to both)
- En passant is only valid immediately after the double-move
Common mistakes:
- Wrong pawn direction (white moves +row, black moves -row, or vice versa)
- Forgetting path blocking for sliding pieces
- Allowing pawn diagonal move without capture
- Off-by-one in path checking (excluding start but not end, or vice versa)
- Castling through pieces or when king would pass through check
- Not validating that en passant target is actually capturable
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses an object-oriented approach with Position, Piece, and Board dataclasses, dispatching validation based on piece type. Solution 2 takes a functional approach with precomputed move tables for knights/kings and ray-based validation for sliding pieces. Solution 3 provides a compact implementation with generator-based move enumeration and includes check detection. These vary in code organization and whether moves are validated individually or enumerated as a set. Core techniques: delta-based movement patterns, ray casting for sliding pieces, box coordinate calculation.
Solution 1: Object-oriented with piece classes Object-oriented approach with Position, Piece, and Board dataclasses. Board handles path-clear checking with directional iteration. validate_move function dispatches based on piece type.
"""Chess Move Validator - Solution 1: Object-Oriented Approach with Piece Classes"""
from dataclasses import dataclass
from typing import Optional
from enum import Enum
class Color(Enum):
WHITE = "white"
BLACK = "black"
@dataclass
class Position:
row: int # 0-7
col: int # 0-7
def is_valid(self) -> bool:
return 0 <= self.row < 8 and 0 <= self.col < 8
@dataclass
class Piece:
color: Color
piece_type: str # 'K', 'Q', 'R', 'B', 'N', 'P'
@dataclass
class Board:
squares: dict[tuple[int, int], Optional[Piece]]
en_passant_target: Optional[Position] = None
castling_rights: dict[Color, dict[str, bool]] = None
def __post_init__(self):
if self.castling_rights is None:
self.castling_rights = {
Color.WHITE: {"kingside": True, "queenside": True},
Color.BLACK: {"kingside": True, "queenside": True}
}
def get(self, pos: Position) -> Optional[Piece]:
return self.squares.get((pos.row, pos.col))
def is_path_clear(self, start: Position, end: Position) -> bool:
dr = 0 if end.row == start.row else (1 if end.row > start.row else -1)
dc = 0 if end.col == start.col else (1 if end.col > start.col else -1)
r, c = start.row + dr, start.col + dc
while (r, c) != (end.row, end.col):
if self.squares.get((r, c)):
return False
r, c = r + dr, c + dc
return True
def validate_move(board: Board, start: Position, end: Position, color: Color) -> bool:
if not start.is_valid() or not end.is_valid():
return False
piece = board.get(start)
if not piece or piece.color != color:
return False
target = board.get(end)
if target and target.color == color:
return False
dr, dc = end.row - start.row, end.col - start.col
adr, adc = abs(dr), abs(dc)
if piece.piece_type == 'N':
return (adr, adc) in [(1, 2), (2, 1)]
if piece.piece_type == 'B':
return adr == adc and adr > 0 and board.is_path_clear(start, end)
if piece.piece_type == 'R':
return (dr == 0 or dc == 0) and (adr + adc > 0) and board.is_path_clear(start, end)
if piece.piece_type == 'Q':
return ((adr == adc) or (dr == 0 or dc == 0)) and (adr + adc > 0) and board.is_path_clear(start, end)
if piece.piece_type == 'K':
if adr <= 1 and adc <= 1 and (adr + adc > 0):
return True
# Castling
if dr == 0 and adc == 2 and board.castling_rights[color]["kingside" if dc > 0 else "queenside"]:
return board.is_path_clear(start, end)
return False
if piece.piece_type == 'P':
direction = 1 if color == Color.WHITE else -1
start_row = 1 if color == Color.WHITE else 6
if dc == 0 and not target:
if dr == direction:
return True
if dr == 2 * direction and start.row == start_row and board.is_path_clear(start, end):
return True
if adc == 1 and dr == direction:
if target:
return True
if board.en_passant_target and end.row == board.en_passant_target.row and end.col == board.en_passant_target.col:
return True
return False
return FalseSolution 2: Functional with move tables Functional approach with precomputed move tables for knights and kings. Uses ray-based validation for sliding pieces. Compact piece representation as strings like "wK", "bP".
"""Chess Move Validator - Solution 2: Functional Approach with Move Tables"""
from dataclasses import dataclass, field
from typing import Callable
@dataclass(frozen=True)
class Pos:
r: int
c: int
def valid(self) -> bool: return 0 <= self.r < 8 and 0 <= self.c < 8
def __add__(self, other: "Pos") -> "Pos": return Pos(self.r + other.r, self.c + other.c)
@dataclass
class GameState:
board: dict[Pos, str] = field(default_factory=dict) # "wP", "bK", etc.
en_passant: Pos | None = None
castle: set[str] = field(default_factory=lambda: {"wK", "wQ", "bK", "bQ"})
def color(piece: str) -> str: return piece[0]
def ptype(piece: str) -> str: return piece[1]
KNIGHT_MOVES = [Pos(dr, dc) for dr in [-2,-1,1,2] for dc in [-2,-1,1,2] if abs(dr) + abs(dc) == 3]
KING_MOVES = [Pos(dr, dc) for dr in [-1,0,1] for dc in [-1,0,1] if (dr, dc) != (0, 0)]
DIAGONALS = [Pos(d, d) for d in [-1, 1]] + [Pos(d, -d) for d in [-1, 1]]
STRAIGHTS = [Pos(0, 1), Pos(0, -1), Pos(1, 0), Pos(-1, 0)]
def ray_clear(state: GameState, start: Pos, direction: Pos, dist: int) -> bool:
pos = start
for _ in range(dist - 1):
pos = pos + direction
if pos in state.board:
return False
return True
def validate_sliding(state: GameState, start: Pos, end: Pos, dirs: list[Pos]) -> bool:
dr, dc = end.r - start.r, end.c - start.c
for d in dirs:
if d.r * dc == d.c * dr and (d.r == 0 or dr // d.r > 0) and (d.c == 0 or dc // d.c > 0):
dist = max(abs(dr), abs(dc))
if dist > 0 and ray_clear(state, start, d, dist):
return True
return False
def validate_pawn(state: GameState, start: Pos, end: Pos, c: str) -> bool:
fwd = 1 if c == 'w' else -1
home = 1 if c == 'w' else 6
dr, dc = end.r - start.r, end.c - start.c
target = state.board.get(end)
if dc == 0 and not target:
if dr == fwd: return True
if dr == 2 * fwd and start.r == home and Pos(start.r + fwd, start.c) not in state.board:
return True
if abs(dc) == 1 and dr == fwd:
if target and color(target) != c: return True
if end == state.en_passant: return True
return False
def validate_king(state: GameState, start: Pos, end: Pos, c: str) -> bool:
dr, dc = abs(end.r - start.r), abs(end.c - start.c)
if dr <= 1 and dc <= 1 and (dr + dc) > 0:
return True
if dr == 0 and dc == 2: # Castling
side = "K" if end.c > start.c else "Q"
if f"{c}{side}" in state.castle and ray_clear(state, start, Pos(0, 1 if side == "K" else -1), dc):
return True
return False
def validate_move(state: GameState, start: Pos, end: Pos) -> bool:
if not start.valid() or not end.valid(): return False
piece = state.board.get(start)
if not piece: return False
target = state.board.get(end)
if target and color(target) == color(piece): return False
c, pt = color(piece), ptype(piece)
if pt == 'N': return end - start in [(m.r, m.c) for m in KNIGHT_MOVES] or any(start + m == end for m in KNIGHT_MOVES)
if pt == 'B': return validate_sliding(state, start, end, DIAGONALS)
if pt == 'R': return validate_sliding(state, start, end, STRAIGHTS)
if pt == 'Q': return validate_sliding(state, start, end, DIAGONALS + STRAIGHTS)
if pt == 'K': return validate_king(state, start, end, c)
if pt == 'P': return validate_pawn(state, start, end, c)
return FalseSolution 3: Compact with check detection Compact implementation with generator-based move enumeration. Includes check detection (is_valid returns whether a move is legal, find_king locates the king, in_check determines if a color is in check). Uses minimal code with tuple-based positions.
"""Chess Move Validator - Solution 3: Compact with Check/Checkmate Detection"""
from dataclasses import dataclass
from typing import Iterator
@dataclass(frozen=True)
class Sq:
r: int; c: int
def ok(self) -> bool: return 0 <= self.r < 8 and 0 <= self.c < 8
@dataclass
class Chess:
board: dict[tuple[int,int], str] # (r,c) -> "wK", "bP", etc.
ep: tuple[int,int] | None = None # en passant target
castle: set[str] | None = None # "wK","wQ","bK","bQ"
def __post_init__(self):
if self.castle is None: self.castle = {"wK", "wQ", "bK", "bQ"}
def at(self, r: int, c: int) -> str | None: return self.board.get((r, c))
def col(self, p: str) -> str: return p[0]
def typ(self, p: str) -> str: return p[1]
def ray_ok(self, r1: int, c1: int, r2: int, c2: int) -> bool:
dr = (r2 > r1) - (r2 < r1); dc = (c2 > c1) - (c2 < c1)
r, c = r1 + dr, c1 + dc
while (r, c) != (r2, c2):
if self.at(r, c): return False
r, c = r + dr, c + dc
return True
def piece_moves(self, r: int, c: int) -> Iterator[tuple[int,int]]:
p = self.at(r, c)
if not p: return
col, typ = self.col(p), self.typ(p)
opp = 'b' if col == 'w' else 'w'
if typ == 'N':
for dr, dc in [(-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1)]:
nr, nc = r+dr, c+dc
if 0 <= nr < 8 and 0 <= nc < 8:
t = self.at(nr, nc)
if not t or self.col(t) == opp: yield (nr, nc)
elif typ in 'BRQ':
dirs = ([(1,1),(1,-1),(-1,1),(-1,-1)] if typ != 'R' else []) + \
([(0,1),(0,-1),(1,0),(-1,0)] if typ != 'B' else [])
for dr, dc in dirs:
nr, nc = r+dr, c+dc
while 0 <= nr < 8 and 0 <= nc < 8:
t = self.at(nr, nc)
if t:
if self.col(t) == opp: yield (nr, nc)
break
yield (nr, nc); nr, nc = nr+dr, nc+dc
elif typ == 'K':
for dr in [-1,0,1]:
for dc in [-1,0,1]:
if dr or dc:
nr, nc = r+dr, c+dc
if 0 <= nr < 8 and 0 <= nc < 8:
t = self.at(nr, nc)
if not t or self.col(t) == opp: yield (nr, nc)
elif typ == 'P':
fwd = 1 if col == 'w' else -1; home = 1 if col == 'w' else 6
if not self.at(r+fwd, c):
yield (r+fwd, c)
if r == home and not self.at(r+2*fwd, c): yield (r+2*fwd, c)
for dc in [-1, 1]:
nr, nc = r+fwd, c+dc
if 0 <= nc < 8:
t = self.at(nr, nc)
if (t and self.col(t) == opp) or (nr, nc) == self.ep: yield (nr, nc)
def is_valid(self, r1: int, c1: int, r2: int, c2: int) -> bool:
return (r2, c2) in self.piece_moves(r1, c1)
def find_king(self, col: str) -> tuple[int,int]:
for (r, c), p in self.board.items():
if p == f"{col}K": return (r, c)
raise ValueError(f"No {col} king")
def in_check(self, col: str) -> bool:
kr, kc = self.find_king(col)
opp = 'b' if col == 'w' else 'w'
for (r, c), p in self.board.items():
if self.col(p) == opp and (kr, kc) in self.piece_moves(r, c):
return True
return False{{/fold}}
Question 12 - Consistent Hash
- Difficulty: 10 / 10
- Approximate lines of code: 80 LoC
- Tags: distributed-systems, data-structures
Description
Consistent hashing is the algorithm used by distributed systems like Cassandra, DynamoDB, and memcached to distribute data across nodes with minimal remapping when nodes join or leave. The key insight: when a node is added or removed, only K/n keys need to move (where K is total keys and n is number of nodes), compared to traditional hashing where nearly all keys would remap.
The core data structure is a "hash ring" - imagine a circle from 0 to 2^32. Nodes are placed at positions determined by hashing their IDs. To find which node owns a key, hash the key and walk clockwise until you hit a node. Internal state is a sorted list of (hash_position, node_id) pairs plus a dict mapping hash positions to node names for O(1) lookup after binary search.
Note: The
sortedcontainerslibrary (SortedList,SortedDict) is available and can simplify this problem. UsingSortedListinstead ofbisect.insort+ list gives O(log n) insertions/deletions instead of O(n).
Part A: Basic Ring
{{fold}}{Problem: Part A}
Implement add_node(node_id), remove_node(node_id), and get_node(key). Use a stable hash function (MD5 or SHA - not Python's hash() which varies between runs). Store positions in a sorted list for binary search.
ring = ConsistentHashRing()
ring.add_node("server1")
ring.add_node("server2")
# Internal state after adding nodes:
# _sorted_keys = [1847293, 2938471] # sorted hash positions
# _ring = {1847293: "server1", 2938471: "server2"}
ring.get_node("user:1001") # -> "server2"
# hash("user:1001") = 2103847
# binary search finds first position >= 2103847
# returns "server2"
ring.get_node("session:xyz") # -> "server1"
# hash("session:xyz") = 3999999
# > all positions, so wrap to first node "server1"{{/fold}}
Part B: Virtual Nodes
{{fold}}{Problem: Part B}
With few physical nodes, keys distribute unevenly. Solution: give each physical node multiple "virtual node" positions on the ring (typically 100-200). Hash "server1#vn0", "server1#vn1", etc. to spread each server across the ring.
ring = ConsistentHashRing(num_virtual_nodes=100)
ring.add_node("server1")
ring.add_node("server2")
# Internal state now has 200 entries (100 per server):
# _sorted_keys = [12847, 38291, 49182, ...] # 200 positions
# _ring = {12847: "server1", 38291: "server2", 49182: "server1", ...}
# get_node() works identically - lookup returns physical node name
ring.get_node("key123") # -> "server1"{{/fold}}
Part C: Efficient Lookup
{{fold}}{Problem: Part C}
Use bisect.bisect_right() for O(log n) lookup instead of linear scan. Handle the wrap-around case: when a key's hash exceeds all node positions, wrap to index 0.
def get_node(self, key: str) -> str:
hash_val = self._hash(key)
idx = bisect.bisect_right(self._sorted_keys, hash_val)
# Wrap around if past the end
if idx == len(self._sorted_keys):
idx = 0
return self._ring[self._sorted_keys[idx]]{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when you call
get_node()on an empty ring? - What if you add the same node twice?
- What if hash produces a collision with an existing virtual node?
- How do you handle the wrap-around at the end of the ring?
Common mistakes:
- Using
bisect_leftinstead ofbisect_rightwith wrong boundary handling - Forgetting wrap-around case (IndexError when hash > all positions)
- Using Python's
hash()which is non-deterministic across runs - Not handling duplicate
add_nodecalls gracefully - O(n) removal by iterating sorted list instead of tracking virtual node positions
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses a basic sorted list with bisect.insort for insertion and binary search for lookup. Solution 2 leverages SortedDict from sortedcontainers for cleaner code and adds migration tracking to report which key ranges move when nodes change. Solution 3 extends consistent hashing to support replication, returning N distinct physical nodes for fault-tolerant storage. Core techniques: binary search, hash functions (MD5/SHA), virtual nodes for load balancing.
Solution 1: Basic sorted list with bisect Basic implementation using a sorted list with bisect.insort for O(log n) insertion and binary search for lookup. Virtual nodes are generated with a consistent naming scheme (node#vnN). Clean dataclass-based design.
"""
Consistent Hashing Ring - Solution 1: Basic Implementation
Uses a sorted list and binary search for node lookup.
"""
from dataclasses import dataclass, field
from typing import Optional
import hashlib
import bisect
@dataclass
class ConsistentHashRing:
"""A consistent hashing ring with virtual nodes for load balancing."""
num_virtual_nodes: int = 100
_ring: dict[int, str] = field(default_factory=dict)
_sorted_keys: list[int] = field(default_factory=list)
_nodes: set[str] = field(default_factory=set)
def _hash(self, key: str) -> int:
"""Generate a hash position on the ring (0 to 2^32 - 1)."""
return int(hashlib.md5(key.encode()).hexdigest(), 16) % (2**32)
def _virtual_node_key(self, node: str, replica: int) -> str:
"""Generate a unique key for a virtual node."""
return f"{node}#vn{replica}"
def add_node(self, node: str) -> None:
"""Add a node with its virtual nodes to the ring."""
if node in self._nodes:
return
self._nodes.add(node)
for i in range(self.num_virtual_nodes):
vn_key = self._virtual_node_key(node, i)
hash_val = self._hash(vn_key)
self._ring[hash_val] = node
bisect.insort(self._sorted_keys, hash_val)
def remove_node(self, node: str) -> None:
"""Remove a node and all its virtual nodes from the ring."""
if node not in self._nodes:
return
self._nodes.discard(node)
for i in range(self.num_virtual_nodes):
vn_key = self._virtual_node_key(node, i)
hash_val = self._hash(vn_key)
if hash_val in self._ring:
del self._ring[hash_val]
self._sorted_keys.remove(hash_val)
def get_node(self, key: str) -> Optional[str]:
"""Find the node responsible for a given key."""
if not self._ring:
return None
hash_val = self._hash(key)
idx = bisect.bisect_right(self._sorted_keys, hash_val)
# Wrap around to the first node if past the last
if idx == len(self._sorted_keys):
idx = 0
return self._ring[self._sorted_keys[idx]]
def get_nodes(self) -> set[str]:
"""Return all physical nodes in the ring."""
return self._nodes.copy()Solution 2: SortedDict with migration tracking Uses SortedDict from sortedcontainers for cleaner code. Adds migration tracking: add_node() and remove_node() return lists of key ranges that moved between nodes, useful for triggering data rebalancing.
"""
Consistent Hashing Ring - Solution 2: Using SortedDict
Leverages sortedcontainers for cleaner code and better performance.
Falls back to a manual implementation if sortedcontainers unavailable.
"""
from dataclasses import dataclass, field
from typing import Optional
import hashlib
try:
from sortedcontainers import SortedDict
HAS_SORTED_CONTAINERS = True
except ImportError:
HAS_SORTED_CONTAINERS = False
@dataclass
class ConsistentHashRing:
"""Consistent hashing using SortedDict for O(log n) operations."""
virtual_nodes: int = 150
_ring: "SortedDict[int, str]" = field(default_factory=lambda: SortedDict())
_physical_nodes: set[str] = field(default_factory=set)
def _hash(self, key: str) -> int:
"""Hash using SHA-256 for better distribution than MD5."""
digest = hashlib.sha256(key.encode()).hexdigest()
return int(digest[:16], 16) # Use first 64 bits
def add_node(self, node: str) -> list[tuple[str, str, str]]:
"""Add node, return list of (key_range_start, old_node, new_node) migrations."""
if node in self._physical_nodes:
return []
self._physical_nodes.add(node)
migrations = []
for i in range(self.virtual_nodes):
vnode_hash = self._hash(f"{node}:{i}")
if vnode_hash in self._ring:
continue # Hash collision, skip
# Find what node previously owned this position
idx = self._ring.bisect_right(vnode_hash)
if idx < len(self._ring):
old_owner = self._ring.values()[idx]
migrations.append((str(vnode_hash), old_owner, node))
self._ring[vnode_hash] = node
return migrations
def remove_node(self, node: str) -> list[tuple[str, str, str]]:
"""Remove node, return migrations to successor nodes."""
if node not in self._physical_nodes:
return []
self._physical_nodes.discard(node)
migrations = []
keys_to_remove = []
for hash_val, owner in self._ring.items():
if owner == node:
keys_to_remove.append(hash_val)
for hash_val in keys_to_remove:
del self._ring[hash_val]
# Find new owner
idx = self._ring.bisect_right(hash_val)
if len(self._ring) > 0:
new_owner = self._ring.values()[idx % len(self._ring)]
migrations.append((str(hash_val), node, new_owner))
return migrations
def get_node(self, key: str) -> Optional[str]:
"""Get the node responsible for this key."""
if not self._ring:
return None
key_hash = self._hash(key)
idx = self._ring.bisect_right(key_hash)
if idx == len(self._ring):
idx = 0
return self._ring.values()[idx]
def get_node_count(self, sample_keys: int = 10000) -> dict[str, int]:
"""Sample key distribution across nodes."""
counts: dict[str, int] = {node: 0 for node in self._physical_nodes}
for i in range(sample_keys):
node = self.get_node(f"sample_key_{i}")
if node:
counts[node] += 1
return countsSolution 3: Replication support Extends basic consistent hashing to support replication. get_nodes_for_key(key, count=N) returns N distinct physical nodes by walking clockwise and skipping duplicate physical nodes (from virtual nodes). Essential for fault-tolerant storage where you want multiple replicas.
"""
Consistent Hashing Ring - Solution 3: With Replication Support
Extends basic consistent hashing to return N replicas for fault tolerance.
"""
from dataclasses import dataclass, field
from typing import Optional
import hashlib
import bisect
@dataclass
class ReplicatedHashRing:
"""Consistent hash ring that supports fetching multiple replica nodes."""
virtual_nodes: int = 100
default_replicas: int = 3
_ring: dict[int, str] = field(default_factory=dict)
_sorted_hashes: list[int] = field(default_factory=list)
_nodes: set[str] = field(default_factory=set)
def _hash(self, key: str) -> int:
"""Compute hash using xxhash-style mixing for speed simulation."""
# Using SHA-1 truncated; in production use xxhash or similar
return int(hashlib.sha1(key.encode()).hexdigest()[:8], 16)
def add_node(self, node: str) -> None:
"""Add a physical node with virtual replicas."""
if node in self._nodes:
return
self._nodes.add(node)
for i in range(self.virtual_nodes):
h = self._hash(f"{node}:vn:{i}")
if h not in self._ring: # Avoid collisions
self._ring[h] = node
bisect.insort(self._sorted_hashes, h)
def remove_node(self, node: str) -> None:
"""Remove a node and its virtual nodes."""
if node not in self._nodes:
return
self._nodes.discard(node)
to_remove = [h for h, n in self._ring.items() if n == node]
for h in to_remove:
del self._ring[h]
self._sorted_hashes.remove(h)
def get_node(self, key: str) -> Optional[str]:
"""Get single node for a key."""
nodes = self.get_nodes_for_key(key, count=1)
return nodes[0] if nodes else None
def get_nodes_for_key(self, key: str, count: Optional[int] = None) -> list[str]:
"""Get N distinct physical nodes for replication."""
if not self._ring:
return []
count = count or self.default_replicas
count = min(count, len(self._nodes)) # Can't exceed physical nodes
key_hash = self._hash(key)
start_idx = bisect.bisect_right(self._sorted_hashes, key_hash)
result: list[str] = []
seen: set[str] = set()
for i in range(len(self._sorted_hashes)):
idx = (start_idx + i) % len(self._sorted_hashes)
node = self._ring[self._sorted_hashes[idx]]
if node not in seen:
result.append(node)
seen.add(node)
if len(result) == count:
break
return result
def get_ring_state(self) -> list[tuple[int, str]]:
"""Debug: return sorted (hash, node) pairs."""
return [(h, self._ring[h]) for h in self._sorted_hashes]{{/fold}}
Question 13 - DNS Cache
- Difficulty: 4 / 10
- Approximate lines of code: 70 LoC
- Tags: storage
Description
A DNS cache stores domain-to-IP mappings to avoid repeated network lookups. Each record has a TTL (time-to-live) after which it expires. The cache must handle three things: TTL-based expiration, capacity limits (evicting old entries when full), and CNAME chains (aliases that point to other domains which may themselves be aliases).
Internal state is typically a dict mapping domain names to cache entries. Each entry contains the IP address (or CNAME target), the expiration timestamp, and optionally the record type. For LRU eviction, use an OrderedDict where accessing an entry moves it to the end, and eviction removes from the front.
Part A: TTL-Based Caching
{{fold}}{Problem: Part A}
Implement basic DNS caching with time-to-live expiration. resolve(domain) checks the cache first, falling back to a recursive lookup on miss or expiration.
cache = DNSCache(default_ttl=300) # 5 minute TTL
# First lookup - cache miss, performs recursive resolution
ip = cache.resolve("example.com")
# cache: {"example.com": CacheEntry(ip="93.184.216.34", expires_at=now+300)}
# Second lookup - cache hit
ip = cache.resolve("example.com") # Returns instantly from cache
# Manual record insertion with custom TTL
cache.add_record("internal.corp", "10.0.0.1", ttl=60)
# After TTL expires, entry is stale
time.sleep(301)
cache.resolve("example.com") # Cache miss - expired entry removed, fresh lookup{{/fold}}
Part B: LRU Eviction
{{fold}}{Problem: Part B}
Add a maximum cache size. When inserting into a full cache, evict the least recently used entry. Accessing an entry (even a cache hit) should update its recency.
cache = LRUDNSCache(max_size=3, default_ttl=300)
cache.set_record("a.com", "1.1.1.1")
cache.set_record("b.com", "2.2.2.2")
cache.set_record("c.com", "3.3.3.3")
# Cache order (LRU to MRU): [a.com, b.com, c.com]
cache.resolve("a.com") # Access a.com, moves to MRU position
# Cache order: [b.com, c.com, a.com]
cache.set_record("d.com", "4.4.4.4") # Cache full, evict LRU (b.com)
# Cache order: [c.com, a.com, d.com]
# b.com is evicted
assert "b.com" not in cache # Evicted
assert "a.com" in cache # Kept (was recently accessed){{/fold}}
Part C: CNAME Chain Resolution
{{fold}}{Problem: Part C}
Handle CNAME (canonical name) records that alias one domain to another. When resolving, follow the chain until you reach an A record. Protect against infinite loops.
# DNS data:
# www.example.com -> CNAME -> example.com
# blog.example.com -> CNAME -> www.example.com
# example.com -> A -> 93.184.216.34
cache = HierarchicalDNSCache(max_cname_depth=10)
ip = cache.resolve("blog.example.com")
# 1. Lookup blog.example.com -> CNAME www.example.com
# 2. Lookup www.example.com -> CNAME example.com
# 3. Lookup example.com -> A 93.184.216.34
# Returns: 93.184.216.34
# All records are cached:
# (blog.example.com, CNAME) -> www.example.com
# (www.example.com, CNAME) -> example.com
# (example.com, A) -> 93.184.216.34
# Loop protection:
# evil.com -> CNAME -> evil.com (would loop forever)
cache.resolve("evil.com") # Returns None after max_cname_depth iterations{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when resolving a domain that doesn't exist?
- How do you handle CNAME loops (A -> B -> A)?
- What if a CNAME points to another CNAME with a shorter TTL?
- How do you evict entries - lazily on access or proactively?
Common mistakes:
- Not removing expired entries from cache (just returning None isn't enough)
- Infinite loop on CNAME chains without depth limiting
- Using system clock that can jump (use monotonic time for TTL calculations)
- Storing CNAME target IP instead of following the chain
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 is a simple TTL-based cache using dict storage with lazy expiration (entries removed on access after expiry). Solution 2 adds LRU eviction with a max capacity using OrderedDict for O(1) LRU operations via move_to_end() and popitem(). Solution 3 handles hierarchical DNS with CNAME chain resolution, using (domain, record_type) tuple keys and depth limiting to prevent infinite loops. These vary in their eviction strategy and DNS complexity: Solution 1 handles basic TTL, Solution 2 adds capacity management, and Solution 3 models realistic DNS behavior. Core techniques: TTL-based expiration, OrderedDict for LRU, CNAME chain following with depth limiting, lazy vs proactive eviction.
Solution 1: Simple TTL-based Cache Simple TTL-based cache with dict storage. Stores expiration timestamp directly in each entry. Lazy expiration - entries are removed when accessed after expiry. Includes manual evict_expired() for batch cleanup.
"""
DNS Cache Solution 1: Simple TTL-based cache with dict storage.
Focuses on correctness and simplicity.
"""
from dataclasses import dataclass, field
from typing import Optional
import time
@dataclass
class CacheEntry:
ip_address: str
expires_at: float
@dataclass
class DNSCache:
cache: dict[str, CacheEntry] = field(default_factory=dict)
default_ttl: int = 300 # 5 minutes
def resolve(self, domain: str) -> Optional[str]:
"""Resolve domain to IP, checking cache first."""
entry = self.cache.get(domain)
if entry and entry.expires_at > time.time():
return entry.ip_address
# Cache miss or expired - do recursive resolution
if entry:
del self.cache[domain]
ip = self._recursive_resolve(domain)
if ip:
self.cache[domain] = CacheEntry(
ip_address=ip,
expires_at=time.time() + self.default_ttl
)
return ip
def _recursive_resolve(self, domain: str) -> Optional[str]:
"""Simulate recursive DNS resolution."""
# In real implementation, this would query DNS servers
fake_dns = {
"example.com": "93.184.216.34",
"google.com": "142.250.80.46",
"github.com": "140.82.114.4",
}
return fake_dns.get(domain)
def add_record(self, domain: str, ip: str, ttl: Optional[int] = None) -> None:
"""Manually add a DNS record to cache."""
self.cache[domain] = CacheEntry(
ip_address=ip,
expires_at=time.time() + (ttl or self.default_ttl)
)
def evict_expired(self) -> int:
"""Remove all expired entries. Returns count of evicted entries."""
now = time.time()
expired = [d for d, e in self.cache.items() if e.expires_at <= now]
for domain in expired:
del self.cache[domain]
return len(expired)Solution 2: LRU Eviction with Max Capacity LRU eviction with max capacity using OrderedDict. move_to_end() on access maintains LRU ordering. popitem(last=False) evicts the oldest entry. Combines TTL expiration with capacity-based eviction.
"""
DNS Cache Solution 2: LRU eviction with max capacity.
Uses OrderedDict for O(1) LRU operations.
"""
from dataclasses import dataclass, field
from collections import OrderedDict
from typing import Optional
import time
@dataclass
class DNSRecord:
ip_address: str
ttl: int
created_at: float
def is_expired(self) -> bool:
return time.time() > self.created_at + self.ttl
@dataclass
class LRUDNSCache:
max_size: int = 1000
default_ttl: int = 300
_cache: OrderedDict[str, DNSRecord] = field(default_factory=OrderedDict)
def resolve(self, domain: str) -> Optional[str]:
"""Resolve with LRU tracking."""
if domain in self._cache:
record = self._cache[domain]
if record.is_expired():
del self._cache[domain]
else:
# Move to end (most recently used)
self._cache.move_to_end(domain)
return record.ip_address
# Cache miss - resolve and cache
ip = self._recursive_resolve(domain)
if ip:
self._add_to_cache(domain, ip, self.default_ttl)
return ip
def _add_to_cache(self, domain: str, ip: str, ttl: int) -> None:
"""Add entry, evicting LRU if at capacity."""
if domain in self._cache:
del self._cache[domain]
elif len(self._cache) >= self.max_size:
self._cache.popitem(last=False) # Remove oldest (LRU)
self._cache[domain] = DNSRecord(
ip_address=ip,
ttl=ttl,
created_at=time.time()
)
def _recursive_resolve(self, domain: str) -> Optional[str]:
"""Simulate DNS lookup."""
records = {
"example.com": "93.184.216.34",
"google.com": "142.250.80.46",
"github.com": "140.82.114.4",
}
return records.get(domain)
def set_record(self, domain: str, ip: str, ttl: Optional[int] = None) -> None:
"""Manually set a DNS record."""
self._add_to_cache(domain, ip, ttl or self.default_ttl)
def size(self) -> int:
return len(self._cache)Solution 3: Hierarchical DNS with CNAME Chains Hierarchical DNS with CNAME chain resolution. Cache keys are (domain, record_type) tuples to store both A and CNAME records. Recursive resolution with depth limiting prevents infinite loops. Follows CNAME chains until reaching an A record.
"""
DNS Cache Solution 3: Hierarchical DNS with multiple record types.
More realistic simulation of DNS resolution chain.
"""
from dataclasses import dataclass, field
from typing import Optional
from enum import Enum
import time
class RecordType(Enum):
A = "A" # IPv4 address
CNAME = "CNAME" # Canonical name (alias)
@dataclass
class DNSRecord:
record_type: RecordType
value: str
ttl: int
expires_at: float
@dataclass
class HierarchicalDNSCache:
cache: dict[tuple[str, RecordType], DNSRecord] = field(default_factory=dict)
default_ttl: int = 300
max_cname_depth: int = 10 # Prevent infinite loops
def resolve(self, domain: str) -> Optional[str]:
"""Resolve domain, following CNAME chains."""
return self._resolve_with_depth(domain, 0)
def _resolve_with_depth(self, domain: str, depth: int) -> Optional[str]:
if depth > self.max_cname_depth:
return None # CNAME loop protection
# Check for A record first
a_record = self._get_cached(domain, RecordType.A)
if a_record:
return a_record.value
# Check for CNAME and follow it
cname = self._get_cached(domain, RecordType.CNAME)
if cname:
return self._resolve_with_depth(cname.value, depth + 1)
# Cache miss - do recursive lookup
record = self._recursive_lookup(domain)
if not record:
return None
self._cache_record(domain, record)
if record.record_type == RecordType.A:
return record.value
else: # CNAME - follow the chain
return self._resolve_with_depth(record.value, depth + 1)
def _get_cached(self, domain: str, rtype: RecordType) -> Optional[DNSRecord]:
key = (domain, rtype)
record = self.cache.get(key)
if record and record.expires_at > time.time():
return record
if record:
del self.cache[key]
return None
def _cache_record(self, domain: str, record: DNSRecord) -> None:
self.cache[(domain, record.record_type)] = record
def _recursive_lookup(self, domain: str) -> Optional[DNSRecord]:
"""Simulate authoritative DNS response."""
dns_data = {
"example.com": (RecordType.A, "93.184.216.34"),
"www.example.com": (RecordType.CNAME, "example.com"),
"blog.example.com": (RecordType.CNAME, "www.example.com"),
"google.com": (RecordType.A, "142.250.80.46"),
}
if domain not in dns_data:
return None
rtype, value = dns_data[domain]
return DNSRecord(
record_type=rtype,
value=value,
ttl=self.default_ttl,
expires_at=time.time() + self.default_ttl
){{/fold}}
Question 14 - Pub/Sub Message Broker
- Difficulty: 7 / 10
- Approximate lines of code: 90 LoC
- Tags: distributed-systems
Description
A publish-subscribe message broker decouples message producers from consumers. Publishers send messages to topics without knowing who will receive them; subscribers register interest in topics and receive matching messages. This pattern is fundamental to event-driven architectures, microservices communication, and real-time systems.
There are two main delivery models: push (broker calls subscriber callbacks immediately) and pull (subscribers request messages on demand). Each message gets a sequence number for ordering. For reliability, the broker may retain messages so disconnected subscribers can catch up. Consumer groups add load balancing - within a group, each message goes to only one member.
Part A: Basic Pub/Sub
{{fold}}{Problem: Part A}
Implement create_topic(), subscribe(topic, subscriber_id, callback), and publish(topic, payload). Messages are pushed to subscriber callbacks immediately.
broker = PubSubBroker()
broker.create_topic("news")
received = []
def on_message(msg):
received.append(msg.payload)
broker.subscribe("news", "sub1", on_message)
broker.publish("news", "Hello World") # Returns sequence number 1
print(received) # ["Hello World"]
broker.publish("news", "Second message") # Returns 2
print(received) # ["Hello World", "Second message"]Internal state:
topics: {"news": [Message(seq=1, "Hello World"), Message(seq=2, "Second message")]}
subscribers: {"news": {"sub1": Subscriber(callback=on_message, connected=True)}}
sequence: {"news": 2}{{/fold}}
Part B: Message History and Catch-up
{{fold}}{Problem: Part B}
Add sequence numbers and message retention. Subscribers can reconnect and catch up from where they left off (pull model).
broker = PubSubBroker()
broker.create_topic("events")
broker.subscribe("events", "sub1")
broker.publish("events", "msg1") # seq=1
broker.publish("events", "msg2") # seq=2
broker.publish("events", "msg3") # seq=3
# Pull model - subscriber controls when to receive
msgs = broker.pull("events", "sub1", max_messages=2)
# Returns [msg1, msg2], updates sub1's last_read to 2
print(broker.get_pending_count("events", "sub1")) # 1 (msg3 pending)
# After disconnect/reconnect, subscriber catches up:
broker.disconnect("sub1")
broker.publish("events", "msg4") # Subscriber is offline
broker.reconnect("sub1")
msgs = broker.pull("events", "sub1") # Gets msg3 and msg4{{/fold}}
Part C: Consumer Groups
{{fold}}{Problem: Part C}
Within a consumer group, each message is delivered to exactly one member (round-robin load balancing). Individual subscribers still receive all messages.
broker = PubSubBroker()
broker.create_topic("orders")
# Individual subscriber gets ALL messages
monitor_msgs = []
broker.subscribe("monitor", "orders", lambda m: monitor_msgs.append(m))
# Consumer group - messages load balanced
worker1_msgs = []
worker2_msgs = []
broker.join_group("worker1", "orders", "processors", lambda m: worker1_msgs.append(m))
broker.join_group("worker2", "orders", "processors", lambda m: worker2_msgs.append(m))
for i in range(4):
broker.publish("orders", f"order_{i}")
print(len(monitor_msgs)) # 4 - monitor gets all
print(len(worker1_msgs) + len(worker2_msgs)) # 4 - split between workers
# Each worker gets ~2 messages (round-robin){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if you publish to a non-existent topic?
- What if a subscriber callback raises an exception?
- How do you handle unsubscribe during iteration?
- What's the memory impact of unbounded message retention?
Common mistakes:
- Mutating subscriber list while iterating (ConcurrentModificationException)
- Not handling disconnected subscribers (should skip, not crash)
- Memory leaks from infinite message retention (need TTL or compaction)
- Sequence numbers resetting on restart (need persistence for durability)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 is a simple push model that immediately invokes subscriber callbacks on publish. Solution 2 is a pull model with message retention and read position tracking per subscriber. Solution 3 is a hybrid push/pull with consumer groups for load-balanced delivery. These vary in their delivery model (push vs pull) and subscriber grouping. Core techniques: callback dispatch, sequence number tracking, round-robin load balancing.
Solution 1: Simple push model Simple push model with callbacks. Messages stored per topic with sequence numbers. Subscribers can connect/disconnect. Immediately invokes callbacks on publish.
"""
Pub/Sub Message Broker - Solution 1: Simple In-Memory with Push Model
Basic implementation using callbacks for message delivery.
Subscribers register callbacks that are invoked when messages are published.
"""
from dataclasses import dataclass, field
from typing import Callable, Dict, List, Set
from collections import defaultdict
@dataclass
class Message:
topic: str
payload: str
sequence: int = 0
@dataclass
class Subscriber:
id: str
callback: Callable[[Message], None]
connected: bool = True
@dataclass
class PubSubBroker:
_topics: Dict[str, List[Message]] = field(default_factory=lambda: defaultdict(list))
_subscribers: Dict[str, Dict[str, Subscriber]] = field(default_factory=lambda: defaultdict(dict))
_sequence: Dict[str, int] = field(default_factory=lambda: defaultdict(int))
def create_topic(self, topic: str) -> None:
if topic not in self._topics:
self._topics[topic] = []
self._sequence[topic] = 0
def subscribe(self, topic: str, subscriber_id: str, callback: Callable[[Message], None]) -> bool:
if topic not in self._topics:
return False
self._subscribers[topic][subscriber_id] = Subscriber(id=subscriber_id, callback=callback)
return True
def unsubscribe(self, topic: str, subscriber_id: str) -> bool:
if topic in self._subscribers and subscriber_id in self._subscribers[topic]:
del self._subscribers[topic][subscriber_id]
return True
return False
def disconnect(self, subscriber_id: str) -> None:
for topic_subs in self._subscribers.values():
if subscriber_id in topic_subs:
topic_subs[subscriber_id].connected = False
def reconnect(self, subscriber_id: str) -> None:
for topic_subs in self._subscribers.values():
if subscriber_id in topic_subs:
topic_subs[subscriber_id].connected = True
def publish(self, topic: str, payload: str) -> int:
if topic not in self._topics:
return -1
self._sequence[topic] += 1
msg = Message(topic=topic, payload=payload, sequence=self._sequence[topic])
self._topics[topic].append(msg)
# Push to connected subscribers
for sub in self._subscribers[topic].values():
if sub.connected:
sub.callback(msg)
return msg.sequenceSolution 2: Pull model with retention Pull model with message retention. Tracks read position per subscriber. Supports catching up on missed messages after disconnect/reconnect. Includes pending count tracking.
"""
Pub/Sub Message Broker - Solution 2: Pull Model with Message Retention
Subscribers pull messages on demand. Tracks read position per subscriber.
Supports catching up on missed messages after reconnect.
"""
from dataclasses import dataclass, field
from typing import Dict, List, Optional
from collections import defaultdict
@dataclass
class Message:
topic: str
payload: str
sequence: int
@dataclass
class SubscriberState:
id: str
last_read: int = 0 # Last sequence number read
connected: bool = True
@dataclass
class PubSubBroker:
_messages: Dict[str, List[Message]] = field(default_factory=lambda: defaultdict(list))
_subscribers: Dict[str, Dict[str, SubscriberState]] = field(default_factory=lambda: defaultdict(dict))
_sequence: Dict[str, int] = field(default_factory=lambda: defaultdict(int))
def create_topic(self, topic: str) -> None:
if topic not in self._messages:
self._messages[topic] = []
def subscribe(self, topic: str, subscriber_id: str, from_beginning: bool = False) -> bool:
if topic not in self._messages:
return False
start_pos = 0 if from_beginning else self._sequence[topic]
self._subscribers[topic][subscriber_id] = SubscriberState(id=subscriber_id, last_read=start_pos)
return True
def unsubscribe(self, topic: str, subscriber_id: str) -> bool:
if topic in self._subscribers and subscriber_id in self._subscribers[topic]:
del self._subscribers[topic][subscriber_id]
return True
return False
def disconnect(self, subscriber_id: str) -> None:
for topic_subs in self._subscribers.values():
if subscriber_id in topic_subs:
topic_subs[subscriber_id].connected = False
def reconnect(self, subscriber_id: str) -> None:
for topic_subs in self._subscribers.values():
if subscriber_id in topic_subs:
topic_subs[subscriber_id].connected = True
def publish(self, topic: str, payload: str) -> int:
if topic not in self._messages:
return -1
self._sequence[topic] += 1
msg = Message(topic=topic, payload=payload, sequence=self._sequence[topic])
self._messages[topic].append(msg)
return msg.sequence
def pull(self, topic: str, subscriber_id: str, max_messages: int = 10) -> List[Message]:
if topic not in self._subscribers or subscriber_id not in self._subscribers[topic]:
return []
state = self._subscribers[topic][subscriber_id]
if not state.connected:
return []
# Find messages after last_read
result = []
for msg in self._messages[topic]:
if msg.sequence > state.last_read:
result.append(msg)
if len(result) >= max_messages:
break
if result:
state.last_read = result[-1].sequence
return result
def get_pending_count(self, topic: str, subscriber_id: str) -> int:
if topic not in self._subscribers or subscriber_id not in self._subscribers[topic]:
return 0
state = self._subscribers[topic][subscriber_id]
return self._sequence[topic] - state.last_readSolution 3: Hybrid with consumer groups Hybrid push/pull with consumer groups. Individual subscribers get all messages; consumer group members get round-robin distribution. Includes message acknowledgment for reliable delivery.
"""
Pub/Sub Message Broker - Solution 3: Hybrid Push/Pull with Consumer Groups
Features:
- Consumer groups for load balancing (each message delivered to one group member)
- Individual subscribers get all messages
- Message acknowledgment for reliable delivery
"""
from dataclasses import dataclass, field
from typing import Callable, Dict, List, Optional, Set
from collections import defaultdict
import itertools
@dataclass
class Message:
topic: str
payload: str
sequence: int
@dataclass
class ConsumerGroup:
name: str
members: List[str] = field(default_factory=list)
pending: Dict[int, str] = field(default_factory=dict) # seq -> assigned_member
last_delivered: int = 0
_round_robin: int = 0
def next_member(self) -> Optional[str]:
connected = [m for m in self.members]
if not connected:
return None
self._round_robin = (self._round_robin + 1) % len(connected)
return connected[self._round_robin]
@dataclass
class PubSubBroker:
_messages: Dict[str, List[Message]] = field(default_factory=lambda: defaultdict(list))
_individual_subs: Dict[str, Set[str]] = field(default_factory=lambda: defaultdict(set))
_consumer_groups: Dict[str, Dict[str, ConsumerGroup]] = field(default_factory=lambda: defaultdict(dict))
_callbacks: Dict[str, Callable[[Message], None]] = field(default_factory=dict)
_sequence: Dict[str, int] = field(default_factory=lambda: defaultdict(int))
def create_topic(self, topic: str) -> None:
if topic not in self._messages:
self._messages[topic] = []
def subscribe(self, subscriber_id: str, topic: str, callback: Callable[[Message], None]) -> bool:
if topic not in self._messages:
return False
self._individual_subs[topic].add(subscriber_id)
self._callbacks[subscriber_id] = callback
return True
def join_group(self, subscriber_id: str, topic: str, group_name: str,
callback: Callable[[Message], None]) -> bool:
if topic not in self._messages:
return False
if group_name not in self._consumer_groups[topic]:
self._consumer_groups[topic][group_name] = ConsumerGroup(name=group_name)
group = self._consumer_groups[topic][group_name]
if subscriber_id not in group.members:
group.members.append(subscriber_id)
self._callbacks[subscriber_id] = callback
return True
def leave_group(self, subscriber_id: str, topic: str, group_name: str) -> bool:
if group_name in self._consumer_groups[topic]:
group = self._consumer_groups[topic][group_name]
if subscriber_id in group.members:
group.members.remove(subscriber_id)
return True
return False
def publish(self, topic: str, payload: str) -> int:
if topic not in self._messages:
return -1
self._sequence[topic] += 1
msg = Message(topic=topic, payload=payload, sequence=self._sequence[topic])
self._messages[topic].append(msg)
# Push to individual subscribers
for sub_id in self._individual_subs[topic]:
if sub_id in self._callbacks:
self._callbacks[sub_id](msg)
# Push to one member per consumer group (round-robin)
for group in self._consumer_groups[topic].values():
member = group.next_member()
if member and member in self._callbacks:
group.pending[msg.sequence] = member
self._callbacks[member](msg)
return msg.sequence
def ack(self, topic: str, group_name: str, sequence: int) -> bool:
if group_name in self._consumer_groups[topic]:
group = self._consumer_groups[topic][group_name]
if sequence in group.pending:
del group.pending[sequence]
return True
return False{{/fold}}
Question 15 - Reader-Writer Lock
- Difficulty: 9 / 10
- Approximate lines of code: 60 LoC
- Tags: concurrency
Description
{{fold}}{Concurrency Cheat Sheet}
This problem involves concurrency. Here is a cheat sheet of relevant Python syntax. You may not need all of these; this list is not exhaustive or suggestive for the problem.
# threading.Thread
t = threading.Thread(target=func, args=(arg1, arg2))
t.start()
t.join()
# threading.Lock
lock = threading.Lock()
lock.acquire()
lock.release()
with lock:
# critical section
# threading.Condition
cond = threading.Condition(lock) # or threading.Condition()
with cond:
cond.wait() # releases lock, waits, re-acquires
cond.notify() # wake one waiter
cond.notify_all() # wake all waiters
# threading.Semaphore
sem = threading.Semaphore(value=1)
sem.acquire()
sem.release()
# threading.Event
event = threading.Event()
event.set() # set flag to True
event.clear() # set flag to False
event.wait() # block until flag is True
event.is_set() # check flag
# threading.RLock (reentrant)
rlock = threading.RLock()
rlock.acquire() # can acquire multiple times from same thread
rlock.release() # must release same number of times{{/fold}}
A reader-writer lock (RWLock) allows concurrent read access but exclusive write access. Multiple readers can hold the lock simultaneously since reads don't conflict, but writers need exclusive access to prevent data races. This is useful for shared data structures where reads vastly outnumber writes, like caches or configuration stores.
The basic invariants are: (1) if a writer holds the lock, no readers or other writers can hold it, and (2) if readers hold the lock, any number of additional readers can acquire it, but writers must wait. The tricky part is preventing writer starvation: without care, a steady stream of readers can indefinitely postpone waiting writers.
Part A: Basic Lock
{{fold}}{Problem: Part A}
Implement acquire_read(), release_read(), acquire_write(), and release_write(). Use a lock and condition variable(s) to coordinate. Track the number of active readers and whether a writer holds the lock.
lock = ReaderWriterLock()
# Thread 1 (Reader) Thread 2 (Reader) Thread 3 (Writer)
lock.acquire_read() lock.acquire_read()
# Both readers active # Both readers active
# _readers = 2 # _readers = 2
lock.acquire_write() # BLOCKS
# Waiting for _readers == 0
lock.release_read()
# _readers = 1 # Still blocked
lock.release_read()
# _readers = 0 # Writer unblocked!
# _writer = True, exclusive access
# Internal state during writer hold:
# _readers = 0, _writer = True
# Any acquire_read() or acquire_write() blocks{{/fold}}
Part B: Starvation Prevention
{{fold}}{Problem: Part B}
The basic implementation has a problem: if new readers keep arriving, a waiting writer never gets in. Fix this by tracking waiting writers and blocking new readers when a writer is waiting.
lock = ReaderWriterLock() # With writer preference
# Thread 1-5 are readers, Thread 6 is a writer
# Time 0: Readers 1,2,3 acquire read locks
# _readers = 3, _waiting_writers = 0
# Time 1: Writer 6 calls acquire_write()
# _waiting_writers = 1, writer blocks waiting for _readers == 0
# Time 2: Reader 4 calls acquire_read()
# With writer preference: blocks because _waiting_writers > 0
# Without: would acquire immediately, potentially starving writer
# Time 3: Readers 1,2,3 release
# _readers = 0, writer 6 acquires
# _waiting_writers = 0, _writer = True
# Time 4: Writer 6 releases
# Reader 4 can now acquire
# Key invariant for writer preference:
# acquire_read blocks while: _writer OR _waiting_writers > 0{{/fold}}
Part C: Upgradable Lock
{{fold}}{Problem: Part C}
Add an "upgradable read" mode: a reader that can later upgrade to a writer without releasing the lock. Only one thread can hold an upgradable lock at a time (if two could, they'd deadlock trying to upgrade simultaneously). The upgrade waits for other readers to release.
lock = UpgradableRWLock()
# Thread 1 (Upgradable) Thread 2 (Regular Reader)
lock.acquire_upgradable()
# Counts as a reader: _readers = 1
# _upgradable_held = True
lock.acquire_read()
# _readers = 2
# Thread 1 decides to write:
lock.upgrade()
# Sets _upgrade_waiting = True (blocks new readers)
# Decrements _readers to 1 (self)
# Waits for _readers == 0
lock.release_read()
# _readers = 0
# Thread 1 continues:
# _writer = True, _upgrade_waiting = False
# Now has exclusive write access
lock.release_write() # Not release_upgradable!
# _writer = False, _upgradable_held = False
# Key: only ONE upgradable lock at a time
lock2.acquire_upgradable() # Thread 3 tries
lock2.acquire_upgradable() # Thread 4 blocks until Thread 3 releases{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if a thread releases a lock it doesn't hold?
- How do you prevent new readers from starving waiting writers?
- Why can only one thread hold an upgradable lock?
- What if a thread tries to upgrade without holding an upgradable lock?
Common mistakes:
- Race condition in first-reader/last-reader logic (count check and lock acquisition not atomic)
- Using
notify()instead ofnotify_all()when releasing write lock (multiple readers waiting) - Deadlock in upgrade: still counting self as reader while waiting for readers == 0
- Writer starvation: not blocking new readers when writers are waiting
- Forgetting to decrement reader count during upgrade before waiting
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses condition variables with separate _can_read and _can_write conditions, tracking _waiting_writers to implement writer preference. Solution 2 uses a semaphore-based turnstile pattern where writers hold the turnstile to block new readers. Solution 3 adds upgradable read locks that can be promoted to write locks without releasing. The key difference is the synchronization mechanism and whether they support lock upgrades.
Core techniques: condition variables, semaphores, turnstile pattern, reader/writer counts, starvation prevention.
Solution 1: Condition variable based Condition variable based implementation with separate conditions for readers and writers. Uses _waiting_writers count to implement writer preference and prevent starvation.
"""
Reader-Writer Lock - Solution 1: Condition Variable Based
Uses a condition variable with reader/writer counts and a waiting writer flag
to prevent writer starvation.
"""
from __future__ import annotations
import threading
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class ReaderWriterLock:
"""Reader-writer lock preventing writer starvation via waiting_writers count."""
_lock: threading.Lock = field(default_factory=threading.Lock)
_can_read: threading.Condition = field(init=False)
_can_write: threading.Condition = field(init=False)
_readers: int = 0
_writers: int = 0
_waiting_writers: int = 0
def __post_init__(self) -> None:
self._can_read = threading.Condition(self._lock)
self._can_write = threading.Condition(self._lock)
def acquire_read(self) -> None:
"""Acquire read lock. Blocks if writer holds lock or writers are waiting."""
with self._can_read:
while self._writers > 0 or self._waiting_writers > 0:
self._can_read.wait()
self._readers += 1
def release_read(self) -> None:
"""Release read lock. Notifies waiting writers if last reader."""
with self._can_write:
self._readers -= 1
if self._readers == 0:
self._can_write.notify()
def acquire_write(self) -> None:
"""Acquire write lock. Blocks until no readers or writers."""
with self._can_write:
self._waiting_writers += 1
while self._readers > 0 or self._writers > 0:
self._can_write.wait()
self._waiting_writers -= 1
self._writers += 1
def release_write(self) -> None:
"""Release write lock. Notifies all waiting readers and one writer."""
with self._lock:
self._writers -= 1
self._can_read.notify_all()
self._can_write.notify()Solution 2: Semaphore based with fair queuing Semaphore-based implementation using a turnstile pattern. Writers hold the turnstile to block new readers. Uses room_empty semaphore for writer exclusivity.
"""
Reader-Writer Lock - Solution 2: Semaphore Based with Fair Queuing
Uses a turnstile semaphore to ensure fairness between readers and writers.
Writers block the turnstile, preventing new readers from cutting ahead.
"""
from __future__ import annotations
import threading
from dataclasses import dataclass, field
@dataclass
class FairReaderWriterLock:
"""Fair reader-writer lock using semaphores with turnstile pattern."""
_turnstile: threading.Semaphore = field(default_factory=lambda: threading.Semaphore(1))
_room_empty: threading.Semaphore = field(default_factory=lambda: threading.Semaphore(1))
_reader_lock: threading.Lock = field(default_factory=threading.Lock)
_reader_count: int = 0
def acquire_read(self) -> None:
"""Acquire read lock. Goes through turnstile for fairness."""
self._turnstile.acquire()
self._turnstile.release()
with self._reader_lock:
self._reader_count += 1
if self._reader_count == 1:
self._room_empty.acquire()
def release_read(self) -> None:
"""Release read lock. Last reader signals room is empty."""
with self._reader_lock:
self._reader_count -= 1
if self._reader_count == 0:
self._room_empty.release()
def acquire_write(self) -> None:
"""Acquire write lock. Holds turnstile to block new readers."""
self._turnstile.acquire()
self._room_empty.acquire()
def release_write(self) -> None:
"""Release write lock."""
self._room_empty.release()
self._turnstile.release()Solution 3: With upgradable read lock Full implementation with upgradable read locks. Only one thread can hold an upgradable lock. Upgrade operation decrements reader count, sets waiting flag, then waits for other readers.
"""
Reader-Writer Lock - Solution 3: With Upgradable Read Lock
Supports upgrading a read lock to a write lock without releasing.
Only one thread can hold an upgradable lock at a time.
"""
from __future__ import annotations
import threading
from dataclasses import dataclass, field
@dataclass
class UpgradableRWLock:
"""Reader-writer lock supporting upgradable read locks."""
_lock: threading.Lock = field(default_factory=threading.Lock)
_cond: threading.Condition = field(init=False)
_readers: int = 0
_writer: bool = False
_upgradable_held: bool = False
_upgrade_waiting: bool = False
def __post_init__(self) -> None:
self._cond = threading.Condition(self._lock)
def acquire_read(self) -> None:
"""Acquire shared read lock."""
with self._cond:
while self._writer or self._upgrade_waiting:
self._cond.wait()
self._readers += 1
def release_read(self) -> None:
"""Release shared read lock."""
with self._cond:
self._readers -= 1
if self._readers == 0:
self._cond.notify_all()
def release_upgradable(self) -> None:
"""Release upgradable read lock without upgrading."""
with self._cond:
self._readers -= 1
self._upgradable_held = False
if self._readers == 0:
self._cond.notify_all()
def acquire_upgradable(self) -> None:
"""Acquire upgradable read lock. Only one thread can hold this."""
with self._cond:
while self._writer or self._upgradable_held:
self._cond.wait()
self._upgradable_held = True
self._readers += 1
def upgrade(self) -> None:
"""Upgrade from upgradable read lock to write lock."""
with self._cond:
self._upgrade_waiting = True
self._readers -= 1
while self._readers > 0:
self._cond.wait()
self._upgrade_waiting = False
self._writer = True
def release_write(self) -> None:
"""Release write lock (after upgrade or direct acquire)."""
with self._cond:
self._writer = False
self._upgradable_held = False
self._cond.notify_all()
def acquire_write(self) -> None:
"""Acquire exclusive write lock."""
with self._cond:
while self._writer or self._readers > 0 or self._upgradable_held:
self._cond.wait()
self._writer = True{{/fold}}
Question 16 - Meeting Scheduler
- Difficulty: 6 / 10
- Approximate lines of code: 100 LoC
- Tags: scheduling, algorithms
Description
A meeting scheduler finds common free time slots across multiple attendees in different timezones. The core algorithm: (1) normalize all busy intervals to a common timezone (UTC), (2) merge overlapping busy intervals, (3) find gaps between busy periods that meet the minimum duration requirement. The key data structure is a list of intervals that gets merged via sorting and linear scan.
Example: Alice (NYC) is busy 9-10am local, Bob (LA) is busy 7-8am local. In UTC, Alice is busy 14:00-15:00, Bob is busy 15:00-16:00. After merging, the combined busy period is 14:00-16:00 UTC.
Part A: Merge Busy Intervals and Find Gaps
{{fold}}{Problem: Part A}
Given multiple attendees with busy time slots, find all common free slots of at least N minutes.
alice = Attendee(
name="Alice",
timezone="America/New_York",
busy_slots=[TimeSlot(datetime(2024, 1, 15, 9, 0), datetime(2024, 1, 15, 10, 0))]
)
bob = Attendee(
name="Bob",
timezone="America/Los_Angeles",
busy_slots=[TimeSlot(datetime(2024, 1, 15, 14, 0), datetime(2024, 1, 15, 15, 0))]
)
# Search window: 14:00-20:00 UTC
slots = find_free_slots([alice, bob],
search_start=datetime(2024, 1, 15, 14, 0), # UTC
search_end=datetime(2024, 1, 15, 20, 0), # UTC
duration_minutes=30)
# Internal processing:
# 1. Normalize to UTC:
# Alice 9am NYC = 14:00 UTC (busy 14:00-15:00)
# Bob 2pm LA = 22:00 UTC (outside search window, ignored)
# 2. Merge overlapping: [(14:00, 15:00)]
# 3. Find gaps >= 30 min: [(15:00, 20:00)]Interval merge algorithm:
def merge_intervals(slots):
sorted_slots = sorted(slots, key=lambda s: s.start)
merged = [sorted_slots[0]]
for slot in sorted_slots[1:]:
if slot.start <= merged[-1].end:
merged[-1].end = max(merged[-1].end, slot.end)
else:
merged.append(slot)
return merged{{/fold}}
Part B: Timezone Handling
{{fold}}{Problem: Part B}
Properly convert between local times and UTC. Each attendee specifies their timezone; all calculations happen in UTC.
def normalize_to_utc(slot: TimeSlot, tz: str) -> TimeSlot:
local_tz = ZoneInfo(tz)
utc = ZoneInfo("UTC")
start_utc = slot.start.replace(tzinfo=local_tz).astimezone(utc)
end_utc = slot.end.replace(tzinfo=local_tz).astimezone(utc)
return TimeSlot(start_utc.replace(tzinfo=None), end_utc.replace(tzinfo=None))
# NYC (EST = UTC-5): 9am local -> 14:00 UTC
# LA (PST = UTC-8): 9am local -> 17:00 UTC
# London (GMT = UTC+0): 9am local -> 09:00 UTCKey: Use zoneinfo.ZoneInfo (Python 3.9+) or pytz. Never mix naive and aware datetimes.
{{/fold}}
Part C: Rank Slots by Preference
{{fold}}{Problem: Part C}
Not all free slots are equal. Rank them by "goodness" - prefer slots during business hours for all attendees, closer to midday.
def score_slot(slot: TimeSlot, people: List[Person]) -> float:
"""Lower score = better. Penalizes times far from noon for each person."""
total_penalty = 0.0
for person in people:
local_start = localize(slot.start, person.timezone)
hours_from_noon = abs(local_start.hour - 12)
total_penalty += hours_from_noon
return total_penalty
# Slot at 17:00 UTC:
# Alice (NYC): 12:00 local -> penalty = 0
# Bob (LA): 09:00 local -> penalty = 3
# Total score: 3
# Slot at 19:00 UTC:
# Alice (NYC): 14:00 local -> penalty = 2
# Bob (LA): 11:00 local -> penalty = 1
# Total score: 3 (tie, but more balanced)Also consider: respecting each person's working hours (9-5 in their timezone), filtering out slots outside those bounds.
{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if there's no overlapping free time at all?
- How do you handle DST transitions?
- What if busy slots overlap or are unsorted?
- What about the final free slot after the last busy period?
Common mistakes:
- Mixing naive and timezone-aware datetimes (causes TypeError or wrong results)
- Forgetting the trailing free slot after the last busy period
- Not clipping busy intervals to the search window
- Using local time comparisons instead of normalizing to UTC first
- Off-by-one: is a slot ending at 10:00 and one starting at 10:00 a conflict?
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses interval merging: collect all busy slots, normalize to UTC, merge overlapping intervals, then find gaps between busy periods. Solution 2 uses a sweep line algorithm that converts busy intervals to start/end events and sweeps through time tracking overlap count. Solution 3 adds working hours constraints and slot scoring based on proximity to noon in each attendee's local timezone. The key difference is how they identify free time (gap-finding vs event sweeping) and whether they consider slot quality.
Core techniques: interval merging via sort-and-scan, sweep line algorithm, timezone normalization with ZoneInfo.
Solution 1: Interval Merging Approach Interval merging approach. Collects all busy slots, normalizes to UTC, merges overlapping intervals, then finds gaps between busy periods that meet duration requirements.
"""
Meeting Scheduler - Solution 1: Interval Merging Approach
Find common free slots across multiple attendees by merging busy intervals
and finding gaps that satisfy the required duration.
"""
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import List, Tuple
from zoneinfo import ZoneInfo
@dataclass
class TimeSlot:
start: datetime
end: datetime
def duration_minutes(self) -> int:
return int((self.end - self.start).total_seconds() / 60)
@dataclass
class Attendee:
name: str
timezone: str
busy_slots: List[TimeSlot]
def normalize_to_utc(slot: TimeSlot, tz: str) -> TimeSlot:
"""Convert a slot from local timezone to UTC."""
local_tz = ZoneInfo(tz)
utc = ZoneInfo("UTC")
start_utc = slot.start.replace(tzinfo=local_tz).astimezone(utc)
end_utc = slot.end.replace(tzinfo=local_tz).astimezone(utc)
return TimeSlot(start_utc.replace(tzinfo=None), end_utc.replace(tzinfo=None))
def merge_intervals(slots: List[TimeSlot]) -> List[TimeSlot]:
"""Merge overlapping intervals."""
if not slots:
return []
sorted_slots = sorted(slots, key=lambda s: s.start)
merged = [sorted_slots[0]]
for slot in sorted_slots[1:]:
if slot.start <= merged[-1].end:
merged[-1] = TimeSlot(merged[-1].start, max(merged[-1].end, slot.end))
else:
merged.append(slot)
return merged
def find_free_slots(
attendees: List[Attendee],
search_start: datetime,
search_end: datetime,
duration_minutes: int,
) -> List[TimeSlot]:
"""Find common free slots of at least duration_minutes."""
# Collect all busy slots normalized to UTC
all_busy: List[TimeSlot] = []
for attendee in attendees:
for slot in attendee.busy_slots:
all_busy.append(normalize_to_utc(slot, attendee.timezone))
merged_busy = merge_intervals(all_busy)
# Find gaps between busy periods
free_slots: List[TimeSlot] = []
current = search_start
for busy in merged_busy:
if busy.start > current:
gap = TimeSlot(current, min(busy.start, search_end))
if gap.duration_minutes() >= duration_minutes:
free_slots.append(gap)
current = max(current, busy.end)
if current < search_end:
gap = TimeSlot(current, search_end)
if gap.duration_minutes() >= duration_minutes:
free_slots.append(gap)
return free_slotsSolution 2: Event Sweep Line Algorithm Sweep line algorithm. Converts busy intervals to start/end events, sweeps through time tracking overlap count. Free time exists where overlap count is zero.
"""
Meeting Scheduler - Solution 2: Event Sweep Line Algorithm
Uses a sweep line approach: convert all busy intervals to start/end events,
sweep through time tracking overlap count, find windows where count is 0.
"""
from dataclasses import dataclass
from datetime import datetime
from typing import List
from zoneinfo import ZoneInfo
@dataclass
class TimeSlot:
start: datetime
end: datetime
def duration_minutes(self) -> int:
return int((self.end - self.start).total_seconds() / 60)
@dataclass
class Calendar:
owner: str
timezone: str
busy_slots: List[TimeSlot]
def to_utc(dt: datetime, tz_name: str) -> datetime:
"""Convert naive datetime in given timezone to naive UTC datetime."""
tz = ZoneInfo(tz_name)
return dt.replace(tzinfo=tz).astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
def find_available_slots(
calendars: List[Calendar],
window_start: datetime,
window_end: datetime,
min_duration: int,
) -> List[TimeSlot]:
"""Find all slots where everyone is free for at least min_duration minutes."""
# Collect events: (time, delta) where delta is +1 for busy start, -1 for busy end
events: List[tuple[datetime, int]] = []
for calendar in calendars:
for slot in calendar.busy_slots:
utc_start = to_utc(slot.start, calendar.timezone)
utc_end = to_utc(slot.end, calendar.timezone)
# Clip to search window
if utc_end <= window_start or utc_start >= window_end:
continue
clipped_start = max(utc_start, window_start)
clipped_end = min(utc_end, window_end)
events.append((clipped_start, 1)) # Start of busy period
events.append((clipped_end, -1)) # End of busy period
# Sort by time; at same time, process ends (-1) before starts (+1)
events.sort(key=lambda e: (e[0], e[1]))
available: List[TimeSlot] = []
busy_count = 0
free_start = window_start
for time, delta in events:
if delta == 1: # Busy period starting
if busy_count == 0 and time > free_start:
slot = TimeSlot(free_start, time)
if slot.duration_minutes() >= min_duration:
available.append(slot)
busy_count += 1
else: # Busy period ending
busy_count -= 1
if busy_count == 0:
free_start = time
# Handle trailing free time
if busy_count == 0 and free_start < window_end:
slot = TimeSlot(free_start, window_end)
if slot.duration_minutes() >= min_duration:
available.append(slot)
return available
def suggest_optimal_times(
slots: List[TimeSlot], preferred_hour_utc: int = 14
) -> List[TimeSlot]:
"""Rank slots by proximity to preferred hour (e.g., 2 PM UTC)."""
def score(slot: TimeSlot) -> float:
hour_diff = abs(slot.start.hour - preferred_hour_utc)
return hour_diff + (1 / max(slot.duration_minutes(), 1))
return sorted(slots, key=score)Solution 3: Working Hours Constraint + Scoring Working hours constraint with scoring. Respects each attendee's working hours, scores slots by convenience (proximity to noon in each person's local time).
"""
Meeting Scheduler - Solution 3: Working Hours Constraint + Scoring
More realistic approach: respects working hours per attendee,
scores slots by convenience (avoiding early/late times across timezones).
"""
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import List
from zoneinfo import ZoneInfo
@dataclass
class TimeSlot:
start: datetime
end: datetime
def duration_minutes(self) -> int:
return int((self.end - self.start).total_seconds() / 60)
@dataclass
class WorkingHours:
start_hour: int = 9
end_hour: int = 17
@dataclass
class Person:
name: str
timezone: str
busy: List[TimeSlot] = field(default_factory=list)
working_hours: WorkingHours = field(default_factory=WorkingHours)
def localize(dt: datetime, tz_name: str) -> datetime:
"""Convert naive UTC datetime to naive local datetime."""
utc = ZoneInfo("UTC")
local = ZoneInfo(tz_name)
return dt.replace(tzinfo=utc).astimezone(local).replace(tzinfo=None)
def to_utc(dt: datetime, tz_name: str) -> datetime:
"""Convert naive local datetime to naive UTC datetime."""
local = ZoneInfo(tz_name)
utc = ZoneInfo("UTC")
return dt.replace(tzinfo=local).astimezone(utc).replace(tzinfo=None)
def is_within_working_hours(dt_utc: datetime, person: Person) -> bool:
"""Check if UTC time falls within person's working hours."""
local_dt = localize(dt_utc, person.timezone)
return person.working_hours.start_hour <= local_dt.hour < person.working_hours.end_hour
def is_busy(dt_utc: datetime, person: Person) -> bool:
"""Check if person has a conflicting meeting at given UTC time."""
for slot in person.busy:
slot_start = to_utc(slot.start, person.timezone)
slot_end = to_utc(slot.end, person.timezone)
if slot_start <= dt_utc < slot_end:
return True
return False
def score_slot(slot: TimeSlot, people: List[Person]) -> float:
"""Score a slot: lower is better. Penalizes times far from midday for each person."""
total_penalty = 0.0
for person in people:
local_start = localize(slot.start, person.timezone)
# Ideal time is noon; penalize distance from it
hours_from_noon = abs(local_start.hour + local_start.minute / 60 - 12)
total_penalty += hours_from_noon
return total_penalty
def find_meeting_slots(
people: List[Person],
search_date: datetime,
duration_minutes: int,
step_minutes: int = 15,
) -> List[tuple[TimeSlot, float]]:
"""Find and rank available meeting slots for a given date."""
# Search window: 00:00 to 23:59 UTC on the given date
window_start = search_date.replace(hour=0, minute=0, second=0, microsecond=0)
window_end = window_start + timedelta(days=1)
candidates: List[tuple[TimeSlot, float]] = []
current = window_start
while current + timedelta(minutes=duration_minutes) <= window_end:
slot_end = current + timedelta(minutes=duration_minutes)
slot = TimeSlot(current, slot_end)
# Check all time points within the slot
all_available = True
check_time = current
while check_time < slot_end:
for person in people:
if not is_within_working_hours(check_time, person):
all_available = False
break
if is_busy(check_time, person):
all_available = False
break
if not all_available:
break
check_time += timedelta(minutes=step_minutes)
if all_available:
candidates.append((slot, score_slot(slot, people)))
current += timedelta(minutes=step_minutes)
# Sort by score (lower is better)
candidates.sort(key=lambda x: x[1])
return candidates{{/fold}}
Question 17 - LSM Tree
- Difficulty: 10 / 10
- Approximate lines of code: 90 LoC
- Tags: storage, data-structures
Description
An LSM (Log-Structured Merge) Tree is the storage engine behind modern databases like LevelDB, RocksDB, and Cassandra. It optimizes for write-heavy workloads by buffering writes in memory and periodically flushing them to disk as immutable sorted files called SSTables (Sorted String Tables). Reads check the in-memory buffer first, then search through SSTables from newest to oldest.
The key data structures are: (1) a memtable (typically a balanced tree or hash map) that holds recent writes in memory, (2) a list of SSTables on disk, each containing sorted key-value pairs, and (3) optional bloom filters to skip SSTables that definitely don't contain a key.
Note: The
sortedcontainerslibrary (SortedDict) is available. UsingSortedDictfor the memtable gives sorted iteration during flush without a separate sort step.
Part A: Basic Operations
{{fold}}{Problem: Part A}
Implement a key-value store with put(key, value) and get(key). When the memtable exceeds a size threshold, flush it to a new SSTable. The critical insight: reads must check the memtable first, then SSTables in newest-to-oldest order (the first match wins).
lsm = LSMTree(memtable_threshold=3)
lsm.put("a", "1")
lsm.put("b", "2")
# Internal state: memtable = {"a": "1", "b": "2"}, sstables = []
lsm.put("c", "3") # Triggers flush
# Internal state: memtable = {}, sstables = [SSTable([("a","1"), ("b","2"), ("c","3")])]
lsm.put("a", "10") # Update in new memtable
# Internal state: memtable = {"a": "10"}, sstables = [SSTable([...])]
lsm.get("a") # Returns "10" (found in memtable, doesn't check SSTable)
lsm.get("b") # Returns "2" (not in memtable, found in SSTable via binary search){{/fold}}
Part B: Delete Support
{{fold}}{Problem: Part B}
Add delete(key). The trick: you cannot simply remove the key from the memtable because older SSTables may still contain it. Instead, write a tombstone marker (e.g., None value) that shadows any older values.
lsm.put("x", "100")
lsm.put("y", "200")
lsm.put("z", "300") # Flush happens
# sstables[0] = [("x","100"), ("y","200"), ("z","300")]
lsm.delete("x")
# memtable = {"x": None} <-- tombstone
lsm.get("x") # Returns None (tombstone found in memtable)
lsm.get("y") # Returns "200" (no tombstone, found in SSTable){{/fold}}
Part C: Compaction
{{fold}}{Problem: Part C}
With many SSTables, reads become slow (must check each one). Implement compact() that merges all SSTables together, keeping only the newest value for each key and removing tombstones for keys that have no older versions.
# Before compaction:
# sstables[0] = [("a", "new")] # Newer
# sstables[1] = [("a", "old"), ("b", "2")] # Older
lsm.compact()
# After: sstables = [SSTable([("a", "new"), ("b", "2")])]
# Tombstone cleanup:
# If sstables[0] = [("x", None)] and sstables[1] = [("x", "old")]
# After compact: key "x" is removed entirely (tombstone + old value both gone){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if you
get()a key that was deleted? (Should return None) - What if you delete a key that doesn't exist? (Write tombstone anyway - it might exist in an SSTable you haven't checked)
- What order do you check SSTables? (Newest first - order matters!)
- When can you safely remove tombstones? (Only during compaction, when you merge with all older SSTables)
Common mistakes:
- Checking SSTables before memtable, or checking oldest SSTable first
- Deleting directly from memtable without writing a tombstone
- Removing tombstones during flush (too early - older SSTables still have the value)
- Off-by-one errors in binary search within SSTables
- Forgetting that
bisect_leftneeds proper tuple comparison
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses an in-memory dict for the memtable and sorted lists for SSTables with binary search lookups. Solution 2 writes SSTables to JSON files on disk and adds bloom filters to skip unnecessary reads. Solution 3 implements tiered compaction with multiple levels, modeling how production systems like LevelDB organize data. The key differences are in storage medium (memory vs files) and compaction strategy (single merge vs tiered levels). Core techniques: binary search, hash maps, bloom filters, merge sort.
Solution 1: In-memory with sorted lists Basic in-memory implementation using a dict for the memtable and sorted lists for SSTables. Uses binary search via bisect for efficient SSTable lookups. Simple and clean - good for demonstrating core concepts.
"""LSM Tree - Basic Implementation with in-memory segments."""
from dataclasses import dataclass, field
from typing import Optional
import bisect
@dataclass
class SSTable:
"""Immutable sorted segment stored on 'disk' (simulated in memory)."""
data: list[tuple[str, Optional[str]]] # Sorted list of (key, value) pairs
def get(self, key: str) -> tuple[bool, Optional[str]]:
"""Binary search for key. Returns (found, value)."""
idx = bisect.bisect_left(self.data, (key,))
if idx < len(self.data) and self.data[idx][0] == key:
return True, self.data[idx][1]
return False, None
@dataclass
class LSMTree:
"""Log-Structured Merge Tree with memtable and SSTables."""
memtable: dict[str, Optional[str]] = field(default_factory=dict)
sstables: list[SSTable] = field(default_factory=list) # Newest first
memtable_threshold: int = 4
def put(self, key: str, value: str) -> None:
"""Insert or update a key-value pair."""
self.memtable[key] = value
if len(self.memtable) >= self.memtable_threshold:
self._flush()
def delete(self, key: str) -> None:
"""Delete a key by writing a tombstone."""
self.memtable[key] = None
def get(self, key: str) -> Optional[str]:
"""Read a value. Checks memtable first, then SSTables newest to oldest."""
if key in self.memtable:
return self.memtable[key] # Returns None for tombstones
for sstable in self.sstables:
found, value = sstable.get(key)
if found:
return value
return None
def _flush(self) -> None:
"""Flush memtable to a new SSTable."""
if not self.memtable:
return
sorted_data = sorted(self.memtable.items())
self.sstables.insert(0, SSTable(data=sorted_data))
self.memtable.clear()
def compact(self) -> None:
"""Merge all SSTables into one, removing tombstones."""
self._flush()
if len(self.sstables) <= 1:
return
merged: dict[str, Optional[str]] = {}
for sstable in reversed(self.sstables): # Oldest first
for key, value in sstable.data:
merged[key] = value
# Remove tombstones
live_data = [(k, v) for k, v in sorted(merged.items()) if v is not None]
self.sstables = [SSTable(data=live_data)] if live_data else []Solution 2: File-based with bloom filters File-based implementation that writes SSTables to JSON files. Adds bloom filters for each SSTable to skip disk reads when a key definitely isn't present. More realistic for understanding actual LSM tree I/O patterns.
"""LSM Tree - File-based simulation with bloom filters."""
from dataclasses import dataclass, field
from typing import Optional
import hashlib
import json
from pathlib import Path
import tempfile
import shutil
@dataclass
class BloomFilter:
"""Simple bloom filter for probabilistic key existence checks."""
size: int = 64
bits: int = 0
def _hashes(self, key: str) -> list[int]:
h = hashlib.md5(key.encode()).hexdigest()
return [int(h[i:i+4], 16) % self.size for i in range(0, 12, 4)]
def add(self, key: str) -> None:
for h in self._hashes(key):
self.bits |= (1 << h)
def might_contain(self, key: str) -> bool:
return all((self.bits & (1 << h)) for h in self._hashes(key))
@dataclass
class SSTable:
"""SSTable stored as a JSON file with bloom filter."""
path: Path
bloom: BloomFilter = field(default_factory=BloomFilter)
def get(self, key: str) -> tuple[bool, Optional[str]]:
if not self.bloom.might_contain(key):
return False, None
data = json.loads(self.path.read_text())
if key in data:
return True, data[key]
return False, None
def items(self) -> list[tuple[str, Optional[str]]]:
return list(json.loads(self.path.read_text()).items())
@dataclass
class LSMTree:
"""LSM Tree with file-based SSTables and bloom filters."""
base_dir: Path
memtable: dict[str, Optional[str]] = field(default_factory=dict)
sstables: list[SSTable] = field(default_factory=list)
memtable_threshold: int = 4
_counter: int = 0
def put(self, key: str, value: str) -> None:
self.memtable[key] = value
if len(self.memtable) >= self.memtable_threshold:
self._flush()
def delete(self, key: str) -> None:
self.memtable[key] = None
def get(self, key: str) -> Optional[str]:
if key in self.memtable:
return self.memtable[key]
for sstable in self.sstables:
found, value = sstable.get(key)
if found:
return value
return None
def _flush(self) -> None:
if not self.memtable:
return
bloom = BloomFilter()
for key in self.memtable:
bloom.add(key)
path = self.base_dir / f"sstable_{self._counter}.json"
path.write_text(json.dumps(dict(sorted(self.memtable.items()))))
self._counter += 1
self.sstables.insert(0, SSTable(path=path, bloom=bloom))
self.memtable.clear()
def compact(self) -> None:
self._flush()
if len(self.sstables) <= 1:
return
merged: dict[str, Optional[str]] = {}
for sstable in reversed(self.sstables):
for k, v in sstable.items():
merged[k] = v
for sstable in self.sstables:
sstable.path.unlink()
live = {k: v for k, v in merged.items() if v is not None}
self.sstables.clear()
if live:
self.memtable = live
self._flush()Solution 3: Tiered compaction with multiple levels Tiered compaction with multiple levels. SSTables are organized into levels; when a level fills up, its tables merge and push to the next level. This models how production systems like LevelDB organize data for better read amplification.
"""LSM Tree - Tiered compaction with multiple levels."""
from dataclasses import dataclass, field
from typing import Optional
import bisect
@dataclass
class SSTable:
"""Immutable sorted segment with size tracking."""
data: list[tuple[str, Optional[str]]]
def get(self, key: str) -> tuple[bool, Optional[str]]:
idx = bisect.bisect_left(self.data, (key,))
if idx < len(self.data) and self.data[idx][0] == key:
return True, self.data[idx][1]
return False, None
def __len__(self) -> int:
return len(self.data)
@dataclass
class Level:
"""A level in the LSM tree containing multiple SSTables."""
sstables: list[SSTable] = field(default_factory=list)
max_tables: int = 4
def is_full(self) -> bool:
return len(self.sstables) >= self.max_tables
def add(self, sstable: SSTable) -> None:
self.sstables.insert(0, sstable)
def merge_all(self) -> SSTable:
merged: dict[str, Optional[str]] = {}
for sstable in reversed(self.sstables):
for k, v in sstable.data:
merged[k] = v
self.sstables.clear()
return SSTable(data=sorted(merged.items()))
@dataclass
class LSMTree:
"""LSM Tree with tiered compaction across multiple levels."""
memtable: dict[str, Optional[str]] = field(default_factory=dict)
levels: list[Level] = field(default_factory=list)
memtable_threshold: int = 4
num_levels: int = 3
def __post_init__(self) -> None:
self.levels = [Level(max_tables=4) for _ in range(self.num_levels)]
def put(self, key: str, value: str) -> None:
self.memtable[key] = value
if len(self.memtable) >= self.memtable_threshold:
self._flush()
def delete(self, key: str) -> None:
self.memtable[key] = None
def get(self, key: str) -> Optional[str]:
if key in self.memtable:
return self.memtable[key]
for level in self.levels:
for sstable in level.sstables:
found, value = sstable.get(key)
if found:
return value
return None
def _flush(self) -> None:
if not self.memtable:
return
sstable = SSTable(data=sorted(self.memtable.items()))
self.memtable.clear()
self._add_to_level(0, sstable)
def _add_to_level(self, level_idx: int, sstable: SSTable) -> None:
if level_idx >= len(self.levels):
self.levels.append(Level(max_tables=4))
level = self.levels[level_idx]
level.add(sstable)
if level.is_full():
merged = level.merge_all()
self._add_to_level(level_idx + 1, merged)
def compact(self) -> None:
"""Force full compaction, removing tombstones from final level."""
self._flush()
for i in range(len(self.levels) - 1):
if self.levels[i].sstables:
merged = self.levels[i].merge_all()
self._add_to_level(i + 1, merged)
# Remove tombstones from last level
if self.levels and self.levels[-1].sstables:
final = self.levels[-1].merge_all()
live = [(k, v) for k, v in final.data if v is not None]
if live:
self.levels[-1].sstables = [SSTable(data=live)]{{/fold}}
Question 18 - Undo/Redo
- Difficulty: 4 / 10
- Approximate lines of code: 100 LoC
- Tags: data-structures
Description
An undo/redo system allows users to reverse and replay operations in applications like text editors, graphics software, or games. The key insight is that operations must be reversible - you need to store enough information to reconstruct the previous state. There are two main approaches: the command pattern (store operations with their inverses) or the memento pattern (store full state snapshots). Command pattern uses less memory but requires each operation to be invertible; memento is simpler but stores redundant data.
Internal state typically includes two stacks: an undo stack (executed commands waiting to be undone) and a redo stack (undone commands waiting to be replayed). When a new command executes, it clears the redo stack - you cannot redo after making a new change.
Part A: Execute, Undo, Redo
{{fold}}{Problem: Part A}
Implement a basic undo/redo manager with three operations: execute(command), undo(), and redo(). Each command must support both execution and reversal.
manager = UndoRedoManager()
doc = Document(content="")
manager.execute(InsertCommand(doc, 0, "Hello"))
# doc.content = "Hello"
# undo_stack = [InsertCommand("Hello" at 0)]
# redo_stack = []
manager.execute(InsertCommand(doc, 5, " World"))
# doc.content = "Hello World"
# undo_stack = [InsertCommand("Hello" at 0), InsertCommand(" World" at 5)]
manager.undo()
# doc.content = "Hello"
# undo_stack = [InsertCommand("Hello" at 0)]
# redo_stack = [InsertCommand(" World" at 5)]
manager.redo()
# doc.content = "Hello World"
# undo_stack = [InsertCommand("Hello" at 0), InsertCommand(" World" at 5)]
# redo_stack = []
manager.execute(InsertCommand(doc, 5, "!"))
# doc.content = "Hello! World"
# undo_stack = [..., InsertCommand("!" at 5)]
# redo_stack = [] # CLEARED - new command invalidates redo history{{/fold}}
Part B: Command Grouping
{{fold}}{Problem: Part B}
Add support for grouping multiple commands into a single undoable operation. When the user undoes a group, all commands in the group are reversed together in reverse order.
group = CommandGroup([
InsertCommand(doc, 0, "A"),
InsertCommand(doc, 1, "B"),
InsertCommand(doc, 2, "C"),
])
manager.execute(group)
# doc.content = "ABC"
# undo_stack = [CommandGroup([A, B, C])]
manager.undo()
# Internally: undo C, then B, then A (reverse order!)
# doc.content = ""{{/fold}}
Part C: Memory Limits
{{fold}}{Problem: Part C}
Add a maximum history size. When the undo stack exceeds the limit, discard the oldest commands. Consider: should you track memory by command count or actual bytes? How do you handle groups that push you over the limit?
manager = UndoRedoManager(max_history=3)
manager.execute(cmd1) # stack: [cmd1]
manager.execute(cmd2) # stack: [cmd1, cmd2]
manager.execute(cmd3) # stack: [cmd1, cmd2, cmd3]
manager.execute(cmd4) # stack: [cmd2, cmd3, cmd4] - cmd1 discarded{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when you undo with an empty undo stack?
- What happens when you redo after executing a new command?
- How do you undo a delete operation? (Must store the deleted content)
- What if undo itself fails partway through a group?
Common mistakes:
- Forgetting to clear the redo stack when executing a new command
- Undoing grouped commands in forward order instead of reverse order
- Not storing enough state to reverse delete operations
- Shallow copying mutable state in memento pattern (changes leak through)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses the classic command pattern with an abstract base class where each command implements execute() and undo() methods. Solution 2 takes a functional approach using closures, where commands are functions that return their undo function when executed. Solution 3 uses the memento pattern, storing complete state snapshots instead of reversible commands. The key difference is the trade-off between memory usage and implementation complexity: command pattern is memory-efficient but requires invertible operations, memento is simpler but stores redundant state. Core techniques: command pattern, closure-based undo, state snapshots with deepcopy, stack-based history management.
Solution 1: Classic Command Pattern Classic command pattern using an abstract base class. Each command (Insert, Delete) implements execute() and undo() methods. Commands store the information needed to reverse themselves. Groups are commands containing other commands.
"""
Undo/Redo System - Solution 1: Classic Command Pattern
Uses abstract base class for commands with execute/undo methods.
"""
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from typing import Any
class Command(ABC):
@abstractmethod
def execute(self) -> None:
pass
@abstractmethod
def undo(self) -> None:
pass
@dataclass
class Document:
content: str = ""
@dataclass
class InsertCommand(Command):
document: Document
position: int
text: str
def execute(self) -> None:
self.document.content = (
self.document.content[:self.position]
+ self.text
+ self.document.content[self.position:]
)
def undo(self) -> None:
self.document.content = (
self.document.content[:self.position]
+ self.document.content[self.position + len(self.text):]
)
@dataclass
class DeleteCommand(Command):
document: Document
position: int
length: int
deleted_text: str = field(default="", init=False)
def execute(self) -> None:
self.deleted_text = self.document.content[self.position:self.position + self.length]
self.document.content = (
self.document.content[:self.position]
+ self.document.content[self.position + self.length:]
)
def undo(self) -> None:
self.document.content = (
self.document.content[:self.position]
+ self.deleted_text
+ self.document.content[self.position:]
)
@dataclass
class CommandGroup(Command):
commands: list[Command] = field(default_factory=list)
def execute(self) -> None:
for cmd in self.commands:
cmd.execute()
def undo(self) -> None:
for cmd in reversed(self.commands):
cmd.undo()
@dataclass
class UndoRedoManager:
undo_stack: list[Command] = field(default_factory=list)
redo_stack: list[Command] = field(default_factory=list)
def execute(self, command: Command) -> None:
command.execute()
self.undo_stack.append(command)
self.redo_stack.clear()
def undo(self) -> bool:
if not self.undo_stack:
return False
command = self.undo_stack.pop()
command.undo()
self.redo_stack.append(command)
return True
def redo(self) -> bool:
if not self.redo_stack:
return False
command = self.redo_stack.pop()
command.execute()
self.undo_stack.append(command)
return TrueSolution 2: Functional Approach with Closures Functional approach using closures. Commands are functions that return their undo function when executed. Cleaner for simple cases with no class hierarchy needed. Must store both the command and its undo function to support redo.
"""
Undo/Redo System - Solution 2: Functional Approach with Closures
Commands are functions that return their inverse (undo function).
Cleaner for simple cases, no class hierarchy needed.
"""
from dataclasses import dataclass, field
from typing import Callable
UndoFn = Callable[[], None]
CommandFn = Callable[[], UndoFn]
@dataclass
class State:
value: int = 0
def make_add_command(state: State, amount: int) -> CommandFn:
def execute() -> UndoFn:
state.value += amount
def undo() -> None:
state.value -= amount
return undo
return execute
def make_multiply_command(state: State, factor: int) -> CommandFn:
def execute() -> UndoFn:
old_value = state.value
state.value *= factor
def undo() -> None:
state.value = old_value
return undo
return execute
def make_set_command(state: State, new_value: int) -> CommandFn:
def execute() -> UndoFn:
old_value = state.value
state.value = new_value
def undo() -> None:
state.value = old_value
return undo
return execute
def make_group_command(commands: list[CommandFn]) -> CommandFn:
def execute() -> UndoFn:
undo_fns: list[UndoFn] = []
for cmd in commands:
undo_fns.append(cmd())
def undo() -> None:
for undo_fn in reversed(undo_fns):
undo_fn()
return undo
return execute
@dataclass
class BetterUndoRedoManager:
"""Version that properly supports redo by storing commands."""
undo_stack: list[tuple[CommandFn, UndoFn]] = field(default_factory=list)
redo_stack: list[CommandFn] = field(default_factory=list)
def execute(self, command: CommandFn) -> None:
undo_fn = command()
self.undo_stack.append((command, undo_fn))
self.redo_stack.clear()
def undo(self) -> bool:
if not self.undo_stack:
return False
command, undo_fn = self.undo_stack.pop()
undo_fn()
self.redo_stack.append(command)
return True
def redo(self) -> bool:
if not self.redo_stack:
return False
command = self.redo_stack.pop()
undo_fn = command()
self.undo_stack.append((command, undo_fn))
return TrueSolution 3: Memento Pattern (State Snapshots) Memento pattern using state snapshots. Instead of reversible commands, store complete copies of state after each operation. Trades memory for simplicity - no need to implement undo logic per operation. Uses deepcopy to prevent mutation leakage.
"""
Undo/Redo System - Solution 3: Memento Pattern (State Snapshots)
Instead of reversible commands, store full state snapshots.
Simpler logic but higher memory usage. Good for small state objects.
"""
from dataclasses import dataclass, field
from typing import Generic, TypeVar
from copy import deepcopy
T = TypeVar('T')
@dataclass
class GameState:
"""Example state: a simple game with position and score."""
x: int = 0
y: int = 0
score: int = 0
inventory: list[str] = field(default_factory=list)
@dataclass
class UndoRedoManager(Generic[T]):
"""
Manages undo/redo using state snapshots (memento pattern).
Stores complete copies of state, trading memory for simplicity.
"""
history: list[T] = field(default_factory=list)
current_index: int = -1
def save_state(self, state: T) -> None:
"""Save a snapshot after each mutation."""
# Discard any redo history when new state is saved
self.history = self.history[:self.current_index + 1]
self.history.append(deepcopy(state))
self.current_index += 1
def undo(self) -> T | None:
"""Return the previous state, or None if at beginning."""
if self.current_index <= 0:
return None
self.current_index -= 1
return deepcopy(self.history[self.current_index])
def redo(self) -> T | None:
"""Return the next state, or None if at end."""
if self.current_index >= len(self.history) - 1:
return None
self.current_index += 1
return deepcopy(self.history[self.current_index])
def can_undo(self) -> bool:
return self.current_index > 0
def can_redo(self) -> bool:
return self.current_index < len(self.history) - 1
@dataclass
class GameEngine:
"""Game engine that uses the undo/redo manager."""
state: GameState = field(default_factory=GameState)
history: UndoRedoManager[GameState] = field(default_factory=UndoRedoManager)
def __post_init__(self) -> None:
self.history.save_state(self.state)
def move(self, dx: int, dy: int) -> None:
self.state.x += dx
self.state.y += dy
self.history.save_state(self.state)
def add_score(self, points: int) -> None:
self.state.score += points
self.history.save_state(self.state)
def collect_item(self, item: str) -> None:
self.state.inventory.append(item)
self.history.save_state(self.state)
def batch_actions(self, actions: list[tuple[str, ...]]) -> None:
"""Execute multiple actions as a single undoable operation."""
for action in actions:
name, *args = action
if name == "move":
self.state.x += int(args[0])
self.state.y += int(args[1])
elif name == "score":
self.state.score += int(args[0])
elif name == "collect":
self.state.inventory.append(str(args[0]))
self.history.save_state(self.state)
def undo(self) -> bool:
prev_state = self.history.undo()
if prev_state is None:
return False
self.state = prev_state
return True
def redo(self) -> bool:
next_state = self.history.redo()
if next_state is None:
return False
self.state = next_state
return True{{/fold}}
Question 19 - Interval Tree
- Difficulty: 9 / 10
- Approximate lines of code: 100 LoC
- Tags: data-structures
Description
An interval tree efficiently stores intervals (like meeting times, IP ranges, or genomic regions) and answers queries about which intervals contain a point or overlap with a query range. The naive approach of checking every interval is O(n) per query. An interval tree achieves O(log n + k) where k is the number of results by augmenting a BST with subtree metadata that enables pruning entire branches.
The key insight is storing max_end at each node: the maximum endpoint among all intervals in that subtree. When querying for point P, if P > node.max_end, you can skip the entire subtree since no interval there can contain P. The tree is ordered by interval start points (like a normal BST), with the max_end augmentation propagated up during insertions and deletions.
Note: The
sortedcontainerslibrary (SortedList) is available. If using a sorted list approach instead of a tree,SortedListgives O(log n) insertions instead of O(n) withbisect.insort.
Part A: Basic Structure
{{fold}}{Problem: Part A}
Build an interval tree supporting insert(start, end) and query_point(point). Each node stores an interval and the maximum endpoint in its subtree. Insert maintains BST ordering by start point and updates max_end on the path to the root.
tree = IntervalTree()
tree.insert(15, 20)
tree.insert(10, 30)
tree.insert(5, 10)
tree.insert(17, 19)
# Tree structure (ordered by start):
# [10,30] max_end=30
# / \
# [5,10] max_end=10 [15,20] max_end=20
# \
# [17,19] max_end=19
result = tree.query_point(18)
# Returns: [[10,30], [15,20], [17,19]]
# Query traverses: checks [10,30] (contains 18), recurses left (max_end=10 < 18, prune),
# recurses right to [15,20] (contains 18), then [17,19] (contains 18)
result = tree.query_point(7)
# Returns: 5,10
# [10,30] doesn't contain 7, but max_end=30 >= 7 so we check children
# Left subtree [5,10] contains 7{{/fold}}
Part B: Overlap Queries
{{fold}}{Problem: Part B}
Add query_range(start, end) that finds all intervals overlapping with the query interval. Two intervals [a,b] and [c,d] overlap if a <= d AND c <= b. Use the same pruning strategy with max_end.
tree = IntervalTree()
tree.insert(15, 20)
tree.insert(10, 30)
tree.insert(5, 10)
tree.insert(25, 30)
result = tree.query_range(12, 16)
# Returns: [[10,30], [15,20]]
# [10,30] overlaps [12,16]: 10 <= 16 AND 12 <= 30
# [15,20] overlaps [12,16]: 15 <= 16 AND 12 <= 20
# [5,10] doesn't overlap: 5 <= 16 but 12 > 10
# [25,30] doesn't overlap: 25 > 16
# Edge case: touching intervals (share an endpoint)
result = tree.query_range(10, 10)
# Returns: [[5,10], [10,30]] - both touch point 10{{/fold}}
Part C: Deletion
{{fold}}{Problem: Part C}
Implement delete(start, end) that removes an interval and maintains the max_end invariant. After removing a node, recompute max_end for all ancestors by taking the max of the node's interval end and the max_end of its children.
tree = IntervalTree()
tree.insert(15, 20)
tree.insert(10, 30)
tree.insert(17, 19)
# Before delete:
# [10,30] max_end=30
# \
# [15,20] max_end=20
# \
# [17,19] max_end=19
tree.delete(17, 19)
# After delete:
# [10,30] max_end=30
# \
# [15,20] max_end=20 <-- max_end recomputed
# Deleting a node with two children uses standard BST deletion
# (replace with in-order successor), then recompute max_end up the path{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- Do [1,5] and [5,10] overlap? (Yes, they touch at 5 - use <= not <)
- What if you insert single-point intervals like [7,7]?
- How do you handle deleting a node with two children? (In-order successor, then recompute max_end)
- What's the worst-case query time? (O(n) if all intervals overlap the query)
Common mistakes:
- Wrong overlap check: using
<instead of<=(missing touching intervals) - Forgetting to update
max_endon insert path - Not recomputing
max_endcorrectly after delete (must check both children) - Pruning incorrectly: should check
query.start > node.max_endnotquery.end - Off-by-one in deciding whether to recurse into children
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses an augmented BST where each node stores max_end (maximum endpoint in subtree) for efficient pruning during queries. Solution 2 is a simpler sorted list approach with binary search for insertion but O(n) queries. Solution 3 implements a centered interval tree that partitions intervals by a center point. They differ in the tradeoff between implementation complexity and query efficiency.
Core techniques: augmented BST, binary search, interval overlap detection, subtree pruning.
Solution 1: Augmented BST approach Augmented BST approach where each node stores the interval and max_end (maximum endpoint in subtree). Insert/delete maintain the invariant. Query uses max_end to prune branches.
"""
Interval Tree - Solution 1: Augmented BST approach
Uses an augmented binary search tree where each node stores the max endpoint in its subtree.
"""
from dataclasses import dataclass
from typing import Optional
@dataclass
class Interval:
start: int
end: int
def overlaps(self, other: "Interval") -> bool:
return self.start <= other.end and other.start <= self.end
def contains_point(self, point: int) -> bool:
return self.start <= point <= self.end
@dataclass
class Node:
interval: Interval
max_end: int
left: Optional["Node"] = None
right: Optional["Node"] = None
class IntervalTree:
def __init__(self) -> None:
self.root: Optional[Node] = None
def insert(self, start: int, end: int) -> None:
interval = Interval(start, end)
self.root = self._insert(self.root, interval)
def _insert(self, node: Optional[Node], interval: Interval) -> Node:
if node is None:
return Node(interval=interval, max_end=interval.end)
if interval.start < node.interval.start:
node.left = self._insert(node.left, interval)
else:
node.right = self._insert(node.right, interval)
node.max_end = max(node.max_end, interval.end)
return node
def query_point(self, point: int) -> list[Interval]:
results: list[Interval] = []
self._query_point(self.root, point, results)
return results
def _query_point(self, node: Optional[Node], point: int, results: list[Interval]) -> None:
if node is None or point > node.max_end:
return
if node.interval.contains_point(point):
results.append(node.interval)
self._query_point(node.left, point, results)
if point >= node.interval.start:
self._query_point(node.right, point, results)
def query_range(self, start: int, end: int) -> list[Interval]:
query_interval = Interval(start, end)
results: list[Interval] = []
self._query_range(self.root, query_interval, results)
return results
def _query_range(self, node: Optional[Node], query: Interval, results: list[Interval]) -> None:
if node is None or query.start > node.max_end:
return
if node.interval.overlaps(query):
results.append(node.interval)
self._query_range(node.left, query, results)
if query.end >= node.interval.start:
self._query_range(node.right, query, results)
def delete(self, start: int, end: int) -> bool:
interval = Interval(start, end)
self.root, deleted = self._delete(self.root, interval)
return deleted
def _delete(self, node: Optional[Node], interval: Interval) -> tuple[Optional[Node], bool]:
if node is None:
return None, False
if node.interval.start == interval.start and node.interval.end == interval.end:
if node.left is None:
return node.right, True
if node.right is None:
return node.left, True
successor = self._min_node(node.right)
node.interval = successor.interval
node.right, _ = self._delete(node.right, successor.interval)
elif interval.start < node.interval.start:
node.left, deleted = self._delete(node.left, interval)
if not deleted:
return node, False
else:
node.right, deleted = self._delete(node.right, interval)
if not deleted:
return node, False
node.max_end = self._compute_max(node)
return node, True
def _min_node(self, node: Node) -> Node:
while node.left:
node = node.left
return node
def _compute_max(self, node: Node) -> int:
max_end = node.interval.end
if node.left:
max_end = max(max_end, node.left.max_end)
if node.right:
max_end = max(max_end, node.right.max_end)
return max_endSolution 2: Sorted list with binary search Sorted list approach using binary search for simpler implementation. O(n) queries but O(1) to understand and debug. Good baseline for smaller datasets.
"""
Interval Tree - Solution 2: Sorted list with binary search
Simpler O(n) approach using a sorted list. Good for smaller datasets or when
simplicity matters more than performance.
"""
from dataclasses import dataclass
from bisect import insort_left, bisect_left
@dataclass(frozen=True)
class Interval:
start: int
end: int
def overlaps(self, other: "Interval") -> bool:
return self.start <= other.end and other.start <= self.end
def contains_point(self, point: int) -> bool:
return self.start <= point <= self.end
def __lt__(self, other: "Interval") -> bool:
return (self.start, self.end) < (other.start, other.end)
class IntervalTree:
"""Simple interval container using sorted list."""
def __init__(self) -> None:
self._intervals: list[Interval] = []
def insert(self, start: int, end: int) -> None:
if start > end:
raise ValueError(f"Invalid interval: start {start} > end {end}")
interval = Interval(start, end)
insort_left(self._intervals, interval)
def query_point(self, point: int) -> list[Interval]:
results: list[Interval] = []
for interval in self._intervals:
if interval.start > point:
break
if interval.contains_point(point):
results.append(interval)
return results
def query_range(self, start: int, end: int) -> list[Interval]:
query = Interval(start, end)
results: list[Interval] = []
for interval in self._intervals:
if interval.start > end:
break
if interval.overlaps(query):
results.append(interval)
return results
def delete(self, start: int, end: int) -> bool:
target = Interval(start, end)
idx = bisect_left(self._intervals, target)
if idx < len(self._intervals) and self._intervals[idx] == target:
self._intervals.pop(idx)
return True
return False
def __len__(self) -> int:
return len(self._intervals)
def __iter__(self):
return iter(self._intervals)Solution 3: Centered Interval Tree Centered interval tree approach. Picks a center point and stores intervals spanning it at the node, with intervals entirely left/right recursively placed in children. Maintains two sorted lists (by start and by end descending) for efficient point queries.
"""
Interval Tree - Solution 3: Centered Interval Tree
Divides intervals by a center point. Intervals spanning the center are stored at the node,
others recursively placed in left/right subtrees.
"""
from dataclasses import dataclass, field
from typing import Optional
@dataclass(frozen=True)
class Interval:
start: int
end: int
def overlaps(self, other: "Interval") -> bool:
return self.start <= other.end and other.start <= self.end
def contains_point(self, point: int) -> bool:
return self.start <= point <= self.end
@dataclass
class CenteredNode:
center: int
by_start: list[Interval] = field(default_factory=list) # sorted by start
by_end: list[Interval] = field(default_factory=list) # sorted by end desc
left: Optional["CenteredNode"] = None
right: Optional["CenteredNode"] = None
class IntervalTree:
def __init__(self) -> None:
self._intervals: set[Interval] = set()
self._root: Optional[CenteredNode] = None
def insert(self, start: int, end: int) -> None:
interval = Interval(start, end)
self._intervals.add(interval)
self._rebuild()
def delete(self, start: int, end: int) -> bool:
interval = Interval(start, end)
if interval not in self._intervals:
return False
self._intervals.remove(interval)
self._rebuild()
return True
def _rebuild(self) -> None:
self._root = self._build(list(self._intervals))
def _build(self, intervals: list[Interval]) -> Optional[CenteredNode]:
if not intervals:
return None
points = sorted(set(p for i in intervals for p in (i.start, i.end)))
center = points[len(points) // 2]
node = CenteredNode(center=center)
left_intervals: list[Interval] = []
right_intervals: list[Interval] = []
for interval in intervals:
if interval.end < center:
left_intervals.append(interval)
elif interval.start > center:
right_intervals.append(interval)
else:
node.by_start.append(interval)
node.by_end.append(interval)
node.by_start.sort(key=lambda i: i.start)
node.by_end.sort(key=lambda i: i.end, reverse=True)
node.left = self._build(left_intervals)
node.right = self._build(right_intervals)
return node
def query_point(self, point: int) -> list[Interval]:
results: list[Interval] = []
self._query_point(self._root, point, results)
return results
def _query_point(self, node: Optional[CenteredNode], point: int, results: list[Interval]) -> None:
if node is None:
return
if point < node.center:
for interval in node.by_start:
if interval.start > point:
break
if interval.contains_point(point):
results.append(interval)
self._query_point(node.left, point, results)
elif point > node.center:
for interval in node.by_end:
if interval.end < point:
break
if interval.contains_point(point):
results.append(interval)
self._query_point(node.right, point, results)
else:
results.extend(node.by_start)
def query_range(self, start: int, end: int) -> list[Interval]:
query = Interval(start, end)
return [i for i in self._intervals if i.overlaps(query)]{{/fold}}
Question 20 - Sparse Matrix
- Difficulty: 3 / 10
- Approximate lines of code: 70 LoC
- Tags: data-structures
Description
A sparse matrix is a matrix where most elements are zero. Instead of storing all n*m elements, we only store non-zero values with their positions. Common representations include DOK (dictionary of keys) using {(row, col): value}, CSR (compressed sparse row) using arrays for values, column indices, and row pointers, and row-based dictionaries using {row: {col: value}}. The choice depends on access patterns: DOK is simple and good for random access, CSR is efficient for row operations and matrix multiplication.
The key insight for multiplication is that you only need to iterate over non-zero elements: for each non-zero A[i,k], multiply with each non-zero B[k,j] and accumulate into C[i,j]. This gives O(nnz_A * avg_row_nnz_B) instead of O(n^3).
Part A: Basic Get/Set Operations
{{fold}}{Problem: Part A}
Implement get(row, col) and set(row, col, value). Setting a value to 0 should remove it from storage (not store zeros). Accessing an unset position returns 0.
m = SparseMatrix(rows=3, cols=3)
m.set(0, 0, 1.0)
m.set(1, 1, 2.0)
m.set(2, 2, 3.0)
# Internal state (DOK): {(0,0): 1.0, (1,1): 2.0, (2,2): 3.0}
m.get(0, 0) # 1.0
m.get(0, 1) # 0.0 (not stored, returns default)
m.get(1, 1) # 2.0
m.set(1, 1, 0.0)
# Internal state: {(0,0): 1.0, (2,2): 3.0}
# Zero was removed, not stored{{/fold}}
Part B: Addition and Transpose
{{fold}}{Problem: Part B}
Implement matrix addition (A + B) and transpose (swap rows and columns). Addition only needs to iterate over non-zero positions from both matrices.
a = SparseMatrix(3, 3)
a.set(0, 0, 1.0)
a.set(1, 1, 2.0)
b = SparseMatrix(3, 3)
b.set(0, 0, 3.0) # Overlap with a
b.set(1, 2, 5.0) # New position
c = a.add(b)
c.get(0, 0) # 4.0 (1.0 + 3.0)
c.get(1, 1) # 2.0 (only in a)
c.get(1, 2) # 5.0 (only in b)
# Transpose
m = SparseMatrix(2, 3)
m.set(0, 2, 7.0)
t = m.transpose() # Now 3x2
t.get(2, 0) # 7.0 (was at row=0, col=2){{/fold}}
Part C: Matrix Multiplication
{{fold}}{Problem: Part C}
Implement matrix multiplication C = A * B. The efficient approach iterates over non-zero elements of A, and for each A[i,k], multiplies with the non-zero elements in row k of B.
# A is 2x3, B is 3x2 -> result C is 2x2
a = SparseMatrix(2, 3)
a.set(0, 0, 1.0) # Row 0: [1, 0, 2]
a.set(0, 2, 2.0)
a.set(1, 1, 3.0) # Row 1: [0, 3, 0]
b = SparseMatrix(3, 2)
b.set(0, 0, 1.0) # Col 0: [1, 0, 0]
b.set(2, 1, 4.0) # Col 1: [0, 0, 4]
c = a.multiply(b)
# C[0,0] = A[0,0]*B[0,0] + A[0,2]*B[2,0] = 1*1 + 2*0 = 1.0
# C[0,1] = A[0,0]*B[0,1] + A[0,2]*B[2,1] = 1*0 + 2*4 = 8.0
# C[1,0] = A[1,1]*B[1,0] = 3*0 = 0.0 (not stored)
# C[1,1] = A[1,1]*B[1,1] = 3*0 = 0.0 (not stored)
c.get(0, 0) # 1.0
c.get(0, 1) # 8.0{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if result of addition is 0 (1.0 + -1.0)?
- Multiplying incompatible dimensions?
- Empty matrix operations?
- What's the complexity of your multiply vs dense O(n^3)?
Common mistakes:
- Storing zeros (defeats the purpose of sparse storage)
- O(n^3) multiplication iterating over all indices
- Not checking dimension compatibility
- Accumulating into result without initializing (missing values)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses Dictionary of Keys (DOK) representation with {(row, col): value}, which is simple and good for random access. Solution 2 uses Compressed Sparse Row (CSR) format with three arrays (values, column indices, row pointers), which is more memory-efficient and cache-friendly for row operations. Solution 3 uses row-based dictionaries {row: {col: value}}, balancing DOK simplicity with efficient row access patterns. The key difference is the storage format and its access pattern tradeoffs: tuple keys vs compressed arrays vs nested dictionaries. Core techniques: sparse representations (DOK, CSR), efficient matrix multiplication via non-zero iteration.
Solution 1: Dictionary of Keys (DOK) representation Dictionary of Keys (DOK) representation using {(row, col): value}. Simple and intuitive, good for random access and incremental construction.
"""
Sparse Matrix - Solution 1: Dictionary of Keys (DOK) representation.
Simple and intuitive approach using a dictionary with (row, col) tuples as keys.
"""
from dataclasses import dataclass, field
from typing import Dict, Tuple
@dataclass
class SparseMatrix:
rows: int
cols: int
data: Dict[Tuple[int, int], float] = field(default_factory=dict)
def get(self, row: int, col: int) -> float:
if not (0 <= row < self.rows and 0 <= col < self.cols):
raise IndexError(f"Index ({row}, {col}) out of bounds")
return self.data.get((row, col), 0.0)
def set(self, row: int, col: int, value: float) -> None:
if not (0 <= row < self.rows and 0 <= col < self.cols):
raise IndexError(f"Index ({row}, {col}) out of bounds")
if value == 0.0:
self.data.pop((row, col), None)
else:
self.data[(row, col)] = value
def add(self, other: "SparseMatrix") -> "SparseMatrix":
if self.rows != other.rows or self.cols != other.cols:
raise ValueError("Matrix dimensions must match for addition")
result = SparseMatrix(self.rows, self.cols)
all_keys = set(self.data.keys()) | set(other.data.keys())
for key in all_keys:
val = self.data.get(key, 0.0) + other.data.get(key, 0.0)
if val != 0.0:
result.data[key] = val
return result
def multiply(self, other: "SparseMatrix") -> "SparseMatrix":
if self.cols != other.rows:
raise ValueError(f"Cannot multiply {self.rows}x{self.cols} by {other.rows}x{other.cols}")
result = SparseMatrix(self.rows, other.cols)
for (i, k), val_a in self.data.items():
for j in range(other.cols):
if (k, j) in other.data:
new_val = result.get(i, j) + val_a * other.data[(k, j)]
result.set(i, j, new_val)
return result
def transpose(self) -> "SparseMatrix":
result = SparseMatrix(self.cols, self.rows)
for (row, col), val in self.data.items():
result.data[(col, row)] = val
return result
def __repr__(self) -> str:
return f"SparseMatrix({self.rows}x{self.cols}, nnz={len(self.data)})"Solution 2: Compressed Sparse Row (CSR) format Compressed Sparse Row (CSR) format using three arrays: values, column indices, and row pointers. More memory-efficient and cache-friendly for row-based operations.
"""
Sparse Matrix - Solution 2: Compressed Sparse Row (CSR) format.
More memory-efficient for row-based operations and matrix multiplication.
"""
from dataclasses import dataclass, field
from typing import List
@dataclass
class SparseMatrixCSR:
rows: int
cols: int
values: List[float] = field(default_factory=list)
col_indices: List[int] = field(default_factory=list)
row_ptrs: List[int] = field(default_factory=lambda: [0])
@classmethod
def from_dict(cls, rows: int, cols: int, data: dict) -> "SparseMatrixCSR":
matrix = cls(rows, cols)
sorted_entries = sorted(data.items(), key=lambda x: (x[0][0], x[0][1]))
current_row = 0
for (r, c), v in sorted_entries:
while current_row < r:
matrix.row_ptrs.append(len(matrix.values))
current_row += 1
matrix.values.append(v)
matrix.col_indices.append(c)
while len(matrix.row_ptrs) <= rows:
matrix.row_ptrs.append(len(matrix.values))
return matrix
def get(self, row: int, col: int) -> float:
if not (0 <= row < self.rows and 0 <= col < self.cols):
raise IndexError(f"Index ({row}, {col}) out of bounds")
start, end = self.row_ptrs[row], self.row_ptrs[row + 1]
for i in range(start, end):
if self.col_indices[i] == col:
return self.values[i]
return 0.0
def to_dict(self) -> dict:
result = {}
for row in range(self.rows):
start, end = self.row_ptrs[row], self.row_ptrs[row + 1]
for i in range(start, end):
result[(row, self.col_indices[i])] = self.values[i]
return result
def add(self, other: "SparseMatrixCSR") -> "SparseMatrixCSR":
if self.rows != other.rows or self.cols != other.cols:
raise ValueError("Matrix dimensions must match")
combined = self.to_dict()
for (r, c), v in other.to_dict().items():
combined[(r, c)] = combined.get((r, c), 0.0) + v
combined = {k: v for k, v in combined.items() if v != 0.0}
return SparseMatrixCSR.from_dict(self.rows, self.cols, combined)
def multiply(self, other: "SparseMatrixCSR") -> "SparseMatrixCSR":
if self.cols != other.rows:
raise ValueError("Incompatible dimensions for multiplication")
result_dict = {}
for i in range(self.rows):
start_a, end_a = self.row_ptrs[i], self.row_ptrs[i + 1]
for idx_a in range(start_a, end_a):
k, val_a = self.col_indices[idx_a], self.values[idx_a]
start_b, end_b = other.row_ptrs[k], other.row_ptrs[k + 1]
for idx_b in range(start_b, end_b):
j, val_b = other.col_indices[idx_b], other.values[idx_b]
result_dict[(i, j)] = result_dict.get((i, j), 0.0) + val_a * val_b
result_dict = {k: v for k, v in result_dict.items() if v != 0.0}
return SparseMatrixCSR.from_dict(self.rows, other.cols, result_dict)
def transpose(self) -> "SparseMatrixCSR":
transposed = {(c, r): v for (r, c), v in self.to_dict().items()}
return SparseMatrixCSR.from_dict(self.cols, self.rows, transposed)Solution 3: Row-based dictionary representation Row-based dictionary representation using {row: {col: value}}. Balances DOK simplicity with efficient row access patterns, good for multiplication.
"""
Sparse Matrix - Solution 3: Row-based dictionary representation.
Balances simplicity of DOK with better row-access patterns.
"""
from dataclasses import dataclass, field
from typing import Dict
@dataclass
class SparseMatrixRowDict:
rows: int
cols: int
data: Dict[int, Dict[int, float]] = field(default_factory=dict)
def get(self, row: int, col: int) -> float:
if not (0 <= row < self.rows and 0 <= col < self.cols):
raise IndexError(f"Index ({row}, {col}) out of bounds")
return self.data.get(row, {}).get(col, 0.0)
def set(self, row: int, col: int, value: float) -> None:
if not (0 <= row < self.rows and 0 <= col < self.cols):
raise IndexError(f"Index ({row}, {col}) out of bounds")
if value == 0.0:
if row in self.data:
self.data[row].pop(col, None)
if not self.data[row]:
del self.data[row]
else:
if row not in self.data:
self.data[row] = {}
self.data[row][col] = value
def add(self, other: "SparseMatrixRowDict") -> "SparseMatrixRowDict":
if self.rows != other.rows or self.cols != other.cols:
raise ValueError("Matrix dimensions must match")
result = SparseMatrixRowDict(self.rows, self.cols)
all_rows = set(self.data.keys()) | set(other.data.keys())
for row in all_rows:
self_row = self.data.get(row, {})
other_row = other.data.get(row, {})
all_cols = set(self_row.keys()) | set(other_row.keys())
for col in all_cols:
val = self_row.get(col, 0.0) + other_row.get(col, 0.0)
if val != 0.0:
result.set(row, col, val)
return result
def multiply(self, other: "SparseMatrixRowDict") -> "SparseMatrixRowDict":
if self.cols != other.rows:
raise ValueError("Incompatible dimensions")
result = SparseMatrixRowDict(self.rows, other.cols)
for i, row_data in self.data.items():
for k, val_a in row_data.items():
if k in other.data:
for j, val_b in other.data[k].items():
curr = result.get(i, j)
result.set(i, j, curr + val_a * val_b)
return result
def transpose(self) -> "SparseMatrixRowDict":
result = SparseMatrixRowDict(self.cols, self.rows)
for row, row_data in self.data.items():
for col, val in row_data.items():
result.set(col, row, val)
return result
def get_row(self, row: int) -> Dict[int, float]:
"""Efficient row access - returns column->value mapping."""
if not (0 <= row < self.rows):
raise IndexError(f"Row {row} out of bounds")
return dict(self.data.get(row, {}))
def nnz(self) -> int:
"""Count of non-zero elements."""
return sum(len(row) for row in self.data.values()){{/fold}}
Question 21 - A* Pathfinding
- Difficulty: 7 / 10
- Approximate lines of code: 80 LoC
- Tags: algorithms
Description
A* is the standard algorithm for finding the shortest path on a weighted graph, combining Dijkstra's guaranteed optimality with a heuristic that guides the search toward the goal. It maintains a priority queue ordered by f(n) = g(n) + h(n), where g(n) is the actual cost from start and h(n) is the estimated cost to goal. The heuristic must be admissible (never overestimate) to guarantee the optimal path.
For grid-based pathfinding, common heuristics are Manhattan distance (for 4-directional movement) and Octile/Chebyshev distance (for 8-directional). The algorithm explores nodes in order of their f-score, updating path costs when a shorter route is found. Key data structures: a min-heap for the open set and a hash map for tracking best g-scores.
Part A: Basic A*
{{fold}}{Problem: Part A}
Implement A* on a 2D grid with 4-directional movement. Grid cells are either open (0) or blocked (1). Return the path from start to goal, or None if no path exists.
grid = [
[0, 0, 0],
[0, 1, 0], # 1 = obstacle
[0, 0, 0]
]
path = astar(grid, start=Point(0, 0), goal=Point(2, 2))
# Returns: [Point(0,0), Point(0,1), Point(0,2), Point(1,2), Point(2,2)]
# or [Point(0,0), Point(1,0), Point(2,0), Point(2,1), Point(2,2)]
# (multiple valid shortest paths exist)
# No path case:
blocked_grid = [
[0, 1, 0],
[0, 1, 0],
[0, 1, 0]
]
path = astar(blocked_grid, Point(0, 0), Point(0, 2)) # Returns NoneAlgorithm state during execution:
Start: (0,0), Goal: (2,2)
Open set (priority queue): [(h, node)] where h = manhattan distance
Step 1: Pop (0,0), g=0, f=4. Add neighbors (0,1), (1,0) to open set.
Step 2: Pop (1,0), g=1, f=4. Add (2,0).
Step 3: Pop (0,1), g=1, f=4. Add (0,2). Skip (1,1) - blocked.
...continues until goal reached{{/fold}}
Part B: Diagonal Movement
{{fold}}{Problem: Part B}
Add 8-directional movement where diagonal moves cost sqrt(2) instead of 1. Use an admissible heuristic for diagonals (Octile distance).
grid = [
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]
]
# With diagonals, can go directly (0,0) -> (1,1) -> (2,2)
path = astar(grid, Point(0, 0), Point(2, 2), allow_diagonal=True)
# Returns: [Point(0,0), Point(1,1), Point(2,2)]
# Cost: 2 * sqrt(2) = 2.83 (vs 4 with cardinal only)
# Octile heuristic for diagonals:
def octile(a, b):
dx, dy = abs(a.x - b.x), abs(a.y - b.y)
return max(dx, dy) + (sqrt(2) - 1) * min(dx, dy){{/fold}}
Part C: Weighted Terrain
{{fold}}{Problem: Part C}
Support variable movement costs per cell. Some cells (like swamps) cost more to enter.
# weights dict: cell -> cost to enter (default 1.0)
weights = {(0, 1): 5.0, (0, 2): 5.0} # Swamp cells
path = find_path(
width=3, height=3,
obstacles=set(),
weights=weights,
start=(0, 0),
goal=(0, 2)
)
# Might go around: (0,0) -> (1,0) -> (1,1) -> (1,2) -> (0,2)
# Cost: 4.0 (vs going through swamp: 1 + 5 + 5 = 11){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- Start equals goal? (Return [start])
- Start or goal is blocked? (Return None)
- What heuristic for 4-directional vs 8-directional?
- Why can't the heuristic overestimate?
Common mistakes:
- Using wrong heuristic for movement type (Manhattan for diagonals overestimates)
- Not including start in the reconstructed path
- Re-exploring nodes already in closed set (inefficient but correct)
- Using Euclidean heuristic for 4-directional (inadmissible - can overestimate)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 is a classic A* with dataclass nodes and Manhattan heuristic for 4-directional movement. Solution 2 adds a Grid class abstraction with 8-directional movement and Octile heuristic. Solution 3 takes a functional approach with weighted terrain support and returns detailed PathResult stats. These vary in movement direction support and terrain cost handling. Core techniques: priority queue (min-heap), f(n) = g(n) + h(n) scoring, admissible heuristics, path reconstruction.
Solution 1: Classic implementation Classic implementation using a priority queue with dataclass nodes. Uses Manhattan heuristic for 4-directional. Returns path list or None. Clean, minimal code.
"""A* Pathfinding - Solution 1: Classic Implementation with Priority Queue"""
from dataclasses import dataclass, field
from heapq import heappush, heappop
from typing import Callable, Optional
import math
@dataclass(frozen=True)
class Point:
x: int
y: int
def neighbors(self) -> list["Point"]:
return [Point(self.x + dx, self.y + dy) for dx, dy in [(0, 1), (1, 0), (0, -1), (-1, 0)]]
@dataclass(order=True)
class Node:
f_score: float
point: Point = field(compare=False)
g_score: float = field(compare=False)
def manhattan(a: Point, b: Point) -> float:
return abs(a.x - b.x) + abs(a.y - b.y)
def euclidean(a: Point, b: Point) -> float:
return math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2)
def astar(
grid: list[list[int]],
start: Point,
goal: Point,
heuristic: Callable[[Point, Point], float] = manhattan,
) -> Optional[list[Point]]:
"""Find shortest path using A* algorithm. Grid: 0=open, 1=obstacle."""
if not grid or not grid[0]:
return None
rows, cols = len(grid), len(grid[0])
def is_valid(p: Point) -> bool:
return 0 <= p.x < rows and 0 <= p.y < cols and grid[p.x][p.y] == 0
if not is_valid(start) or not is_valid(goal):
return None
open_set: list[Node] = []
heappush(open_set, Node(heuristic(start, goal), start, 0))
came_from: dict[Point, Point] = {}
g_scores: dict[Point, float] = {start: 0}
while open_set:
current = heappop(open_set)
if current.point == goal:
path = [goal]
while path[-1] in came_from:
path.append(came_from[path[-1]])
return path[::-1]
for neighbor in current.point.neighbors():
if not is_valid(neighbor):
continue
tentative_g = current.g_score + 1
if tentative_g < g_scores.get(neighbor, float("inf")):
came_from[neighbor] = current.point
g_scores[neighbor] = tentative_g
f_score = tentative_g + heuristic(neighbor, goal)
heappush(open_set, Node(f_score, neighbor, tentative_g))
return NoneSolution 2: Grid class with 8-directional movement Grid-based with 8-directional movement support. Uses Octile heuristic for diagonals. Diagonal moves cost sqrt(2). Includes Grid class for cleaner abstractions.
"""A* Pathfinding - Solution 2: Using a Grid class with 8-directional movement"""
from dataclasses import dataclass
from heapq import heappush, heappop
from typing import Optional
import math
CARDINAL = [(0, 1), (1, 0), (0, -1), (-1, 0)]
DIAGONAL = [(1, 1), (1, -1), (-1, 1), (-1, -1)]
@dataclass(frozen=True)
class Cell:
row: int
col: int
@dataclass
class Grid:
data: list[list[int]] # 0=walkable, 1=blocked
@property
def rows(self) -> int:
return len(self.data)
@property
def cols(self) -> int:
return len(self.data[0]) if self.data else 0
def walkable(self, c: Cell) -> bool:
return 0 <= c.row < self.rows and 0 <= c.col < self.cols and self.data[c.row][c.col] == 0
def neighbors(self, c: Cell, allow_diagonal: bool = False) -> list[tuple[Cell, float]]:
dirs = CARDINAL + DIAGONAL if allow_diagonal else CARDINAL
result = []
for dr, dc in dirs:
neighbor = Cell(c.row + dr, c.col + dc)
if self.walkable(neighbor):
cost = math.sqrt(2) if (dr != 0 and dc != 0) else 1.0
result.append((neighbor, cost))
return result
def chebyshev(a: Cell, b: Cell) -> float:
return max(abs(a.row - b.row), abs(a.col - b.col))
def octile(a: Cell, b: Cell) -> float:
dx, dy = abs(a.row - b.row), abs(a.col - b.col)
return max(dx, dy) + (math.sqrt(2) - 1) * min(dx, dy)
def astar_grid(
grid: Grid, start: Cell, goal: Cell, allow_diagonal: bool = True
) -> Optional[list[Cell]]:
"""A* with optional diagonal movement. Returns path or None."""
if not grid.walkable(start) or not grid.walkable(goal):
return None
heuristic = octile if allow_diagonal else lambda a, b: abs(a.row - b.row) + abs(a.col - b.col)
open_set: list[tuple[float, int, Cell]] = []
counter = 0
heappush(open_set, (heuristic(start, goal), counter, start))
came_from: dict[Cell, Cell] = {}
g_score: dict[Cell, float] = {start: 0}
while open_set:
_, _, current = heappop(open_set)
if current == goal:
path = []
while current in came_from:
path.append(current)
current = came_from[current]
path.append(start)
return path[::-1]
if g_score.get(current, float("inf")) < g_score[current]:
continue # Skip outdated entries
for neighbor, cost in grid.neighbors(current, allow_diagonal):
tentative = g_score[current] + cost
if tentative < g_score.get(neighbor, float("inf")):
came_from[neighbor] = current
g_score[neighbor] = tentative
counter += 1
heappush(open_set, (tentative + heuristic(neighbor, goal), counter, neighbor))
return NoneSolution 3: Functional approach with weighted terrain Functional approach with weighted terrain support. Uses tuple coordinates instead of dataclass. Separates obstacles from weights. Returns PathResult with cost and nodes explored.
"""A* Pathfinding - Solution 3: Functional approach with weighted edges"""
from dataclasses import dataclass
from heapq import heappush, heappop
from typing import Callable, Optional, TypeAlias
Coord: TypeAlias = tuple[int, int]
Heuristic: TypeAlias = Callable[[Coord, Coord], float]
@dataclass
class PathResult:
path: list[Coord]
cost: float
nodes_explored: int
def manhattan(a: Coord, b: Coord) -> float:
return abs(a[0] - b[0]) + abs(a[1] - b[1])
def find_path(
width: int,
height: int,
obstacles: set[Coord],
weights: dict[Coord, float],
start: Coord,
goal: Coord,
heuristic: Heuristic = manhattan,
) -> Optional[PathResult]:
"""
A* on a grid with weighted cells.
obstacles: impassable cells
weights: cost to enter cell (default 1.0)
"""
def in_bounds(c: Coord) -> bool:
return 0 <= c[0] < height and 0 <= c[1] < width
def passable(c: Coord) -> bool:
return c not in obstacles
def get_neighbors(c: Coord) -> list[Coord]:
r, col = c
candidates = [(r - 1, col), (r + 1, col), (r, col - 1), (r, col + 1)]
return [n for n in candidates if in_bounds(n) and passable(n)]
def edge_cost(to_node: Coord) -> float:
return weights.get(to_node, 1.0)
if not in_bounds(start) or not in_bounds(goal):
return None
if start in obstacles or goal in obstacles:
return None
open_heap: list[tuple[float, Coord]] = [(heuristic(start, goal), start)]
came_from: dict[Coord, Coord] = {}
g_score: dict[Coord, float] = {start: 0}
explored = 0
while open_heap:
_, current = heappop(open_heap)
explored += 1
if current == goal:
path = [current]
while path[-1] != start:
path.append(came_from[path[-1]])
return PathResult(path[::-1], g_score[goal], explored)
for neighbor in get_neighbors(current):
new_g = g_score[current] + edge_cost(neighbor)
if new_g < g_score.get(neighbor, float("inf")):
came_from[neighbor] = current
g_score[neighbor] = new_g
f = new_g + heuristic(neighbor, goal)
heappush(open_heap, (f, neighbor))
return None{{/fold}}
Question 22 - HyperLogLog
- Difficulty: 9 / 10
- Approximate lines of code: 100 LoC
- Tags: probabilistic, data-structures
Description
HyperLogLog (HLL) is a probabilistic data structure for estimating the cardinality (count of unique elements) of a set using minimal memory. Redis uses it for PFCOUNT. The key insight: if you hash values uniformly, the probability of seeing a hash with N leading zeros is 1/2^N. So the maximum leading zeros you've observed gives you a rough estimate of log2(cardinality). With 10 leading zeros max, you've probably seen around 2^10 = 1024 unique elements.
The core data structure is an array of "registers" (typically 2^p registers, where p=14 gives 16384 registers). Each register stores the maximum leading-zeros-plus-one (called rho) seen for hashes that map to that bucket. To add an element: hash it, use the first p bits to pick a register, count leading zeros in the remaining bits, update the register if this count is higher. To estimate cardinality: compute the harmonic mean of 2^(-register) across all registers and apply bias correction.
Part A: Basic Structure
{{fold}}{Problem: Part A}
Implement add(element) and estimate(). Use a 64-bit hash. First p bits select the bucket (register index). Remaining 64-p bits are used to count leading zeros.
hll = HyperLogLog(precision=10) # 2^10 = 1024 registers
# registers = [0, 0, 0, ..., 0] # 1024 zeros
hll.add("user_123")
# hash("user_123") = 0x3A7F... (64 bits)
# bucket = first 10 bits = 234
# remaining 54 bits: count leading zeros = 3, so rho = 4
# registers[234] = max(0, 4) = 4
hll.add("user_456")
# bucket = 891, rho = 7
# registers[891] = 7
hll.estimate() # -> approximately 2{{/fold}}
Part B: Improve Accuracy
{{fold}}{Problem: Part B}
Single-bucket estimates are noisy. Split the hash space into m buckets and combine estimates using harmonic mean. Apply the alpha correction factor based on bucket count.
def estimate(self) -> int:
m = len(self.registers) # 2^precision
# Harmonic mean of 2^(-register_value)
harmonic_sum = sum(2.0 ** (-r) for r in self.registers)
alpha = self._get_alpha(m) # Bias correction: ~0.7213 for large m
raw_estimate = alpha * m * m / harmonic_sum
return int(raw_estimate)
def _get_alpha(self, m: int) -> float:
if m == 16: return 0.673
if m == 32: return 0.697
if m == 64: return 0.709
return 0.7213 / (1 + 1.079 / m){{/fold}}
Part C: Merge and Edge Cases
{{fold}}{Problem: Part C}
Implement merge(other) that combines two HLLs - this enables distributed counting. Handle small cardinality correction (linear counting when many registers are zero) and optionally large cardinality correction.
# Merge is simple: take max of each register
def merge(self, other: HyperLogLog) -> HyperLogLog:
result = HyperLogLog(precision=self.precision)
result.registers = [max(a, b) for a, b in
zip(self.registers, other.registers)]
return result
# Small range correction in estimate():
if raw_estimate <= 2.5 * m:
zeros = self.registers.count(0)
if zeros > 0:
# Linear counting: more accurate for small cardinalities
return int(m * math.log(m / zeros))hll_west = HyperLogLog(precision=12)
hll_east = HyperLogLog(precision=12)
# Add users from west coast server
for user in west_coast_users:
hll_west.add(user)
# Add users from east coast server
for user in east_coast_users:
hll_east.add(user)
# Merge to get total unique users (handles duplicates!)
combined = hll_west.merge(hll_east)
total_unique = combined.estimate(){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if you add the same element 1000 times?
- Why is it called "leading zeros plus one" (the rho function)?
- What happens when precision is very low (4 bits = 16 registers)?
- How do you handle an empty HLL (all registers zero)?
Common mistakes:
- Off-by-one in rho function (should be leading zeros + 1, not just leading zeros)
- Using low bits instead of high bits for bucket index (high bits have better distribution)
- Using arithmetic mean instead of harmonic mean
- Forgetting small range correction (linear counting)
- Using Python's
hash()which isn't stable across runs
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 is a standard HyperLogLog with SHA-256 hashing, harmonic mean estimation, and both small-range and large-range corrections. Solution 2 uses Python's built-in hash with FNV-style bit mixing for faster hashing and adds batch processing and merge_all class method. Solution 3 is a production-quality HyperLogLog++ implementation with memory-efficient bytearray storage and serialization support. These vary in their hashing approach and additional features for production use. Core techniques: probabilistic counting, leading zeros estimation, harmonic mean, bias correction.
Solution 1: Standard HyperLogLog with SHA-256 Standard HyperLogLog with SHA-256 hashing, harmonic mean estimation, and both small-range (linear counting) and large-range corrections. Clean implementation using dataclass with configurable precision (4-16 bits).
"""
HyperLogLog Implementation - Basic Version
Uses standard HyperLogLog algorithm with bias correction.
"""
from dataclasses import dataclass, field
import hashlib
import math
@dataclass
class HyperLogLog:
"""HyperLogLog cardinality estimator with configurable precision."""
precision: int = 14 # Number of bits for bucket index (4-16 typical)
registers: list[int] = field(default_factory=list, repr=False)
def __post_init__(self) -> None:
if not 4 <= self.precision <= 16:
raise ValueError("Precision must be between 4 and 16")
num_registers = 1 << self.precision # 2^precision buckets
if not self.registers:
self.registers = [0] * num_registers
def _hash(self, element: str) -> int:
"""Hash element to 64-bit integer."""
h = hashlib.sha256(element.encode()).hexdigest()
return int(h[:16], 16) # Use first 64 bits
def _count_leading_zeros(self, value: int, max_bits: int) -> int:
"""Count leading zeros in the remaining bits after bucket selection."""
if value == 0:
return max_bits
count = 0
for i in range(max_bits - 1, -1, -1):
if value & (1 << i):
break
count += 1
return count
def add(self, element: str) -> None:
"""Add an element to the HyperLogLog."""
hash_val = self._hash(element)
# Use first 'precision' bits to determine bucket
bucket_idx = hash_val >> (64 - self.precision)
# Count leading zeros in remaining bits (+ 1 for the implicit leading 1)
remaining = hash_val & ((1 << (64 - self.precision)) - 1)
zeros = self._count_leading_zeros(remaining, 64 - self.precision) + 1
# Keep maximum zeros seen for this bucket
self.registers[bucket_idx] = max(self.registers[bucket_idx], zeros)
def estimate(self) -> int:
"""Estimate the cardinality using harmonic mean."""
m = len(self.registers)
# Harmonic mean of 2^(-register_value)
harmonic_sum = sum(2.0 ** (-r) for r in self.registers)
alpha = self._get_alpha(m)
raw_estimate = alpha * m * m / harmonic_sum
# Small range correction (linear counting)
if raw_estimate <= 2.5 * m:
zeros = self.registers.count(0)
if zeros > 0:
return int(m * math.log(m / zeros))
# Large range correction (for 64-bit hash)
if raw_estimate > (1 << 32) / 30:
return int(-(1 << 64) * math.log(1 - raw_estimate / (1 << 64)))
return int(raw_estimate)
def _get_alpha(self, m: int) -> float:
"""Get bias correction constant alpha_m."""
if m == 16:
return 0.673
if m == 32:
return 0.697
if m == 64:
return 0.709
return 0.7213 / (1 + 1.079 / m)
def merge(self, other: "HyperLogLog") -> "HyperLogLog":
"""Merge with another HyperLogLog (must have same precision)."""
if self.precision != other.precision:
raise ValueError("Cannot merge HyperLogLogs with different precision")
merged = HyperLogLog(precision=self.precision)
merged.registers = [max(a, b) for a, b in zip(self.registers, other.registers)]
return mergedSolution 2: FNV-style hashing with batch processing Uses Python's built-in hash with FNV-style bit mixing for faster hashing. Adds add_batch() for streaming, merge_all() class method for combining multiple HLLs, and error_rate() to report theoretical standard error (1.04/sqrt(m)).
"""
HyperLogLog Implementation - Using mmh3 (MurmurHash3)
Cleaner implementation with explicit register updates and streaming support.
"""
from dataclasses import dataclass, field
from typing import Iterator
import math
@dataclass
class HyperLogLog:
"""HyperLogLog using built-in hash function."""
precision: int = 12
_registers: list[int] = field(default_factory=list, init=False)
def __post_init__(self) -> None:
self._num_buckets = 1 << self.precision
self._registers = [0] * self._num_buckets
# Alpha correction factor
self._alpha = 0.7213 / (1 + 1.079 / self._num_buckets)
def _hash(self, item: str) -> int:
"""Generate 64-bit hash using Python's built-in hash with mixing."""
# Use mixing function to get better distribution
h = hash(item)
# Mix bits using FNV-style constants
h = ((h ^ (h >> 33)) * 0xFF51AFD7ED558CCD) & 0xFFFFFFFFFFFFFFFF
h = ((h ^ (h >> 33)) * 0xC4CEB9FE1A85EC53) & 0xFFFFFFFFFFFFFFFF
return h ^ (h >> 33)
def _rho(self, w: int) -> int:
"""
Position of leftmost 1-bit (1-indexed).
This is equivalent to counting leading zeros + 1.
"""
if w == 0:
return 64 - self.precision
pos = 1
while (w & 1) == 0:
w >>= 1
pos += 1
return pos
def add(self, item: str) -> None:
"""Add an item to the sketch."""
x = self._hash(item)
# First p bits determine the bucket
j = x >> (64 - self.precision)
# Remaining bits used for leading zeros count
w = x & ((1 << (64 - self.precision)) - 1)
self._registers[j] = max(self._registers[j], self._rho(w))
def add_batch(self, items: Iterator[str]) -> None:
"""Add multiple items efficiently."""
for item in items:
self.add(item)
def count(self) -> int:
"""Return estimated cardinality."""
m = self._num_buckets
# Raw harmonic mean estimator
z = sum(2.0 ** (-reg) for reg in self._registers)
e = self._alpha * m * m / z
# Small range correction using linear counting
if e <= 2.5 * m:
v = self._registers.count(0)
if v > 0:
return int(m * math.log(m / v))
return int(e)
def merge_with(self, other: "HyperLogLog") -> None:
"""Merge another HyperLogLog into this one (in-place)."""
if self.precision != other.precision:
raise ValueError(f"Precision mismatch: {self.precision} vs {other.precision}")
for i in range(self._num_buckets):
self._registers[i] = max(self._registers[i], other._registers[i])
@classmethod
def merge_all(cls, hlls: list["HyperLogLog"]) -> "HyperLogLog":
"""Merge multiple HyperLogLogs into a new one."""
if not hlls:
raise ValueError("Cannot merge empty list")
precision = hlls[0].precision
if any(h.precision != precision for h in hlls):
raise ValueError("All HyperLogLogs must have same precision")
result = cls(precision=precision)
for hll in hlls:
result.merge_with(hll)
return result
def error_rate(self) -> float:
"""Expected standard error rate: 1.04 / sqrt(m)."""
return 1.04 / math.sqrt(self._num_buckets)Solution 3: Production-quality HyperLogLog++ Production-quality HyperLogLog++ implementation with 64-bit hashes, memory-efficient bytearray storage (1 byte per register), and serialization support. Includes custom xxHash-style mixing function for fast, high-quality hashing.
"""
HyperLogLog Implementation - Production-Quality Version
Includes HyperLogLog++ improvements: 64-bit hashes and bias correction.
"""
from dataclasses import dataclass
import struct
import math
def _hash64(data: bytes) -> int:
"""64-bit hash using xxHash-style mixing."""
PRIME1 = 0x9E3779B185EBCA87
PRIME2 = 0xC2B2AE3D27D4EB4F
PRIME3 = 0x165667B19E3779F9
h = len(data) * PRIME3
for i, byte in enumerate(data):
h ^= byte * PRIME1
h = ((h /api/attachments.redirect?id= 31) | (h 33)) & 0xFFFFFFFFFFFFFFFF
h = (h * PRIME2) & 0xFFFFFFFFFFFFFFFF
# Final avalanche
h ^= h >> 33
h = (h * PRIME2) & 0xFFFFFFFFFFFFFFFF
h ^= h >> 29
h = (h * PRIME3) & 0xFFFFFFFFFFFFFFFF
h ^= h >> 32
return h
@dataclass
class HyperLogLogPlusPlus:
"""
HyperLogLog++ implementation with improved accuracy.
Reference: Heule, Nunkesser, Hall (2013)
"""
precision: int = 14 # p: number of bits for indexing (4-18)
def __post_init__(self) -> None:
if not 4 <= self.precision <= 18:
raise ValueError("Precision must be between 4 and 18")
self.m = 1 << self.precision # Number of registers
self.registers = bytearray(self.m) # Memory efficient: 1 byte per register
self._alpha = self._compute_alpha()
def _compute_alpha(self) -> float:
"""Compute bias correction constant."""
m = self.m
if m >= 128:
return 0.7213 / (1.0 + 1.079 / m)
if m == 64:
return 0.709
if m == 32:
return 0.697
return 0.673
def _leading_zeros(self, val: int, bits: int) -> int:
"""Count leading zeros plus 1 (the rho function)."""
if val == 0:
return bits + 1
count = 1
mask = 1 /api/attachments.redirect?id= (bits - 1)
while not (val & mask):
count += 1
mask = 1
return count
def add(self, element: str | bytes) -> None:
"""Add element to the HyperLogLog."""
if isinstance(element, str):
element = element.encode('utf-8')
h = _hash64(element)
# Extract bucket index from high bits
idx = h >> (64 - self.precision)
# Compute rho on remaining bits
w = h & ((1 << (64 - self.precision)) - 1)
rho = self._leading_zeros(w, 64 - self.precision)
if rho > self.registers[idx]:
self.registers[idx] = rho
def cardinality(self) -> int:
"""Estimate cardinality with bias correction."""
# Compute indicator function Z (harmonic mean)
z_inv = sum(2.0 ** (-r) for r in self.registers)
e = self._alpha * self.m * self.m / z_inv
# Apply corrections based on estimate range
if e <= 5 * self.m:
# Small range: use linear counting if there are zeros
v = self.registers.count(0)
if v != 0:
e_prime = self.m * math.log(self.m / v)
return int(e_prime)
return int(e)
def merge(self, other: "HyperLogLogPlusPlus") -> "HyperLogLogPlusPlus":
"""Create new HLL from merging two instances."""
if self.precision != other.precision:
raise ValueError("Precision mismatch")
result = HyperLogLogPlusPlus(precision=self.precision)
for i in range(self.m):
result.registers[i] = max(self.registers[i], other.registers[i])
return result
def serialize(self) -> bytes:
"""Serialize to bytes for storage/transmission."""
header = struct.pack('!B', self.precision)
return header + bytes(self.registers)
@classmethod
def deserialize(cls, data: bytes) -> "HyperLogLogPlusPlus":
"""Deserialize from bytes."""
precision = struct.unpack('!B', data[:1])[0]
hll = cls(precision=precision)
hll.registers = bytearray(data[1:])
return hll
def memory_bytes(self) -> int:
"""Return memory usage in bytes."""
return self.m # 1 byte per register
def standard_error(self) -> float:
"""Theoretical standard error: 1.04/sqrt(m)."""
return 1.04 / math.sqrt(self.m){{/fold}}
Question 23 - Collision Detection
- Difficulty: 3 / 10
- Approximate lines of code: 80 LoC
- Tags: game/simulation, algorithms
Description
Collision detection determines whether two geometric shapes overlap. In 2D games and physics engines, the most common shapes are axis-aligned bounding boxes (AABBs) and circles. An AABB is defined by its min/max corners (min_x, min_y, max_x, max_y), while a circle is defined by center (x, y) and radius. The key insight for efficiency is to avoid expensive operations like square roots when possible - comparing squared distances works for most circle checks.
For large numbers of objects, a two-phase approach is used: broad-phase (spatial partitioning like grids or quadtrees) quickly eliminates pairs that can't possibly collide, then narrow-phase performs precise geometric checks on remaining candidates.
Part A: AABB vs AABB Collision
{{fold}}{Problem: Part A}
Two AABBs collide if and only if they overlap on both axes. Check if one box is completely to the left, right, above, or below the other - if none of these are true, they collide.
box1 = AABB(min_x=0, min_y=0, max_x=10, max_y=10)
box2 = AABB(min_x=5, min_y=5, max_x=15, max_y=15)
box3 = AABB(min_x=20, min_y=20, max_x=30, max_y=30)
aabb_vs_aabb(box1, box2) # True (overlap in corner)
aabb_vs_aabb(box1, box3) # False (no overlap)
aabb_vs_aabb(box1, box1) # True (same box)
# Edge case: touching edges
box4 = AABB(min_x=10, min_y=0, max_x=20, max_y=10)
aabb_vs_aabb(box1, box4) # True (edges touch at x=10){{/fold}}
Part B: Circle vs Circle Collision
{{fold}}{Problem: Part B}
Two circles collide if the distance between their centers is less than or equal to the sum of their radii. Avoid sqrt by comparing squared values: dx^2 + dy^2 <= (r1 + r2)^2.
c1 = Circle(x=0, y=0, radius=5)
c2 = Circle(x=8, y=0, radius=5) # distance=8, radii sum=10
c3 = Circle(x=20, y=0, radius=5) # distance=20, radii sum=10
circle_vs_circle(c1, c2) # True (8 <= 10)
circle_vs_circle(c1, c3) # False (20 > 10)
# Edge case: circles just touching
c4 = Circle(x=10, y=0, radius=5)
circle_vs_circle(c1, c4) # True (10 <= 10, exactly touching){{/fold}}
Part C: AABB vs Circle Collision
{{fold}}{Problem: Part C}
Find the point on the AABB closest to the circle's center (clamp the center coordinates to the box bounds). Then check if that closest point is within the circle's radius.
box = AABB(min_x=0, min_y=0, max_x=10, max_y=10)
# Circle inside box
circle_inside = Circle(x=5, y=5, radius=2)
aabb_vs_circle(box, circle_inside) # True
# Circle outside, near corner
circle_corner = Circle(x=12, y=12, radius=3)
# Closest point on box is (10, 10)
# Distance to center: sqrt(4+4) = 2.83 < 3
aabb_vs_circle(box, circle_corner) # True
# Circle far from box
circle_far = Circle(x=20, y=20, radius=3)
# Closest point is (10, 10), distance = 14.14 > 3
aabb_vs_circle(box, circle_far) # False{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- Do touching edges/surfaces count as collision?
- What about zero-radius circles or zero-area boxes?
- Circle center exactly on box edge?
- How would you handle rotated rectangles (OBB)?
Common mistakes:
- Using sqrt when squared comparison works (performance)
- AABB-Circle: checking if center is inside, not closest point distance
- Off-by-one with <= vs < (do touching objects collide?)
- Forgetting to handle the case where circle center is inside the box
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 provides basic narrow-phase collision detection with separate functions for AABB-AABB, circle-circle, and AABB-circle checks. Solution 2 adds a uniform grid for broad-phase spatial partitioning, reducing the number of narrow-phase checks needed. Solution 3 uses a quadtree for adaptive spatial partitioning, which is more efficient than uniform grids when objects are non-uniformly distributed. The key difference is how they handle broad-phase culling: none vs uniform grid vs adaptive quadtree. Core techniques: AABB overlap tests, squared distance comparisons, spatial partitioning (grids, quadtrees).
Solution 1: Basic Collision Detection A straightforward implementation with separate functions for each collision type. Uses dataclasses for shapes and avoids sqrt by comparing squared distances.
"""
Solution 1: Basic Collision Detection
Straightforward implementation using dataclasses for shapes.
"""
from dataclasses import dataclass
import math
@dataclass
class AABB:
"""Axis-Aligned Bounding Box defined by min/max corners."""
min_x: float
min_y: float
max_x: float
max_y: float
@dataclass
class Circle:
"""Circle defined by center point and radius."""
x: float
y: float
radius: float
def aabb_vs_aabb(a: AABB, b: AABB) -> bool:
"""Check if two AABBs overlap."""
if a.max_x < b.min_x or b.max_x < a.min_x:
return False
if a.max_y < b.min_y or b.max_y < a.min_y:
return False
return True
def circle_vs_circle(a: Circle, b: Circle) -> bool:
"""Check if two circles overlap."""
dx = a.x - b.x
dy = a.y - b.y
distance_squared = dx * dx + dy * dy
radius_sum = a.radius + b.radius
return distance_squared <= radius_sum * radius_sum
def aabb_vs_circle(box: AABB, circle: Circle) -> bool:
"""Check if an AABB and circle overlap."""
# Find the closest point on the AABB to the circle center
closest_x = max(box.min_x, min(circle.x, box.max_x))
closest_y = max(box.min_y, min(circle.y, box.max_y))
# Calculate distance from circle center to closest point
dx = circle.x - closest_x
dy = circle.y - closest_y
distance_squared = dx * dx + dy * dy
return distance_squared <= circle.radius * circle.radiusSolution 2: Collision Detection with Spatial Partitioning (Grid) Adds a uniform grid for broad-phase spatial partitioning. Objects are inserted into grid cells based on their bounding box, and queries return only objects in relevant cells as collision candidates.
"""
Solution 2: Collision Detection with Spatial Partitioning (Grid)
Uses a uniform grid for efficient broad-phase collision detection.
"""
from dataclasses import dataclass, field
from typing import List, Set, Tuple, Union
import math
@dataclass
class AABB:
min_x: float
min_y: float
max_x: float
max_y: float
@dataclass
class Circle:
x: float
y: float
radius: float
def to_aabb(self) -> AABB:
"""Convert circle to bounding AABB for broad-phase."""
return AABB(
self.x - self.radius, self.y - self.radius,
self.x + self.radius, self.y + self.radius
)
Shape = Union[AABB, Circle]
@dataclass
class SpatialGrid:
"""Uniform grid for spatial partitioning."""
cell_size: float
cells: dict = field(default_factory=dict)
def _get_cell(self, x: float, y: float) -> Tuple[int, int]:
return (int(x // self.cell_size), int(y // self.cell_size))
def _get_cells_for_aabb(self, aabb: AABB) -> List[Tuple[int, int]]:
"""Get all cells that an AABB occupies."""
min_cell = self._get_cell(aabb.min_x, aabb.min_y)
max_cell = self._get_cell(aabb.max_x, aabb.max_y)
cells = []
for cx in range(min_cell[0], max_cell[0] + 1):
for cy in range(min_cell[1], max_cell[1] + 1):
cells.append((cx, cy))
return cells
def insert(self, obj_id: int, shape: Shape) -> None:
"""Insert an object into the grid."""
aabb = shape.to_aabb() if isinstance(shape, Circle) else shape
for cell in self._get_cells_for_aabb(aabb):
if cell not in self.cells:
self.cells[cell] = set()
self.cells[cell].add(obj_id)
def query(self, shape: Shape) -> Set[int]:
"""Find all objects that might collide with the given shape."""
aabb = shape.to_aabb() if isinstance(shape, Circle) else shape
candidates = set()
for cell in self._get_cells_for_aabb(aabb):
if cell in self.cells:
candidates.update(self.cells[cell])
return candidates
def clear(self) -> None:
self.cells.clear()
def check_collision(a: Shape, b: Shape) -> bool:
"""Check collision between any two shapes."""
if isinstance(a, AABB) and isinstance(b, AABB):
return not (a.max_x < b.min_x or b.max_x < a.min_x or
a.max_y < b.min_y or b.max_y < a.min_y)
if isinstance(a, Circle) and isinstance(b, Circle):
dx, dy = a.x - b.x, a.y - b.y
return dx*dx + dy*dy <= (a.radius + b.radius) ** 2
# AABB vs Circle
box, circle = (a, b) if isinstance(a, AABB) else (b, a)
closest_x = max(box.min_x, min(circle.x, box.max_x))
closest_y = max(box.min_y, min(circle.y, box.max_y))
dx, dy = circle.x - closest_x, circle.y - closest_y
return dx*dx + dy*dy <= circle.radius ** 2Solution 3: Collision Detection with Quadtree Spatial Partitioning Uses a quadtree for adaptive spatial partitioning, which is more efficient than uniform grids for non-uniform object distributions. Subdivides recursively when capacity is exceeded.
"""
Solution 3: Collision Detection with Quadtree Spatial Partitioning
More efficient than uniform grid for non-uniform object distributions.
"""
from dataclasses import dataclass, field
from typing import List, Optional, Set, Union
@dataclass
class AABB:
min_x: float
min_y: float
max_x: float
max_y: float
def contains_point(self, x: float, y: float) -> bool:
return self.min_x <= x <= self.max_x and self.min_y <= y <= self.max_y
def intersects(self, other: "AABB") -> bool:
return not (self.max_x < other.min_x or other.max_x < self.min_x or
self.max_y < other.min_y or other.max_y < self.min_y)
@dataclass
class Circle:
x: float
y: float
radius: float
def to_aabb(self) -> AABB:
return AABB(self.x - self.radius, self.y - self.radius,
self.x + self.radius, self.y + self.radius)
Shape = Union[AABB, Circle]
@dataclass
class QuadTree:
boundary: AABB
capacity: int = 4
objects: List[tuple] = field(default_factory=list) # (id, shape)
divided: bool = False
nw: Optional["QuadTree"] = None
ne: Optional["QuadTree"] = None
sw: Optional["QuadTree"] = None
se: Optional["QuadTree"] = None
def _subdivide(self) -> None:
b = self.boundary
mid_x, mid_y = (b.min_x + b.max_x) / 2, (b.min_y + b.max_y) / 2
self.nw = QuadTree(AABB(b.min_x, mid_y, mid_x, b.max_y), self.capacity)
self.ne = QuadTree(AABB(mid_x, mid_y, b.max_x, b.max_y), self.capacity)
self.sw = QuadTree(AABB(b.min_x, b.min_y, mid_x, mid_y), self.capacity)
self.se = QuadTree(AABB(mid_x, b.min_y, b.max_x, mid_y), self.capacity)
self.divided = True
def insert(self, obj_id: int, shape: Shape) -> bool:
aabb = shape.to_aabb() if isinstance(shape, Circle) else shape
if not self.boundary.intersects(aabb):
return False
if len(self.objects) < self.capacity and not self.divided:
self.objects.append((obj_id, shape))
return True
if not self.divided:
self._subdivide()
for child in (self.nw, self.ne, self.sw, self.se):
child.insert(obj_id, shape)
return True
def query(self, shape: Shape) -> Set[int]:
aabb = shape.to_aabb() if isinstance(shape, Circle) else shape
found = set()
if not self.boundary.intersects(aabb):
return found
for obj_id, _ in self.objects:
found.add(obj_id)
if self.divided:
for child in (self.nw, self.ne, self.sw, self.se):
found.update(child.query(shape))
return found
def narrow_phase(a: Shape, b: Shape) -> bool:
"""Precise collision check between two shapes."""
if isinstance(a, AABB) and isinstance(b, AABB):
return a.intersects(b)
if isinstance(a, Circle) and isinstance(b, Circle):
dx, dy = a.x - b.x, a.y - b.y
return dx*dx + dy*dy <= (a.radius + b.radius) ** 2
box, circle = (a, b) if isinstance(a, AABB) else (b, a)
cx = max(box.min_x, min(circle.x, box.max_x))
cy = max(box.min_y, min(circle.y, box.max_y))
dx, dy = circle.x - cx, circle.y - cy
return dx*dx + dy*dy <= circle.radius ** 2{{/fold}}
Question 24 - Job Scheduler
- Difficulty: 8 / 10
- Approximate lines of code: 110 LoC
- Tags: scheduling
Description
A job scheduler executes tasks based on priority while respecting dependency constraints. Jobs with higher priority run first, but only after all their dependencies have completed. The core data structures are a min-heap (priority queue) for O(log n) selection of the highest-priority ready job, and a graph of dependencies to track which jobs are blocked.
Internally, each job has a status (pending, running, completed, cancelled), a priority, and a set of dependency job IDs. When a job completes, you notify all jobs that depend on it. When all dependencies are satisfied, the job becomes ready and enters the priority queue.
Note: The
sortedcontainerslibrary (SortedList) is available. Unlikeheapq,SortedListsupports O(log n) removal of cancelled jobs instead of lazy deletion.
Part A: Priority Queue
{{fold}}{Problem: Part A}
Implement a scheduler where jobs execute in priority order. Higher priority means the job runs sooner. Use a max-heap (negate priorities in a min-heap) to efficiently select the next job.
scheduler = JobScheduler()
scheduler.add_job("compile", task=compile_fn, priority=2)
scheduler.add_job("test", task=test_fn, priority=1)
scheduler.add_job("deploy", task=deploy_fn, priority=5)
# Internal state:
# heap: [(-5, "deploy"), (-2, "compile"), (-1, "test")]
# All jobs have status=PENDING
scheduler.run_next() # Runs "deploy" (priority 5)
scheduler.run_next() # Runs "compile" (priority 2)
scheduler.run_next() # Runs "test" (priority 1){{/fold}}
Part B: Dependencies
{{fold}}{Problem: Part B}
Jobs can depend on other jobs. A job only becomes ready when all its dependencies have completed. Track a waiting_on count that decrements as dependencies finish.
scheduler = JobScheduler()
scheduler.add_job("compile", task=compile_fn, priority=2)
scheduler.add_job("test", task=test_fn, priority=5, dependencies={"compile"})
scheduler.add_job("lint", task=lint_fn, priority=3)
# "test" has priority 5, but depends on "compile"
# "lint" has priority 3 with no dependencies
# Internal state:
# heap: [(-3, "lint"), (-2, "compile")] # "test" not in heap yet
# waiting_on: {"test": 1, "compile": 0, "lint": 0}
# dependents: {"compile": ["test"]}
scheduler.run_next() # Runs "lint" (priority 3, ready)
scheduler.run_next() # Runs "compile" (priority 2, ready)
# -> "test" now has waiting_on=0, enters heap
scheduler.run_next() # Runs "test" (priority 5, now ready){{/fold}}
Part C: Cancellation
{{fold}}{Problem: Part C}
Add cancel(job_id) that cancels a pending job. When a job is cancelled, all jobs that depend on it (directly or transitively) can never run and should also be marked as failed/cancelled.
scheduler = JobScheduler()
scheduler.add_job("a", task=fn_a, priority=1)
scheduler.add_job("b", task=fn_b, priority=2, dependencies={"a"})
scheduler.add_job("c", task=fn_c, priority=3, dependencies={"b"})
scheduler.cancel("a")
# Internal state:
# jobs["a"].status = CANCELLED
# jobs["b"].status = CANCELLED (cascade)
# jobs["c"].status = CANCELLED (cascade)
scheduler.run_all() # Returns [] - nothing to run{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if a dependency doesn't exist yet when you add a job? (Track as pending)
- What happens if you cancel a job that's already running? (Cannot cancel)
- What if a job fails during execution? (Should cascade like cancellation)
- What if you add a job with a dependency that already completed? (Should be immediately ready)
Common mistakes:
- Re-sorting entire list instead of using a heap (O(n log n) vs O(log n))
- Linear scan to find dependents when a job completes (maintain reverse edges)
- Not skipping cancelled jobs when popping from heap
- Forgetting to check if dependency already exists and is completed when adding job
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 uses a simple heap with set-based dependency tracking, re-scanning all jobs on each completion. Solution 2 adds explicit reverse edges (dependents list) with a waiting_on counter for O(1) readiness checks and cascade cancellation. Solution 3 extends to async-ready design with result storage and exception propagation to dependent jobs. These vary in their approach to dependency notification efficiency and failure handling. Core techniques: min-heap/priority queue, topological ordering, graph traversal.
Solution 1: Simple Heap-Based Simple heap-based approach with sets for dependency tracking. Re-scans all pending jobs after each completion to find newly ready jobs. Clear and correct but O(n) on completion.
"""Job Scheduler - Solution 1: Simple Heap-Based Approach
Uses a priority queue (heap) for scheduling. Dependencies tracked via sets.
Jobs are processed when all dependencies are satisfied.
"""
from dataclasses import dataclass, field
from typing import Callable, Optional
from enum import Enum
import heapq
class JobStatus(Enum):
PENDING = "pending"
RUNNING = "running"
COMPLETED = "completed"
CANCELLED = "cancelled"
@dataclass(order=True)
class Job:
priority: int
job_id: str = field(compare=False)
task: Callable[[], None] = field(compare=False)
dependencies: set[str] = field(default_factory=set, compare=False)
status: JobStatus = field(default=JobStatus.PENDING, compare=False)
class JobScheduler:
def __init__(self) -> None:
self._jobs: dict[str, Job] = {}
self._ready_queue: list[tuple[int, str]] = [] # (neg_priority, job_id)
self._completed: set[str] = set()
def add_job(
self,
job_id: str,
task: Callable[[], None],
priority: int = 0,
dependencies: Optional[set[str]] = None,
) -> None:
"""Add a job to the scheduler."""
job = Job(
priority=priority,
job_id=job_id,
task=task,
dependencies=dependencies or set(),
)
self._jobs[job_id] = job
self._try_enqueue(job)
def _try_enqueue(self, job: Job) -> None:
"""Enqueue job if all dependencies are satisfied."""
if job.status != JobStatus.PENDING:
return
if job.dependencies.issubset(self._completed):
heapq.heappush(self._ready_queue, (-job.priority, job.job_id))
def cancel(self, job_id: str) -> bool:
"""Cancel a pending job. Returns True if cancelled."""
if job_id not in self._jobs:
return False
job = self._jobs[job_id]
if job.status == JobStatus.PENDING:
job.status = JobStatus.CANCELLED
return True
return False
def run_next(self) -> Optional[str]:
"""Run the highest priority ready job. Returns job_id or None."""
while self._ready_queue:
_, job_id = heapq.heappop(self._ready_queue)
job = self._jobs[job_id]
if job.status != JobStatus.PENDING:
continue
job.status = JobStatus.RUNNING
job.task()
job.status = JobStatus.COMPLETED
self._completed.add(job_id)
self._check_dependents()
return job_id
return None
def _check_dependents(self) -> None:
"""Re-check all pending jobs for dependency satisfaction."""
for job in self._jobs.values():
if job.status == JobStatus.PENDING:
self._try_enqueue(job)
def run_all(self) -> list[str]:
"""Run all jobs in priority order. Returns list of completed job_ids."""
executed = []
while (job_id := self.run_next()) is not None:
executed.append(job_id)
return executedSolution 2: Graph-Based with Reverse Edges Graph-based approach with explicit reverse edge tracking (dependents list). Maintains waiting_on counter per job for O(1) readiness check. Includes cascade cancellation for dependent jobs.
"""Job Scheduler - Solution 2: Graph-Based with Topological Awareness
Uses explicit dependency graph tracking. More efficient dependency resolution
by maintaining reverse edges (dependents list).
"""
from dataclasses import dataclass, field
from typing import Callable, Optional
from enum import Enum
import heapq
class Status(Enum):
PENDING = "pending"
RUNNING = "running"
DONE = "done"
CANCELLED = "cancelled"
@dataclass
class Job:
id: str
task: Callable[[], None]
priority: int = 0
deps: set[str] = field(default_factory=set)
status: Status = field(default=Status.PENDING)
waiting_on: int = 0 # Count of unfinished dependencies
class Scheduler:
def __init__(self) -> None:
self._jobs: dict[str, Job] = {}
self._dependents: dict[str, list[str]] = {} # job_id -> jobs waiting on it
self._heap: list[tuple[int, str]] = []
def add(
self,
job_id: str,
task: Callable[[], None],
priority: int = 0,
deps: Optional[set[str]] = None,
) -> None:
deps = deps or set()
job = Job(id=job_id, task=task, priority=priority, deps=deps)
self._jobs[job_id] = job
# Count how many deps are not yet done
for dep_id in deps:
if dep_id in self._jobs and self._jobs[dep_id].status == Status.DONE:
continue
job.waiting_on += 1
self._dependents.setdefault(dep_id, []).append(job_id)
if job.waiting_on == 0:
heapq.heappush(self._heap, (-priority, job_id))
def cancel(self, job_id: str) -> bool:
if job_id not in self._jobs:
return False
job = self._jobs[job_id]
if job.status == Status.PENDING:
job.status = Status.CANCELLED
# Propagate cancellation: jobs depending on this can never run
self._cascade_cancel(job_id)
return True
return False
def _cascade_cancel(self, job_id: str) -> None:
"""Cancel all jobs that depend on a cancelled job."""
for dep_id in self._dependents.get(job_id, []):
dep_job = self._jobs.get(dep_id)
if dep_job and dep_job.status == Status.PENDING:
dep_job.status = Status.CANCELLED
self._cascade_cancel(dep_id)
def _notify_dependents(self, job_id: str) -> None:
"""Notify dependents that this job completed."""
for dep_id in self._dependents.get(job_id, []):
dep_job = self._jobs.get(dep_id)
if dep_job and dep_job.status == Status.PENDING:
dep_job.waiting_on -= 1
if dep_job.waiting_on == 0:
heapq.heappush(self._heap, (-dep_job.priority, dep_job.id))
def step(self) -> Optional[str]:
"""Execute one job. Returns job_id or None."""
while self._heap:
_, job_id = heapq.heappop(self._heap)
job = self._jobs[job_id]
if job.status != Status.PENDING:
continue
job.status = Status.RUNNING
job.task()
job.status = Status.DONE
self._notify_dependents(job_id)
return job_id
return None
def run_all(self) -> list[str]:
order = []
while (jid := self.step()) is not None:
order.append(jid)
return orderSolution 3: Async-Ready with Result Storage Async-ready design with job result storage and exception propagation. Jobs that fail cause all dependent jobs to be marked failed with the error. Supports retrieving job results after completion.
"""Job Scheduler - Solution 3: Async-Ready with Callbacks
Designed for extensibility to async execution. Uses callbacks for completion
notification and supports job result retrieval.
"""
from dataclasses import dataclass, field
from typing import Callable, Any, Optional
from enum import Enum, auto
import heapq
class State(Enum):
WAITING = auto()
READY = auto()
RUNNING = auto()
DONE = auto()
FAILED = auto()
CANCELLED = auto()
@dataclass
class JobSpec:
id: str
fn: Callable[[], Any]
priority: int = 0
deps: frozenset[str] = field(default_factory=frozenset)
state: State = State.WAITING
result: Any = None
error: Optional[Exception] = None
class AsyncReadyScheduler:
def __init__(self) -> None:
self._jobs: dict[str, JobSpec] = {}
self._waiting_for: dict[str, set[str]] = {} # job -> deps not yet done
self._blocked_by: dict[str, set[str]] = {} # dep -> jobs waiting on it
self._ready: list[tuple[int, str]] = []
def submit(
self,
job_id: str,
fn: Callable[[], Any],
priority: int = 0,
deps: Optional[set[str]] = None,
) -> JobSpec:
deps_frozen = frozenset(deps or [])
job = JobSpec(id=job_id, fn=fn, priority=priority, deps=deps_frozen)
self._jobs[job_id] = job
# Track which deps are still pending
pending_deps = {d for d in deps_frozen if d not in self._jobs or self._jobs[d].state != State.DONE}
self._waiting_for[job_id] = pending_deps
for dep in pending_deps:
self._blocked_by.setdefault(dep, set()).add(job_id)
if not pending_deps:
job.state = State.READY
heapq.heappush(self._ready, (-priority, job_id))
return job
def cancel(self, job_id: str) -> bool:
job = self._jobs.get(job_id)
if not job or job.state not in (State.WAITING, State.READY):
return False
job.state = State.CANCELLED
self._propagate_failure(job_id)
return True
def _propagate_failure(self, job_id: str) -> None:
for blocked_id in self._blocked_by.get(job_id, []):
blocked = self._jobs[blocked_id]
if blocked.state in (State.WAITING, State.READY):
blocked.state = State.FAILED
blocked.error = Exception(f"Dependency {job_id} unavailable")
self._propagate_failure(blocked_id)
def _on_complete(self, job_id: str) -> None:
for blocked_id in self._blocked_by.get(job_id, []):
waiting = self._waiting_for.get(blocked_id, set())
waiting.discard(job_id)
if not waiting:
blocked = self._jobs[blocked_id]
if blocked.state == State.WAITING:
blocked.state = State.READY
heapq.heappush(self._ready, (-blocked.priority, blocked_id))
def tick(self) -> Optional[str]:
while self._ready:
_, job_id = heapq.heappop(self._ready)
job = self._jobs[job_id]
if job.state != State.READY:
continue
job.state = State.RUNNING
try:
job.result = job.fn()
job.state = State.DONE
except Exception as e:
job.state = State.FAILED
job.error = e
self._propagate_failure(job_id)
continue
self._on_complete(job_id)
return job_id
return None
def drain(self) -> list[str]:
completed = []
while (jid := self.tick()) is not None:
completed.append(jid)
return completed
def get_result(self, job_id: str) -> Any:
job = self._jobs.get(job_id)
if not job or job.state != State.DONE:
raise ValueError(f"Job {job_id} not completed")
return job.result{{/fold}}
Question 25 - Heartbeat Monitor
- Difficulty: 5 / 10
- Approximate lines of code: 90 LoC
- Tags: distributed-systems, concurrency
Description
{{fold}}{Concurrency Cheat Sheet}
# threading.Thread
t = threading.Thread(target=func, args=(arg,), daemon=True)
t.start()
t.join(timeout=2.0)
# threading.Lock
lock = threading.Lock()
lock.acquire()
lock.release()
with lock:
# critical section
# threading.Timer
timer = threading.Timer(5.0, callback_func)
timer.start()
timer.cancel()
# threading.Event
event = threading.Event()
event.set()
event.clear()
event.wait(timeout=1.0)
event.is_set()
# time.time() for timestamps
now = time.time()
elapsed = time.time() - start_time{{/fold}}
A heartbeat monitor tracks the health of distributed nodes by receiving periodic heartbeat signals. If a node fails to send a heartbeat within a timeout period, it is marked as unhealthy. This pattern is fundamental to distributed systems for failure detection - used in Kubernetes pod health checks, ZooKeeper session management, and service mesh health monitoring.
The core data structures are: (1) a map from node ID to last heartbeat timestamp, (2) a map tracking current node states (healthy/unhealthy), and (3) optionally a min-heap of deadlines for efficient expiration checking. The key challenge is triggering state-change callbacks only on transitions (healthy->unhealthy or vice versa), not on every check.
Note: The
sortedcontainerslibrary (SortedList) is available. Unlikeheapq,SortedListsupports O(log n) removal when a node's deadline is updated, avoiding stale heap entries.
Part A: Basic Health Tracking
{{fold}}{Problem: Part A}
Implement heartbeat(node_id) to record a heartbeat, and get_status(node_id) to return current health based on whether the last heartbeat was within the timeout.
monitor = HeartbeatMonitor(timeout_seconds=5.0)
monitor.heartbeat("node-1")
monitor.get_status("node-1") # Returns HEALTHY
time.sleep(6)
monitor.get_status("node-1") # Returns UNHEALTHY (timeout exceeded)
# Internal state after heartbeat:
# _last_heartbeat = {"node-1": 1704067200.0}
# _node_states = {"node-1": HEALTHY}{{/fold}}
Part B: State Change Callbacks
{{fold}}{Problem: Part B}
Add callbacks that fire when a node's state changes. The callback should only fire on transitions, not on every heartbeat or status check.
def on_state_change(node_id: str, new_state: NodeState):
print(f"{node_id} is now {new_state}")
monitor = HeartbeatMonitor(
timeout_seconds=5.0,
on_state_change=on_state_change
)
monitor.heartbeat("node-1") # First heartbeat, no callback (not a transition)
monitor.heartbeat("node-1") # Still healthy, no callback
time.sleep(6)
monitor.check_nodes() # Prints: "node-1 is now UNHEALTHY"
monitor.check_nodes() # No output (already unhealthy, not a transition)
monitor.heartbeat("node-1") # Prints: "node-1 is now HEALTHY"{{/fold}}
Part C: Efficient Expiration Checking
{{fold}}{Problem: Part C}
With many nodes, checking all timestamps on every call is O(n). Use a min-heap to efficiently find nodes whose deadlines have passed. Handle the problem of stale heap entries when a node's deadline is updated.
monitor = HeartbeatMonitor(timeout_seconds=5.0)
# Register 10000 nodes
for i in range(10000):
monitor.heartbeat(f"node-{i}")
# Only node-0 misses heartbeat
time.sleep(6)
for i in range(1, 10000):
monitor.heartbeat(f"node-{i}")
# Efficient: only processes expired entries from heap
failed = monitor.process_expirations() # Returns ["node-0"]
# Internal heap state uses generation numbers:
# When node-1 sends new heartbeat, generation increments
# Old heap entry for node-1 is stale (generation mismatch), skipped{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What state should a node be in after its first heartbeat? (Healthy, no transition callback)
- What if check_nodes() is called and a node is already unhealthy?
- How do you handle a node recovering (sending heartbeat after being marked unhealthy)?
- What about nodes that have never sent a heartbeat?
Common mistakes:
- Firing callback on every heartbeat, not just state transitions
- O(n) scan of all nodes on every check instead of using a heap
- Stale heap entries: node refreshes deadline but old entry still in heap causes false failure
- Using
time.time()instead oftime.monotonic()(system clock can jump) - Holding lock while firing callbacks (deadlock if callback calls back into monitor)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses a simple polling approach with dictionaries tracking last heartbeat times and current states. Solution 2 implements a timer-based approach with a min-heap of deadlines and generation numbers to handle stale entries. Solution 3 provides a thread-safe implementation with a background checker thread and proper lock handling. These vary in efficiency (O(n) polling vs O(log n) heap) and threading model (single-threaded vs background thread). Core techniques: timestamp comparison, min-heap with generation numbers, callbacks outside locks to prevent deadlock.
Solution 1: Simple polling approach Simple polling approach using dictionaries. Tracks last heartbeat time and current state per node. check_nodes() iterates all nodes to find failures. Callbacks fire outside the main logic after state changes are recorded.
"""
Heartbeat Monitor - Solution 1: Simple Polling-Based Approach
A straightforward implementation using a dictionary to track last heartbeat times.
Periodically polls to check for failed nodes.
"""
from dataclasses import dataclass, field
from typing import Callable
from enum import Enum
import time
class NodeState(Enum):
HEALTHY = "healthy"
UNHEALTHY = "unhealthy"
@dataclass
class HeartbeatMonitor:
timeout_seconds: float = 5.0
on_state_change: Callable[[str, NodeState], None] | None = None
_last_heartbeat: dict[str, float] = field(default_factory=dict)
_node_states: dict[str, NodeState] = field(default_factory=dict)
def heartbeat(self, node_id: str) -> None:
"""Record a heartbeat from a node."""
self._last_heartbeat[node_id] = time.time()
previous_state = self._node_states.get(node_id)
if previous_state != NodeState.HEALTHY:
self._node_states[node_id] = NodeState.HEALTHY
if self.on_state_change and previous_state is not None:
self.on_state_change(node_id, NodeState.HEALTHY)
elif previous_state is None:
self._node_states[node_id] = NodeState.HEALTHY
def check_nodes(self) -> list[str]:
"""Check all nodes and return list of failed node IDs."""
now = time.time()
failed_nodes = []
for node_id, last_time in self._last_heartbeat.items():
elapsed = now - last_time
previous_state = self._node_states.get(node_id)
if elapsed > self.timeout_seconds:
if previous_state != NodeState.UNHEALTHY:
self._node_states[node_id] = NodeState.UNHEALTHY
if self.on_state_change:
self.on_state_change(node_id, NodeState.UNHEALTHY)
failed_nodes.append(node_id)
return failed_nodes
def get_state(self, node_id: str) -> NodeState | None:
"""Get the current state of a node."""
return self._node_states.get(node_id)
def get_all_nodes(self) -> dict[str, NodeState]:
"""Get states of all known nodes."""
return dict(self._node_states)Solution 2: Timer-based with min-heap Timer-based approach with a min-heap of deadlines. Each node has a generation number that increments on heartbeat. Stale heap entries (generation mismatch) are skipped during processing. Supports injectable time provider for testing.
"""
Heartbeat Monitor - Solution 2: Timer-Based with Per-Node Deadlines
Uses scheduled deadlines per node with a heap for efficient expiration processing.
Handles stale heap entries by tracking generation numbers.
"""
from dataclasses import dataclass, field
from typing import Callable, Protocol
from enum import Enum
import heapq
import time
class NodeState(Enum):
HEALTHY = "healthy"
UNHEALTHY = "unhealthy"
class TimeProvider(Protocol):
def now(self) -> float: ...
class RealTimeProvider:
def now(self) -> float:
return time.time()
@dataclass
class HeapEntry:
deadline: float
generation: int
node_id: str
def __lt__(self, other: "HeapEntry") -> bool:
return self.deadline < other.deadline
@dataclass
class NodeInfo:
node_id: str
deadline: float
generation: int
state: NodeState = NodeState.HEALTHY
@dataclass
class HeartbeatMonitor:
timeout_seconds: float = 5.0
on_state_change: Callable[[str, NodeState], None] | None = None
time_provider: TimeProvider = field(default_factory=RealTimeProvider)
_nodes: dict[str, NodeInfo] = field(default_factory=dict)
_deadline_heap: list[HeapEntry] = field(default_factory=list)
def heartbeat(self, node_id: str) -> None:
"""Record a heartbeat from a node."""
now = self.time_provider.now()
new_deadline = now + self.timeout_seconds
if node_id in self._nodes:
node = self._nodes[node_id]
old_state = node.state
node.deadline = new_deadline
node.generation += 1
node.state = NodeState.HEALTHY
heapq.heappush(self._deadline_heap,
HeapEntry(new_deadline, node.generation, node_id))
if old_state == NodeState.UNHEALTHY and self.on_state_change:
self.on_state_change(node_id, NodeState.HEALTHY)
else:
node = NodeInfo(node_id=node_id, deadline=new_deadline, generation=0)
self._nodes[node_id] = node
heapq.heappush(self._deadline_heap,
HeapEntry(new_deadline, 0, node_id))
def process_expirations(self) -> list[str]:
"""Process expired deadlines and return list of newly failed nodes."""
now = self.time_provider.now()
newly_failed = []
while self._deadline_heap and self._deadline_heap[0].deadline <= now:
entry = heapq.heappop(self._deadline_heap)
current_node = self._nodes.get(entry.node_id)
# Skip stale entries (generation mismatch means deadline was updated)
if current_node is None or current_node.generation != entry.generation:
continue
if current_node.state == NodeState.HEALTHY:
current_node.state = NodeState.UNHEALTHY
newly_failed.append(entry.node_id)
if self.on_state_change:
self.on_state_change(entry.node_id, NodeState.UNHEALTHY)
return newly_failed
def get_state(self, node_id: str) -> NodeState | None:
return self._nodes[node_id].state if node_id in self._nodes else None
def get_all_nodes(self) -> dict[str, NodeState]:
return {nid: info.state for nid, info in self._nodes.items()}Solution 3: Thread-safe with background checker Production-oriented thread-safe implementation with a background checker thread. Uses locks for thread safety, fires callbacks outside the lock to prevent deadlocks. Includes start/stop lifecycle for the background thread.
"""
Heartbeat Monitor - Solution 3: Thread-Safe with Background Checker
Production-oriented implementation with background thread for automatic
failure detection and thread-safe operations.
"""
from dataclasses import dataclass, field
from typing import Callable
from enum import Enum
from threading import Lock, Thread, Event
import time
class NodeState(Enum):
HEALTHY = "healthy"
UNHEALTHY = "unhealthy"
@dataclass
class Node:
node_id: str
last_heartbeat: float
state: NodeState = NodeState.HEALTHY
@dataclass
class HeartbeatMonitor:
timeout_seconds: float = 5.0
check_interval: float = 1.0
on_state_change: Callable[[str, NodeState], None] | None = None
_nodes: dict[str, Node] = field(default_factory=dict)
_lock: Lock = field(default_factory=Lock)
_stop_event: Event = field(default_factory=Event)
_checker_thread: Thread | None = field(default=None, init=False)
def start(self) -> None:
"""Start the background checker thread."""
self._stop_event.clear()
self._checker_thread = Thread(target=self._check_loop, daemon=True)
self._checker_thread.start()
def stop(self) -> None:
"""Stop the background checker thread."""
self._stop_event.set()
if self._checker_thread:
self._checker_thread.join(timeout=2.0)
def _check_loop(self) -> None:
"""Background loop that checks for failed nodes."""
while not self._stop_event.is_set():
self._check_all_nodes()
self._stop_event.wait(self.check_interval)
def _check_all_nodes(self) -> None:
"""Check all nodes for timeout."""
now = time.time()
callbacks: list[tuple[str, NodeState]] = []
with self._lock:
for node in self._nodes.values():
elapsed = now - node.last_heartbeat
if elapsed > self.timeout_seconds and node.state == NodeState.HEALTHY:
node.state = NodeState.UNHEALTHY
callbacks.append((node.node_id, NodeState.UNHEALTHY))
# Fire callbacks outside lock to prevent deadlock
for node_id, state in callbacks:
if self.on_state_change:
self.on_state_change(node_id, state)
def heartbeat(self, node_id: str) -> None:
"""Record a heartbeat from a node (thread-safe)."""
now = time.time()
callback: tuple[str, NodeState] | None = None
with self._lock:
if node_id in self._nodes:
node = self._nodes[node_id]
node.last_heartbeat = now
if node.state == NodeState.UNHEALTHY:
node.state = NodeState.HEALTHY
callback = (node_id, NodeState.HEALTHY)
else:
self._nodes[node_id] = Node(node_id=node_id, last_heartbeat=now)
if callback and self.on_state_change:
self.on_state_change(callback[0], callback[1])
def get_state(self, node_id: str) -> NodeState | None:
with self._lock:
return self._nodes[node_id].state if node_id in self._nodes else None
def get_all_nodes(self) -> dict[str, NodeState]:
with self._lock:
return {nid: n.state for nid, n in self._nodes.items()}{{/fold}}
Question 26 - Bitmap Index
- Difficulty: 2 / 10
- Approximate lines of code: 120 LoC
- Tags: data-structures, storage
Description
A bitmap index accelerates queries on low-cardinality columns (columns with few distinct values, like "status" or "color"). For each distinct value in a column, we maintain a bitmap where bit i is 1 if row i has that value. Queries become bitwise operations: AND for intersection, OR for union, NOT for complement. This is how databases like Oracle and PostgreSQL speed up OLAP queries.
For a table with 5 rows and a "color" column with values ["red", "blue", "red", "green", "blue"], we create three bitmaps:
- red: 10100 (rows 0, 2)
- blue: 01001 (rows 1, 4)
- green: 00010 (row 3)
Finding rows where color="red" AND size="S" becomes red_bitmap & small_bitmap, which is O(n/64) operations using 64-bit words.
Part A: Basic Bitmap Operations
{{fold}}{Problem: Part A}
Implement a Bitmap class supporting AND, OR, NOT operations and a method to get matching row indices. Use Python's arbitrary-precision integers as the underlying bit storage.
# Build bitmaps from column values
index = BitmapIndex("color")
index.build(["red", "blue", "red", "green", "blue"])
# Internal state after build:
# bitmaps = {
# "red": Bitmap(bits=0b00101, size=5), # rows 0, 2
# "blue": Bitmap(bits=0b10010, size=5), # rows 1, 4
# "green": Bitmap(bits=0b01000, size=5), # row 3
# }
red = index.get("red")
red.get_matching_rows() # [0, 2]
blue = index.get("blue")
(red | blue).get_matching_rows() # [0, 1, 2, 4]{{/fold}}
Part B: Multi-Condition Queries
{{fold}}{Problem: Part B}
Build a Table class that indexes multiple columns and supports queries with AND/OR across conditions.
table = Table()
table.add_column("color", ["red", "blue", "red", "green", "blue"])
table.add_column("size", ["S", "M", "L", "S", "M"])
# Internal state:
# indexes = {
# "color": BitmapIndex with bitmaps for red, blue, green
# "size": BitmapIndex with bitmaps for S, M, L
# }
# Find rows where color="blue" AND size="M"
table.query([("color", "blue"), ("size", "M")], op="AND")
# blue = 0b10010, M = 0b10010
# AND result = 0b10010 -> [1, 4]
# Find rows where color="red" OR color="green"
table.query([("color", "red"), ("color", "green")], op="OR")
# red = 0b00101, green = 0b01000
# OR result = 0b01101 -> [0, 2, 3]{{/fold}}
Part C: NOT Operation and Compression Discussion
{{fold}}{Problem: Part C}
Implement NOT correctly (must mask to valid rows only). Discuss compression schemes for sparse bitmaps (RLE, WAH).
red = index.get("red") # bits=0b00101, size=5
not_red = ~red # Must mask: ~0b00101 & 0b11111 = 0b11010
not_red.get_matching_rows() # [1, 3, 4]
# Without masking, ~0b00101 = ...111111111111111111111010 (infinite 1s)
# This would return invalid row indices
# Compression discussion:
# - Run-Length Encoding: Store (value, count) pairs
# [1,1,1,1,0,0,0,0] -> [(1,4), (0,4)]
# - Word-Aligned Hybrid (WAH): Fixed word size with fill/literal encoding
# - When to compress: High cardinality columns, sparse data{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when querying for a value that doesn't exist in the column?
- How does NOT behave if you don't mask to the valid row range?
- What's the space complexity for a column with N distinct values and M rows?
- When would bitmap indexes perform worse than B-tree indexes?
Common mistakes:
- NOT without masking to valid row range (returns infinite/invalid rows)
- Using Python's hash() which is non-deterministic across runs
- Not handling empty result sets gracefully
- Off-by-one errors when converting bitmap to row indices
- Assuming bitmap indexes are always better (they're not for high-cardinality columns)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses Python's arbitrary-precision integers for raw bitmap storage with basic AND/OR/NOT operations. Solution 2 implements Run-Length Encoding (RLE) compression storing (value, count) pairs for efficient handling of clustered data. Solution 3 implements Word-Aligned Hybrid (WAH) compression with fixed-size words and fill/literal encoding for CPU-aligned operations. The key difference is the storage format and compression tradeoffs: raw bits for simplicity, RLE for clustered patterns, WAH for practical CPU efficiency. Core techniques: bitwise operations, bit masking for NOT, run-length encoding, word-aligned compression.
Solution 1: Basic Implementation Basic implementation using Python's arbitrary-precision integers for bitmaps. Implements AND, OR, NOT with proper masking, and builds indexes from column values.
"""
Bitmap Index - Solution 1: Basic Implementation
Simple bitmap indexing with AND/OR/NOT operations, no compression.
"""
from dataclasses import dataclass, field
from typing import Any
@dataclass
class Bitmap:
"""A bitmap representing rows matching a condition."""
bits: int # Using Python's arbitrary-precision int as bit array
size: int # Number of rows
def __and__(self, other: "Bitmap") -> "Bitmap":
return Bitmap(self.bits & other.bits, self.size)
def __or__(self, other: "Bitmap") -> "Bitmap":
return Bitmap(self.bits | other.bits, self.size)
def __invert__(self) -> "Bitmap":
mask = (1 << self.size) - 1
return Bitmap(~self.bits & mask, self.size)
def get_matching_rows(self) -> list[int]:
"""Return indices of rows where bit is set."""
return [i for i in range(self.size) if self.bits & (1 << i)]
@dataclass
class BitmapIndex:
"""Bitmap index for a single column."""
column_name: str
bitmaps: dict[Any, Bitmap] = field(default_factory=dict)
row_count: int = 0
def build(self, values: list[Any]) -> None:
"""Build bitmap index from column values."""
self.row_count = len(values)
value_rows: dict[Any, int] = {}
for i, value in enumerate(values):
if value not in value_rows:
value_rows[value] = 0
value_rows[value] |= (1 << i)
self.bitmaps = {v: Bitmap(bits, self.row_count) for v, bits in value_rows.items()}
def get(self, value: Any) -> Bitmap:
"""Get bitmap for a specific value."""
return self.bitmaps.get(value, Bitmap(0, self.row_count))
@dataclass
class Table:
"""Simple table with bitmap indexes."""
columns: dict[str, list[Any]] = field(default_factory=dict)
indexes: dict[str, BitmapIndex] = field(default_factory=dict)
def add_column(self, name: str, values: list[Any]) -> None:
self.columns[name] = values
index = BitmapIndex(name)
index.build(values)
self.indexes[name] = index
def query(self, conditions: list[tuple[str, Any]], op: str = "AND") -> list[int]:
"""Query with multiple conditions combined with AND or OR."""
if not conditions:
return []
col, val = conditions[0]
result = self.indexes[col].get(val)
for col, val in conditions[1:]:
bitmap = self.indexes[col].get(val)
result = result & bitmap if op == "AND" else result | bitmap
return result.get_matching_rows()
if __name__ == "__main__":
# Smoke tests
table = Table()
table.add_column("color", ["red", "blue", "red", "green", "blue"])
table.add_column("size", ["S", "M", "L", "S", "M"])
# Test single condition
assert table.query([("color", "red")]) == [0, 2], "Red rows should be 0, 2"
# Test AND query
assert table.query([("color", "blue"), ("size", "M")], "AND") == [1, 4]
# Test OR query
assert table.query([("color", "red"), ("color", "green")], "OR") == [0, 2, 3]
# Test NOT operation
red_bitmap = table.indexes["color"].get("red")
not_red = ~red_bitmap
assert not_red.get_matching_rows() == [1, 3, 4], "NOT red should be 1, 3, 4"
print("All tests passed!")Solution 2: Run-Length Encoding Compression Implements Run-Length Encoding (RLE) compression for bitmaps. Stores (bit_value, count) pairs instead of raw bits. Efficient for clustered data where same values appear consecutively.
"""
Bitmap Index - Solution 2: Run-Length Encoding Compression
Compressed bitmap using RLE for sparse data.
"""
from dataclasses import dataclass, field
from typing import Any
@dataclass
class RLEBitmap:
"""Run-length encoded bitmap: stores (value, count) pairs."""
runs: list[tuple[int, int]] = field(default_factory=list) # (bit_value, run_length)
size: int = 0
@classmethod
def from_bits(cls, bits: int, size: int) -> "RLEBitmap":
"""Create RLE bitmap from raw bits."""
if size == 0:
return cls([], 0)
runs = []
current_bit = bits & 1
count = 0
for i in range(size):
bit = (bits >> i) & 1
if bit == current_bit:
count += 1
else:
runs.append((current_bit, count))
current_bit = bit
count = 1
runs.append((current_bit, count))
return cls(runs, size)
def to_bits(self) -> int:
"""Decompress to raw bits."""
bits = 0
pos = 0
for bit_val, count in self.runs:
if bit_val:
for i in range(count):
bits |= (1 << (pos + i))
pos += count
return bits
def __and__(self, other: "RLEBitmap") -> "RLEBitmap":
return RLEBitmap.from_bits(self.to_bits() & other.to_bits(), self.size)
def __or__(self, other: "RLEBitmap") -> "RLEBitmap":
return RLEBitmap.from_bits(self.to_bits() | other.to_bits(), self.size)
def __invert__(self) -> "RLEBitmap":
return RLEBitmap([(1 - v, c) for v, c in self.runs], self.size)
def get_matching_rows(self) -> list[int]:
result = []
pos = 0
for bit_val, count in self.runs:
if bit_val:
result.extend(range(pos, pos + count))
pos += count
return result
def compression_ratio(self) -> float:
"""Return compression ratio (lower is better)."""
if self.size == 0:
return 0.0
return len(self.runs) * 2 / self.size # 2 values per run vs 1 bit per row
@dataclass
class CompressedBitmapIndex:
"""Bitmap index using RLE compression."""
column_name: str
bitmaps: dict[Any, RLEBitmap] = field(default_factory=dict)
row_count: int = 0
def build(self, values: list[Any]) -> None:
self.row_count = len(values)
value_bits: dict[Any, int] = {}
for i, value in enumerate(values):
if value not in value_bits:
value_bits[value] = 0
value_bits[value] |= (1 << i)
self.bitmaps = {
v: RLEBitmap.from_bits(bits, self.row_count)
for v, bits in value_bits.items()
}
def get(self, value: Any) -> RLEBitmap:
return self.bitmaps.get(value, RLEBitmap([(0, self.row_count)], self.row_count))
if __name__ == "__main__":
# Test RLE compression
bitmap = RLEBitmap.from_bits(0b11110000, 8)
assert bitmap.runs == [(0, 4), (1, 4)], f"Unexpected runs: {bitmap.runs}"
assert bitmap.to_bits() == 0b11110000
# Test operations
a = RLEBitmap.from_bits(0b1100, 4)
b = RLEBitmap.from_bits(0b1010, 4)
assert (a & b).to_bits() == 0b1000
assert (a | b).to_bits() == 0b1110
assert (~a).to_bits() == 0b0011
# Test index
index = CompressedBitmapIndex("status")
index.build(["active"] * 100 + ["inactive"] * 100)
active_bitmap = index.get("active")
assert active_bitmap.get_matching_rows() == list(range(100))
print(f"Compression ratio for clustered data: {active_bitmap.compression_ratio():.3f}")
# Sparse data compresses well with RLE
sparse = RLEBitmap.from_bits(0b1, 1000)
print(f"Compression ratio for sparse data: {sparse.compression_ratio():.3f}")
print("All tests passed!")Solution 3: Word-Aligned Hybrid (WAH) Style Implements Word-Aligned Hybrid (WAH) compression. Uses fixed-size words with fill/literal encoding. More practical for real systems as it aligns with CPU word sizes.
"""
Bitmap Index - Solution 3: Word-Aligned Hybrid (WAH) Style
Practical approach using fixed-size words with fill/literal encoding.
"""
from dataclasses import dataclass, field
from typing import Any
from enum import Enum
class WordType(Enum):
LITERAL = 0 # Word contains raw bits
FILL_ZEROS = 1 # Word represents N consecutive zero-words
FILL_ONES = 2 # Word represents N consecutive one-words
WORD_SIZE = 31 # Bits per word (leaving 1 for type indicator in real impl)
@dataclass
class WAHBitmap:
"""Word-aligned hybrid compressed bitmap."""
words: list[tuple[WordType, int]] = field(default_factory=list)
size: int = 0
@classmethod
def from_bits(cls, bits: int, size: int) -> "WAHBitmap":
"""Compress raw bits into WAH format."""
words = []
num_words = (size + WORD_SIZE - 1) // WORD_SIZE
i = 0
while i < num_words:
word = (bits >> (i * WORD_SIZE)) & ((1 /api/attachments.redirect?id= WORD_SIZE) - 1)
all_zeros = word == 0
all_ones = word == (1 << min(WORD_SIZE, size - i * WORD_SIZE)) - 1
if all_zeros or all_ones:
# Count consecutive fill words
fill_type = WordType.FILL_ZEROS if all_zeros else WordType.FILL_ONES
count = 1
while i + count < num_words:
next_word = (bits ((i + count) * WORD_SIZE)) & ((1 << WORD_SIZE) - 1)
if (fill_type == WordType.FILL_ZEROS and next_word == 0) or \
(fill_type == WordType.FILL_ONES and next_word == (1 << WORD_SIZE) - 1):
count += 1
else:
break
words.append((fill_type, count))
i += count
else:
words.append((WordType.LITERAL, word))
i += 1
return cls(words, size)
def to_bits(self) -> int:
"""Decompress to raw bits."""
bits = 0
pos = 0
for word_type, value in self.words:
if word_type == WordType.LITERAL:
bits |= value << (pos * WORD_SIZE)
pos += 1
elif word_type == WordType.FILL_ONES:
for _ in range(value):
bits |= ((1 << WORD_SIZE) - 1) << (pos * WORD_SIZE)
pos += 1
else: # FILL_ZEROS
pos += value
return bits
def __and__(self, other: "WAHBitmap") -> "WAHBitmap":
return WAHBitmap.from_bits(self.to_bits() & other.to_bits(), self.size)
def __or__(self, other: "WAHBitmap") -> "WAHBitmap":
return WAHBitmap.from_bits(self.to_bits() | other.to_bits(), self.size)
def __invert__(self) -> "WAHBitmap":
mask = (1 << self.size) - 1
return WAHBitmap.from_bits(~self.to_bits() & mask, self.size)
def get_matching_rows(self) -> list[int]:
bits = self.to_bits()
return [i for i in range(self.size) if bits & (1 << i)]
def word_count(self) -> int:
return len(self.words)
@dataclass
class WAHIndex:
"""Bitmap index using WAH compression."""
bitmaps: dict[Any, WAHBitmap] = field(default_factory=dict)
row_count: int = 0
def build(self, values: list[Any]) -> None:
self.row_count = len(values)
value_bits: dict[Any, int] = {}
for i, v in enumerate(values):
value_bits.setdefault(v, 0)
value_bits[v] |= (1 << i)
self.bitmaps = {v: WAHBitmap.from_bits(b, self.row_count) for v, b in value_bits.items()}
def get(self, value: Any) -> WAHBitmap:
return self.bitmaps.get(value, WAHBitmap.from_bits(0, self.row_count))
if __name__ == "__main__":
# Test WAH compression with clustered data
clustered = (1 << 100) - 1 # First 100 bits set
wah = WAHBitmap.from_bits(clustered, 200)
assert wah.to_bits() == clustered
print(f"Clustered data: {wah.word_count()} words for 200 bits")
# Test operations
a = WAHBitmap.from_bits(0b1100, 4)
b = WAHBitmap.from_bits(0b1010, 4)
assert (a & b).to_bits() == 0b1000
assert (a | b).to_bits() == 0b1110
# Test index
index = WAHIndex()
index.build(["A"] * 50 + ["B"] * 50 + ["A"] * 50)
assert index.get("A").get_matching_rows() == list(range(50)) + list(range(100, 150))
print("All tests passed!"){{/fold}}
Question 27 - Rope
- Difficulty: 8 / 10
- Approximate lines of code: 130 LoC
- Tags: data-structures
Description
A rope is a binary tree data structure for efficiently representing and manipulating long strings. Unlike a standard string where concatenation is O(n), a rope achieves O(1) concatenation by creating a new parent node that points to both strings. This makes ropes ideal for text editors where users frequently insert, delete, and concatenate text at arbitrary positions.
The key insight is that leaf nodes store actual string fragments, while internal nodes store only metadata. Each internal node tracks its "weight" - the total length of its left subtree - which enables O(log n) character indexing by comparing the target index against the weight to decide whether to go left or right.
Part A: Structure and Concatenation
{{fold}}{Problem: Part A}
Implement the basic rope structure with concat() that joins two ropes in O(1) time, and to_string() that flattens the rope back to a string.
r1 = Rope("Hello, ")
r2 = Rope("World!")
r3 = r1.concat(r2)
print(r3.to_string()) # "Hello, World!"
print(len(r3)) # 13Internal state after concat:
[weight=7] <- new root, weight = len(left subtree)
/ \
"Hello, " "World!" <- leaf nodes with actual text{{/fold}}
Part B: Index Access
{{fold}}{Problem: Part B}
Implement index(i) that retrieves the character at position i in O(log n) time for a balanced tree.
The algorithm: at each node, if i < weight, recurse left. Otherwise, recurse right with i - weight.
r3.index(0) # 'H' - go left (0 < 7)
r3.index(7) # 'W' - go right (7 >= 7), then index 0 in right subtree
r3.index(12) # '!' - go right, then index 5 in "World!"{{/fold}}
Part C: Split
{{fold}}{Problem: Part C}
Implement split(i) that divides a rope at position i, returning two ropes (left, right).
This is the trickiest operation. You must recursively descend to find the split point, potentially splitting a leaf node itself, then reconstruct the tree structure.
left, right = r3.split(7)
left.to_string() # "Hello, "
right.to_string() # "World!"
# Splitting mid-leaf:
r = Rope("abcdef")
l, r = r.split(3)
l.to_string() # "abc"
r.to_string() # "def"{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when concatenating with an empty rope?
- What if split position is 0 or equal to length?
- How do you handle negative indices?
- What's the time complexity if the tree becomes unbalanced (repeated concat on one side)?
Common mistakes:
- Confusing weight (left subtree length) with total node length
- Off-by-one errors in split, especially at leaf boundaries
- Not handling empty rope/None cases
- Forgetting to recurse with adjusted index (
i - weight) when going right
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 is a basic recursive implementation using weight-based tree traversal. Solution 2 adds AVL-style balancing with rotations to maintain O(log n) height. Solution 3 takes a functional/immutable approach with frozen dataclasses and Python operator support. The key difference is how they handle tree balance and mutability. Core techniques: binary tree traversal, weight-based indexing, recursive split with tree reconstruction.
Solution 1: Basic recursive implementation Basic recursive implementation using dataclasses. Uses RopeNode with weight field for left subtree length. Split recursively descends and reconstructs parent nodes.
"""
Rope Data Structure - Solution 1: Basic Implementation
A rope is a binary tree where leaves contain string fragments.
Supports O(1) concatenation, O(log n) indexing with balanced tree.
"""
from __future__ import annotations
from dataclasses import dataclass
from typing import Optional
@dataclass
class RopeNode:
"""A node in the rope tree. Leaves have text, internal nodes have children."""
left: Optional[RopeNode] = None
right: Optional[RopeNode] = None
text: Optional[str] = None
weight: int = 0 # Length of left subtree (or text length for leaves)
@staticmethod
def from_string(s: str) -> RopeNode:
"""Create a leaf node from a string."""
return RopeNode(text=s, weight=len(s))
def is_leaf(self) -> bool:
return self.text is not None
class Rope:
"""Rope data structure for efficient string operations."""
def __init__(self, text: str = ""):
self.root: Optional[RopeNode] = RopeNode.from_string(text) if text else None
def __len__(self) -> int:
return self._total_length(self.root)
def _total_length(self, node: Optional[RopeNode]) -> int:
if node is None:
return 0
if node.is_leaf():
return node.weight
return node.weight + self._total_length(node.right)
def concat(self, other: Rope) -> Rope:
"""Concatenate two ropes in O(1) time."""
result = Rope()
if self.root is None:
result.root = other.root
elif other.root is None:
result.root = self.root
else:
result.root = RopeNode(
left=self.root,
right=other.root,
weight=len(self)
)
return result
def index(self, i: int) -> str:
"""Get character at position i in O(log n) time for balanced tree."""
if i < 0 or i >= len(self):
raise IndexError(f"Index {i} out of range")
return self._index(self.root, i)
def _index(self, node: RopeNode, i: int) -> str:
if node.is_leaf():
return node.text[i]
if i < node.weight:
return self._index(node.left, i)
return self._index(node.right, i - node.weight)
def split(self, i: int) -> tuple[Rope, Rope]:
"""Split rope at position i, returning (left, right) ropes."""
if i <= 0:
return Rope(), self
if i >= len(self):
return self, Rope()
left_node, right_node = self._split(self.root, i)
left_rope, right_rope = Rope(), Rope()
left_rope.root, right_rope.root = left_node, right_node
return left_rope, right_rope
def _split(self, node: RopeNode, i: int) -> tuple[Optional[RopeNode], Optional[RopeNode]]:
if node.is_leaf():
left = RopeNode.from_string(node.text[:i]) if i > 0 else None
right = RopeNode.from_string(node.text[i:]) if i < len(node.text) else None
return left, right
if i < node.weight:
left, mid = self._split(node.left, i)
right = RopeNode(left=mid, right=node.right, weight=node.weight - i) if mid or node.right else node.right
return left, right
elif i > node.weight:
mid, right = self._split(node.right, i - node.weight)
left = RopeNode(left=node.left, right=mid, weight=node.weight) if node.left or mid else mid
return left, right
return node.left, node.right
def to_string(self) -> str:
"""Convert rope back to string."""
return self._collect(self.root)
def _collect(self, node: Optional[RopeNode]) -> str:
if node is None:
return ""
if node.is_leaf():
return node.text
return self._collect(node.left) + self._collect(node.right)Solution 2: AVL-style balancing Adds AVL-style tree balancing to maintain O(log n) height. Tracks node height and rebalances after concat using rotations. Updates weight during rotations.
"""
Rope Data Structure - Solution 2: With Tree Balancing
Implements AVL-style balancing to maintain O(log n) operations.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class RopeNode:
left: Optional[RopeNode] = None
right: Optional[RopeNode] = None
text: Optional[str] = None
weight: int = 0
height: int = 1
@staticmethod
def leaf(s: str) -> RopeNode:
return RopeNode(text=s, weight=len(s), height=1)
def is_leaf(self) -> bool:
return self.text is not None
def get_height(node: Optional[RopeNode]) -> int:
return node.height if node else 0
def get_balance(node: RopeNode) -> int:
return get_height(node.left) - get_height(node.right)
def update_height(node: RopeNode) -> None:
node.height = 1 + max(get_height(node.left), get_height(node.right))
def total_length(node: Optional[RopeNode]) -> int:
if node is None:
return 0
if node.is_leaf():
return node.weight
return node.weight + total_length(node.right)
def rotate_right(y: RopeNode) -> RopeNode:
x = y.left
t2 = x.right
x.right = y
y.left = t2
y.weight = total_length(y.left)
update_height(y)
update_height(x)
return x
def rotate_left(x: RopeNode) -> RopeNode:
y = x.right
t2 = y.left
y.left = x
x.right = t2
x.weight = total_length(x.left)
y.weight = total_length(y.left)
update_height(x)
update_height(y)
return y
def balance(node: RopeNode) -> RopeNode:
update_height(node)
bal = get_balance(node)
if bal > 1:
if get_balance(node.left) < 0:
node.left = rotate_left(node.left)
return rotate_right(node)
if bal < -1:
if get_balance(node.right) > 0:
node.right = rotate_right(node.right)
return rotate_left(node)
return node
class Rope:
def __init__(self, text: str = ""):
self.root: Optional[RopeNode] = RopeNode.leaf(text) if text else None
def __len__(self) -> int:
return total_length(self.root)
def concat(self, other: Rope) -> Rope:
result = Rope()
if not self.root:
result.root = other.root
elif not other.root:
result.root = self.root
else:
node = RopeNode(left=self.root, right=other.root, weight=len(self))
result.root = balance(node)
return result
def index(self, i: int) -> str:
if i < 0 or i >= len(self):
raise IndexError(f"Index {i} out of range")
node = self.root
while node:
if node.is_leaf():
return node.text[i]
if i < node.weight:
node = node.left
else:
i -= node.weight
node = node.right
raise IndexError("Invalid rope structure")
def split(self, i: int) -> tuple[Rope, Rope]:
if i <= 0:
return Rope(), self
if i >= len(self):
return self, Rope()
left_node, right_node = self._split(self.root, i)
left_rope, right_rope = Rope(), Rope()
left_rope.root = left_node
right_rope.root = right_node
return left_rope, right_rope
def _split(self, node: RopeNode, i: int) -> tuple[Optional[RopeNode], Optional[RopeNode]]:
if node.is_leaf():
l = RopeNode.leaf(node.text[:i]) if i > 0 else None
r = RopeNode.leaf(node.text[i:]) if i < len(node.text) else None
return l, r
if i <= node.weight:
left, mid = self._split(node.left, i)
right = self._merge(mid, node.right)
return left, right
mid, right = self._split(node.right, i - node.weight)
left = self._merge(node.left, mid)
return left, right
def _merge(self, a: Optional[RopeNode], b: Optional[RopeNode]) -> Optional[RopeNode]:
if not a:
return b
if not b:
return a
return balance(RopeNode(left=a, right=b, weight=total_length(a)))
def to_string(self) -> str:
parts = []
self._collect(self.root, parts)
return "".join(parts)
def _collect(self, node: Optional[RopeNode], parts: list[str]) -> None:
if node is None:
return
if node.is_leaf():
parts.append(node.text)
else:
self._collect(node.left, parts)
self._collect(node.right, parts)Solution 3: Functional/immutable approach Functional/immutable approach using frozen dataclasses. Stores explicit size field. Supports Python operators (+, []), negative indexing, and insert/delete operations built on split.
"""
Rope Data Structure - Solution 3: Functional Style with Immutability
Uses immutable nodes for easier reasoning and thread safety.
"""
from __future__ import annotations
from dataclasses import dataclass
from typing import Optional, Iterator
@dataclass(frozen=True)
class Node:
"""Immutable rope node."""
left: Optional[Node] = None
right: Optional[Node] = None
text: Optional[str] = None
weight: int = 0
size: int = 0
@staticmethod
def leaf(s: str) -> Node:
return Node(text=s, weight=len(s), size=len(s))
@staticmethod
def branch(left: Node, right: Node) -> Node:
return Node(left=left, right=right, weight=left.size, size=left.size + right.size)
def is_leaf(self) -> bool:
return self.text is not None
@dataclass(frozen=True)
class Rope:
"""Immutable rope data structure."""
root: Optional[Node] = None
@staticmethod
def from_string(s: str) -> Rope:
return Rope(Node.leaf(s)) if s else Rope()
def __len__(self) -> int:
return self.root.size if self.root else 0
def __add__(self, other: Rope) -> Rope:
"""Concatenate using + operator."""
if not self.root:
return other
if not other.root:
return self
return Rope(Node.branch(self.root, other.root))
def __getitem__(self, i: int) -> str:
"""Index using [] operator."""
if i < 0:
i += len(self)
if i < 0 or i >= len(self):
raise IndexError(f"Index {i} out of range")
return self._index(self.root, i)
def _index(self, node: Node, i: int) -> str:
if node.is_leaf():
return node.text[i]
if i < node.weight:
return self._index(node.left, i)
return self._index(node.right, i - node.weight)
def split(self, i: int) -> tuple[Rope, Rope]:
"""Split into two ropes at position i."""
if i <= 0:
return Rope(), self
if i >= len(self):
return self, Rope()
left, right = self._split(self.root, i)
return Rope(left), Rope(right)
def _split(self, node: Node, i: int) -> tuple[Optional[Node], Optional[Node]]:
if node.is_leaf():
left = Node.leaf(node.text[:i]) if i > 0 else None
right = Node.leaf(node.text[i:]) if i < len(node.text) else None
return left, right
if i <= node.weight:
left, mid = self._split(node.left, i)
right = self._join(mid, node.right)
return left, right
mid, right = self._split(node.right, i - node.weight)
left = self._join(node.left, mid)
return left, right
def _join(self, a: Optional[Node], b: Optional[Node]) -> Optional[Node]:
if not a:
return b
if not b:
return a
return Node.branch(a, b)
def insert(self, i: int, s: str) -> Rope:
"""Insert string at position i, returning new rope."""
left, right = self.split(i)
return left + Rope.from_string(s) + right
def delete(self, start: int, end: int) -> Rope:
"""Delete characters from start to end, returning new rope."""
left, _ = self.split(start)
_, right = self.split(end)
return left + right
def __iter__(self) -> Iterator[str]:
"""Iterate over characters."""
yield from self._iterate(self.root)
def _iterate(self, node: Optional[Node]) -> Iterator[str]:
if node is None:
return
if node.is_leaf():
yield from node.text
else:
yield from self._iterate(node.left)
yield from self._iterate(node.right)
def to_string(self) -> str:
return "".join(self)
def __repr__(self) -> str:
return f"Rope({self.to_string()!r})"{{/fold}}
Question 28 - Spell Checker
- Difficulty: 6 / 10
- Approximate lines of code: 80 LoC
- Tags: algorithms, data-structures
Description
A spell checker validates words against a dictionary and suggests corrections for misspelled words. The core algorithm uses edit distance (Levenshtein distance) to find dictionary words within 1-2 edits of the misspelled word. Suggestions are ranked by a combination of edit distance and word frequency - "the" is more likely than "thee" even if both are 1 edit away from "teh".
The naive approach computes edit distance against every dictionary word (O(n * m^2) where n=dictionary size, m=word length). Optimizations include BK-trees for faster neighbor search, or generating all possible edits and filtering by dictionary membership.
Part A: Dictionary Lookup
{{fold}}{Problem: Part A}
Implement case-insensitive dictionary lookup.
checker = SpellChecker()
checker.add_word("hello", frequency=200)
checker.add_word("world", frequency=150)
checker.add_word("help", frequency=100)
assert checker.is_correct("hello") == True
assert checker.is_correct("Hello") == True # Case insensitive
assert checker.is_correct("helo") == False
# Internal state:
# dictionary: {"hello", "world", "help"}
# word_frequency: {"hello": 200, "world": 150, "help": 100}{{/fold}}
Part B: Edit Distance and Suggestions
{{fold}}{Problem: Part B}
Find suggestions within edit distance 1-2, ranked by distance then frequency.
checker = SpellChecker()
words = [("the", 1000), ("their", 500), ("there", 400),
("they", 300), ("hello", 200), ("help", 100)]
for word, freq in words:
checker.add_word(word, freq)
suggestions = checker.get_suggestions("helo")
# Returns: ["hello", "help", ...]
# "hello" ranked first: distance=1, frequency=200
# "help" ranked second: distance=1, frequency=100
suggestions = checker.get_suggestions("thier")
# Returns: ["their", "there", "they", "the", ...]
# "their" ranked first: distance=1 (transposition)Edit distance (Levenshtein) counts minimum operations to transform one string to another:
- Insert: "helo" -> "hello" (1 edit)
- Delete: "helloo" -> "hello" (1 edit)
- Substitute: "hallo" -> "hello" (1 edit)
- Transpose: "hlelo" -> "hello" (can count as 1 or 2 depending on variant)
Standard DP solution:
def edit_distance(s1, s2):
m, n = len(s1), len(s2)
dp = [[0] * (n+1) for _ in range(m+1)]
for i in range(m+1): dp[i][0] = i
for j in range(n+1): dp[0][j] = j
for i in range(1, m+1):
for j in range(1, n+1):
if s1[i-1] == s2[j-1]:
dp[i][j] = dp[i-1][j-1]
else:
dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
return dp[m][n]{{/fold}}
Part C: Ranking with Combined Score
{{fold}}{Problem: Part C}
Rank suggestions by both edit distance and word frequency. Lower distance wins, then higher frequency breaks ties.
# Ranking tuple: (edit_distance, -frequency, word)
# Sort ascending: lower distance first, higher frequency first (via negation)
candidates = [
(1, -200, "hello"), # distance=1, freq=200
(1, -100, "help"), # distance=1, freq=100
(2, -1000, "the"), # distance=2, freq=1000
]
candidates.sort()
# Result: [hello, help, the]
# Even though "the" has highest frequency, distance=2 loses to distance=1Advanced: Weight keyboard proximity (typing "r" instead of "e" is common since they're adjacent).
{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- Empty string input?
- Word already in dictionary (return empty suggestions)?
- Very long words (edit distance computation cost)?
- What if multiple words have same distance and frequency?
Common mistakes:
- Off-by-one in DP table indexing (using
s1[i]instead ofs1[i-1]) - Not handling case sensitivity consistently
- Sorting by frequency ascending instead of descending
- Computing edit distance for entire dictionary (slow) - consider BK-tree or candidate generation
- Forgetting to handle the case where word is already correct
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses basic Levenshtein distance computed against every dictionary word - simple but O(n * m^2) per query. Solution 2 uses a BK-tree data structure for faster nearest neighbor search, allowing branch pruning based on the triangle inequality property of edit distance. Solution 3 takes a generate-and-filter approach: instead of checking every dictionary word, it generates all strings within 1-2 edits and filters by dictionary membership, also incorporating keyboard proximity for common typos. These vary in their search strategy: brute force, tree-based pruning, or candidate generation.
Core techniques: Levenshtein distance DP, BK-tree construction and search, edit operation generation (insert, delete, substitute, transpose).
Solution 1: Basic Edit Distance Approach Basic approach using standard Levenshtein distance DP. Computes edit distance against every dictionary word. Simple but O(n * m^2) per query.
"""
Spell Checker - Solution 1: Basic Edit Distance Approach
Uses Levenshtein distance with frequency-weighted suggestions.
"""
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class SpellChecker:
"""Spell checker using edit distance and word frequency."""
dictionary: set[str] = field(default_factory=set)
word_frequency: dict[str, int] = field(default_factory=dict)
max_edit_distance: int = 2
def add_word(self, word: str, frequency: int = 1) -> None:
"""Add a word to the dictionary with its frequency."""
word = word.lower()
self.dictionary.add(word)
self.word_frequency[word] = frequency
def is_correct(self, word: str) -> bool:
"""Check if a word is spelled correctly."""
return word.lower() in self.dictionary
def edit_distance(self, word1: str, word2: str) -> int:
"""Calculate Levenshtein edit distance between two words."""
m, n = len(word1), len(word2)
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(m + 1):
dp[i][0] = i
for j in range(n + 1):
dp[0][j] = j
for i in range(1, m + 1):
for j in range(1, n + 1):
if word1[i - 1] == word2[j - 1]:
dp[i][j] = dp[i - 1][j - 1]
else:
dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
return dp[m][n]
def get_suggestions(self, word: str, max_suggestions: int = 5) -> list[str]:
"""Get spelling suggestions sorted by edit distance then frequency."""
word = word.lower()
if self.is_correct(word):
return []
candidates: list[tuple[int, int, str]] = []
for dict_word in self.dictionary:
distance = self.edit_distance(word, dict_word)
if distance <= self.max_edit_distance:
freq = self.word_frequency.get(dict_word, 0)
candidates.append((distance, -freq, dict_word))
candidates.sort()
return [c[2] for c in candidates[:max_suggestions]]Solution 2: BK-Tree for Efficient Lookup BK-tree approach for faster nearest neighbor search in edit distance space. Tree structure allows pruning branches that cannot contain matches within the distance threshold.
"""
Spell Checker - Solution 2: BK-Tree for Efficient Lookup
Uses a BK-tree for faster nearest neighbor search in edit distance space.
"""
from dataclasses import dataclass, field
from typing import Optional
def levenshtein(s1: str, s2: str) -> int:
"""Calculate Levenshtein distance between two strings."""
if len(s1) < len(s2):
s1, s2 = s2, s1
if len(s2) == 0:
return len(s1)
prev_row = list(range(len(s2) + 1))
for i, c1 in enumerate(s1):
curr_row = [i + 1]
for j, c2 in enumerate(s2):
insertions = prev_row[j + 1] + 1
deletions = curr_row[j] + 1
substitutions = prev_row[j] + (c1 != c2)
curr_row.append(min(insertions, deletions, substitutions))
prev_row = curr_row
return prev_row[-1]
@dataclass
class BKNode:
"""Node in a BK-tree."""
word: str
children: dict[int, "BKNode"] = field(default_factory=dict)
@dataclass
class SpellChecker:
"""Spell checker using BK-tree for efficient fuzzy matching."""
root: Optional[BKNode] = None
dictionary: set[str] = field(default_factory=set)
word_frequency: dict[str, int] = field(default_factory=dict)
def add_word(self, word: str, frequency: int = 1) -> None:
"""Add a word to the BK-tree and dictionary."""
word = word.lower()
self.dictionary.add(word)
self.word_frequency[word] = frequency
if self.root is None:
self.root = BKNode(word)
return
node = self.root
while True:
dist = levenshtein(word, node.word)
if dist == 0:
return
if dist in node.children:
node = node.children[dist]
else:
node.children[dist] = BKNode(word)
return
def is_correct(self, word: str) -> bool:
"""Check if a word is spelled correctly."""
return word.lower() in self.dictionary
def _search_bk(self, node: BKNode, word: str, max_dist: int) -> list[tuple[str, int]]:
"""Recursively search BK-tree for words within max_dist."""
results = []
dist = levenshtein(word, node.word)
if dist <= max_dist:
results.append((node.word, dist))
for d in range(dist - max_dist, dist + max_dist + 1):
if d in node.children:
results.extend(self._search_bk(node.children[d], word, max_dist))
return results
def get_suggestions(self, word: str, max_suggestions: int = 5) -> list[str]:
"""Get spelling suggestions using BK-tree search."""
word = word.lower()
if self.is_correct(word) or self.root is None:
return []
matches = self._search_bk(self.root, word, max_dist=2)
scored = [(d, -self.word_frequency.get(w, 0), w) for w, d in matches]
scored.sort()
return [w for _, _, w in scored[:max_suggestions]]Solution 3: Generate-and-Filter with Common Typo Patterns Generate-and-filter approach. Instead of checking every dictionary word, generates all strings within 1-2 edits of the input, then filters by dictionary membership. Also includes keyboard proximity for common typos.
"""
Spell Checker - Solution 3: Generate-and-Filter with Common Typo Patterns
Generates candidate corrections by applying edit operations, then filters by dictionary.
"""
from dataclasses import dataclass, field
from typing import Iterator
KEYBOARD_NEIGHBORS: dict[str, str] = {
'a': 'qwsz', 'b': 'vghn', 'c': 'xdfv', 'd': 'erfcxs', 'e': 'rdsw',
'f': 'rtgvcd', 'g': 'tyhbvf', 'h': 'yujnbg', 'i': 'uojk', 'j': 'uikmnh',
'k': 'iolmj', 'l': 'opk', 'm': 'njk', 'n': 'bhjm', 'o': 'iplk',
'p': 'ol', 'q': 'wa', 'r': 'edft', 's': 'wedxza', 't': 'rfgy',
'u': 'yhji', 'v': 'cfgb', 'w': 'qase', 'x': 'zsdc', 'y': 'tghu', 'z': 'asx',
}
@dataclass
class SpellChecker:
"""Spell checker that generates candidates via edit operations."""
dictionary: set[str] = field(default_factory=set)
word_frequency: dict[str, int] = field(default_factory=dict)
def add_word(self, word: str, frequency: int = 1) -> None:
"""Add a word to the dictionary."""
word = word.lower()
self.dictionary.add(word)
self.word_frequency[word] = frequency
def is_correct(self, word: str) -> bool:
"""Check if a word is spelled correctly."""
return word.lower() in self.dictionary
def _edits1(self, word: str) -> Iterator[str]:
"""Generate all strings that are one edit away."""
letters = 'abcdefghijklmnopqrstuvwxyz'
splits = [(word[:i], word[i:]) for i in range(len(word) + 1)]
for left, right in splits:
if right:
yield left + right[1:] # deletion
if len(right) > 1:
yield left + right[1] + right[0] + right[2:] # transposition
for c in letters:
yield left + c + right # insertion
if right:
yield left + c + right[1:] # substitution
def _keyboard_edits(self, word: str) -> Iterator[str]:
"""Generate edits based on keyboard proximity (common typos)."""
for i, char in enumerate(word):
if char in KEYBOARD_NEIGHBORS:
for neighbor in KEYBOARD_NEIGHBORS[char]:
yield word[:i] + neighbor + word[i + 1:]
def _edits2(self, word: str) -> Iterator[str]:
"""Generate all strings that are two edits away."""
seen = set()
for e1 in self._edits1(word):
for e2 in self._edits1(e1):
if e2 not in seen:
seen.add(e2)
yield e2
def get_suggestions(self, word: str, max_suggestions: int = 5) -> list[str]:
"""Get spelling suggestions by generating and filtering candidates."""
word = word.lower()
if self.is_correct(word):
return []
candidates: list[tuple[int, int, str]] = []
# Priority 1: keyboard typos (distance 0.5 conceptually)
for candidate in self._keyboard_edits(word):
if candidate in self.dictionary:
freq = self.word_frequency.get(candidate, 0)
candidates.append((0, -freq, candidate))
# Priority 2: edit distance 1
for candidate in self._edits1(word):
if candidate in self.dictionary:
freq = self.word_frequency.get(candidate, 0)
candidates.append((1, -freq, candidate))
# Priority 3: edit distance 2 (only if needed)
if len(candidates) < max_suggestions:
for candidate in self._edits2(word):
if candidate in self.dictionary:
freq = self.word_frequency.get(candidate, 0)
candidates.append((2, -freq, candidate))
seen = set()
result = []
for _, _, w in sorted(candidates):
if w not in seen:
seen.add(w)
result.append(w)
if len(result) >= max_suggestions:
break
return result{{/fold}}
Question 29 - B-Tree
- Difficulty: 10 / 10
- Approximate lines of code: 90 LoC
- Tags: data-structures, storage
Description
A B-tree is a self-balancing search tree optimized for systems that read and write large blocks of data, like databases and filesystems. Unlike binary trees where each node has 2 children, B-tree nodes have many keys and children (determined by the "order" or "minimum degree"). This reduces tree height, minimizing disk I/O operations.
Each node contains sorted keys and associated values. For a B-tree of order t (minimum degree): each non-root node has between t-1 and 2t-1 keys, and between t and 2t children. A node with k keys has k+1 children. All leaves are at the same depth. The tree grows upward (from the root) rather than downward.
Part A: Structure and Search
{{fold}}{Problem: Part A}
Create a B-tree node that holds multiple keys, values, and child pointers. Implement search(key) that traverses from root to leaf.
# B-tree with order=3 (max 2 keys per node, max 3 children)
# Internal state example:
#
# [10, 20]
# / | \
# [5, 7] [12, 15] [25, 30]
#
# Each node: keys=[...], values=[...], children=[...]
tree = BTree(order=3)
# After inserting keys 5,7,10,12,15,20,25,30:
tree.search(12) # Returns "val_12"
# Path: root[10,20] -> key 12 > 10 and < 20 -> middle child [12,15] -> found at index 0
tree.search(8) # Returns None
# Path: root[10,20] -> key 8 < 10 -> left child [5,7] -> not found, is leaf -> NoneSearch algorithm:
- At current node, find first key >= search_key (binary or linear search)
- If found exact match, return the value
- If leaf node, return None (not found)
- Otherwise, recurse into the appropriate child
{{/fold}}
Part B: Insertion with Splitting
{{fold}}{Problem: Part B}
Implement insert(key, value). The challenge: when a node is full, you must split it before inserting. Use proactive splitting - split full nodes on the way down, not after insertion.
# Starting state (order=3, max 2 keys per node):
# [10]
# / \
# [5] [20, 30] <- This node is full!
tree.insert(25, "val_25")
# Step 1: Root not full, descend
# Step 2: Right child [20,30] is full, split it BEFORE descending:
# - Middle key (20 or 30 depending on implementation) promoted to parent
# - Node splits into two smaller nodes
# After split:
# [10, 25]
# / | \
# [5] [20] [30]
# Step 3: Insert 25 - wait, 25 was the split key promoted, so we're done
# (or insert into appropriate child if different split point)Split mechanics for node with keys [a, b, c] (order=3, mid=1):
- Left node keeps:
[a] - Right node gets:
[c] - Middle key
bpromoted to parent - Children arrays split similarly (left gets first half, right gets second half)
{{/fold}}
Part C: Root Growth
{{fold}}{Problem: Part C}
When the root itself is full and needs to split, the tree grows taller. This is the ONLY way a B-tree increases height.
# Before (root is full, order=3):
# [10, 20] <- Full root!
tree.insert(15, "val_15")
# Step 1: Root is full - create NEW root with old root as only child
# [empty new root]
# |
# [10, 20]
# Step 2: Split the child (old root)
# [10] <- new root now has promoted key
# / \
# [] [20] <- split creates two children
# Step 3: Insert 15 into appropriate child
# [10]
# / \
# [] [15, 20]{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when inserting into an empty tree? (Create root with one key)
- When exactly do you split - before or after inserting? (Before - proactive splitting)
- How many children does a node with k keys have? (k+1)
- What's the minimum/maximum keys in a node? (t-1 to 2t-1 for non-root, root can have 1 to 2t-1)
Common mistakes:
- Off-by-one errors in split: children array has one more element than keys array
- Forgetting to insert the new child reference in parent after split
- Splitting at wrong index (need to handle even vs odd number of keys)
- Not creating new root when current root is full (just splitting in place)
- Confusing order vs minimum degree terminology (order = max children = 2t)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 is a basic recursive implementation using "order" terminology with linear search within nodes. Solution 2 uses minimum degree t (CLRS style) with binary search for key lookup and an explicit leaf flag. Solution 3 adds generic typing and update-on-duplicate semantics, making the B-tree behave like an ordered map. The key differences are in terminology conventions (order vs degree), search strategy (linear vs binary), and duplicate handling (error vs update). Core techniques: binary search, recursive tree traversal, proactive node splitting.
Solution 1: Recursive with order terminology Basic recursive implementation using "order" terminology (order = max children). Uses linear search within nodes and recursive insert. Clean separation of split logic into a helper method.
"""B-Tree implementation with configurable order (branching factor)."""
from dataclasses import dataclass, field
from typing import Optional, Any
@dataclass
class BTreeNode:
"""A node in the B-tree."""
keys: list[Any] = field(default_factory=list)
values: list[Any] = field(default_factory=list)
children: list["BTreeNode"] = field(default_factory=list)
@property
def is_leaf(self) -> bool:
return len(self.children) == 0
@dataclass
class BTree:
"""B-Tree with configurable order (max children per node)."""
order: int # Maximum number of children per node
root: BTreeNode = field(default_factory=BTreeNode)
@property
def max_keys(self) -> int:
return self.order - 1
def search(self, key: Any) -> Optional[Any]:
"""Search for a key and return its value, or None if not found."""
return self._search_node(self.root, key)
def _search_node(self, node: BTreeNode, key: Any) -> Optional[Any]:
i = 0
while i < len(node.keys) and key > node.keys[i]:
i += 1
if i < len(node.keys) and key == node.keys[i]:
return node.values[i]
if node.is_leaf:
return None
return self._search_node(node.children[i], key)
def insert(self, key: Any, value: Any) -> None:
"""Insert a key-value pair into the B-tree."""
root = self.root
if len(root.keys) == self.max_keys:
new_root = BTreeNode(children=[root])
self._split_child(new_root, 0)
self.root = new_root
self._insert_non_full(self.root, key, value)
def _insert_non_full(self, node: BTreeNode, key: Any, value: Any) -> None:
i = len(node.keys) - 1
if node.is_leaf:
# Find position and insert
while i >= 0 and key < node.keys[i]:
i -= 1
node.keys.insert(i + 1, key)
node.values.insert(i + 1, value)
else:
while i >= 0 and key < node.keys[i]:
i -= 1
i += 1
if len(node.children[i].keys) == self.max_keys:
self._split_child(node, i)
if key > node.keys[i]:
i += 1
self._insert_non_full(node.children[i], key, value)
def _split_child(self, parent: BTreeNode, index: int) -> None:
"""Split a full child node at the given index."""
full_node = parent.children[index]
mid = self.max_keys // 2
new_node = BTreeNode(
keys=full_node.keys[mid + 1:],
values=full_node.values[mid + 1:],
children=full_node.children[mid + 1:] if not full_node.is_leaf else []
)
parent.keys.insert(index, full_node.keys[mid])
parent.values.insert(index, full_node.values[mid])
parent.children.insert(index + 1, new_node)
full_node.keys = full_node.keys[:mid]
full_node.values = full_node.values[:mid]
if not full_node.is_leaf:
full_node.children = full_node.children[:mid + 1]Solution 2: CLRS style with binary search Uses minimum degree t terminology (standard in CLRS). Includes iterative search with binary search for key lookup within nodes. Explicit leaf boolean flag instead of checking children length.
"""B-Tree with iterative search and explicit min/max degree handling."""
from dataclasses import dataclass, field
from typing import Optional, Any, Tuple
@dataclass
class Node:
"""B-tree node with keys, values, and optional children."""
keys: list[Any] = field(default_factory=list)
values: list[Any] = field(default_factory=list)
children: list["Node"] = field(default_factory=list)
leaf: bool = True
@dataclass
class BTree:
"""B-Tree using minimum degree t (nodes have t-1 to 2t-1 keys)."""
t: int # Minimum degree
def __post_init__(self) -> None:
self.root = Node()
@property
def max_keys(self) -> int:
return 2 * self.t - 1
def search(self, key: Any) -> Optional[Any]:
"""Iterative search for key."""
node = self.root
while node:
i = self._find_key_index(node, key)
if i < len(node.keys) and node.keys[i] == key:
return node.values[i]
if node.leaf:
return None
node = node.children[i]
return None
def _find_key_index(self, node: Node, key: Any) -> int:
"""Binary search for key position in node."""
lo, hi = 0, len(node.keys)
while lo < hi:
mid = (lo + hi) // 2
if node.keys[mid] < key:
lo = mid + 1
else:
hi = mid
return lo
def insert(self, key: Any, value: Any) -> None:
"""Insert key-value, splitting root if necessary."""
if len(self.root.keys) == self.max_keys:
old_root = self.root
self.root = Node(children=[old_root], leaf=False)
self._split_child(self.root, 0)
self._insert_non_full(self.root, key, value)
def _split_child(self, parent: Node, idx: int) -> None:
"""Split parent.children[idx] which must be full."""
t = self.t
full = parent.children[idx]
new = Node(leaf=full.leaf)
# Move upper half to new node
new.keys = full.keys[t:]
new.values = full.values[t:]
if not full.leaf:
new.children = full.children[t:]
# Promote middle key to parent
parent.keys.insert(idx, full.keys[t - 1])
parent.values.insert(idx, full.values[t - 1])
parent.children.insert(idx + 1, new)
# Trim the original node
full.keys = full.keys[:t - 1]
full.values = full.values[:t - 1]
if not full.leaf:
full.children = full.children[:t]
def _insert_non_full(self, node: Node, key: Any, value: Any) -> None:
"""Insert into a node that has room."""
i = self._find_key_index(node, key)
if node.leaf:
node.keys.insert(i, key)
node.values.insert(i, value)
else:
if len(node.children[i].keys) == self.max_keys:
self._split_child(node, i)
if key > node.keys[i]:
i += 1
self._insert_non_full(node.children[i], key, value)Solution 3: Generic typed with update semantics Generic typed implementation with update-on-duplicate semantics (like a map). Checks if key exists before inserting, and updates the value if found. Shows how B-trees can serve as ordered maps.
"""B-Tree with generic typing and update-on-duplicate semantics."""
from dataclasses import dataclass, field
from typing import Generic, TypeVar, Optional
K = TypeVar("K")
V = TypeVar("V")
@dataclass
class BNode(Generic[K, V]):
"""Generic B-tree node."""
keys: list[K] = field(default_factory=list)
values: list[V] = field(default_factory=list)
children: list["BNode[K, V]"] = field(default_factory=list)
@property
def is_leaf(self) -> bool:
return len(self.children) == 0
@dataclass
class BTree(Generic[K, V]):
"""Generic B-Tree with update semantics for duplicate keys."""
order: int
root: BNode[K, V] = field(default_factory=BNode)
def get(self, key: K) -> Optional[V]:
"""Get value for key, or None."""
node, idx = self._find(self.root, key)
return node.values[idx] if node else None
def _find(self, node: BNode[K, V], key: K) -> tuple[Optional[BNode[K, V]], int]:
"""Find node and index containing key."""
i = 0
while i < len(node.keys) and key > node.keys[i]:
i += 1
if i < len(node.keys) and node.keys[i] == key:
return node, i
if node.is_leaf:
return None, -1
return self._find(node.children[i], key)
def put(self, key: K, value: V) -> None:
"""Insert or update key-value pair."""
# Check for existing key first
node, idx = self._find(self.root, key)
if node:
node.values[idx] = value
return
# Insert new key
if len(self.root.keys) == self.order - 1:
old = self.root
self.root = BNode(children=[old])
self._split(self.root, 0)
self._insert(self.root, key, value)
def _insert(self, node: BNode[K, V], key: K, value: V) -> None:
i = len(node.keys) - 1
if node.is_leaf:
while i >= 0 and key < node.keys[i]:
i -= 1
node.keys.insert(i + 1, key)
node.values.insert(i + 1, value)
else:
while i >= 0 and key < node.keys[i]:
i -= 1
i += 1
if len(node.children[i].keys) == self.order - 1:
self._split(node, i)
if key > node.keys[i]:
i += 1
self._insert(node.children[i], key, value)
def _split(self, parent: BNode[K, V], idx: int) -> None:
mid = (self.order - 1) // 2
child = parent.children[idx]
sibling = BNode[K, V](
keys=child.keys[mid + 1:],
values=child.values[mid + 1:],
children=child.children[mid + 1:] if not child.is_leaf else []
)
parent.keys.insert(idx, child.keys[mid])
parent.values.insert(idx, child.values[mid])
parent.children.insert(idx + 1, sibling)
child.keys = child.keys[:mid]
child.values = child.values[:mid]
if not child.is_leaf:
child.children = child.children[:mid + 1]{{/fold}}
Question 30 - Transaction Log
- Difficulty: 4 / 10
- Approximate lines of code: 110 LoC
- Tags: storage
Description
A transaction log provides atomicity for a key-value store: operations either fully complete or fully roll back, with no partial states visible. The key mechanism is storing the old value before each modification, enabling rollback by replaying these saved values in reverse order. This is the foundation of ACID transactions in databases.
Internal state includes: the actual data store (a dict), a write-ahead log (WAL) of operations with their old values, and savepoint markers. When you begin(), you start recording. When you commit(), you discard the log (changes are permanent). When you rollback(), you replay the log backwards to restore the original state.
Part A: Begin, Commit, Rollback
{{fold}}{Problem: Part A}
Implement basic transaction semantics with begin(), set(key, value), delete(key), commit(), and rollback().
tm = TransactionManager()
# Basic transaction flow
tm.begin()
tm.set("user", "alice")
tm.set("count", 1)
# Internal WAL: [SET user (old=None), SET count (old=None)]
# Store: {"user": "alice", "count": 1}
tm.commit()
# WAL cleared, changes are permanent
# Store: {"user": "alice", "count": 1}
# Rollback example
tm.begin()
tm.set("user", "bob")
# WAL: [SET user (old="alice")]
# Store: {"user": "bob", "count": 1}
tm.rollback()
# Replay WAL backwards: restore user to "alice"
# Store: {"user": "alice", "count": 1}{{/fold}}
Part B: Savepoints
{{fold}}{Problem: Part B}
Add nested rollback points within a transaction. savepoint() returns a marker you can roll back to without aborting the entire transaction.
tm.begin()
tm.set("x", 10)
sp1 = tm.savepoint() # savepoint 1
# WAL: [SET x (old=None, sp=0)]
tm.set("x", 20)
sp2 = tm.savepoint() # savepoint 2
# WAL: [SET x (old=None, sp=0), SET x (old=10, sp=1)]
tm.set("x", 30)
tm.set("y", 100)
# WAL: [..., SET x (old=20, sp=2), SET y (old=None, sp=2)]
tm.rollback_to(sp2)
# Undo all ops with savepoint >= 2
# x restored to 20, y removed
assert tm.get("x") == 20
assert tm.get("y") is None
tm.rollback_to(sp1)
assert tm.get("x") == 10
tm.commit(){{/fold}}
Part C: Durability via Write-Ahead Log
{{fold}}{Problem: Part C}
Make transactions survive crashes by writing the log to disk before applying changes. On startup, replay any uncommitted transactions from the log.
# Write to disk before modifying memory
tm.begin()
tm.set("key", "value")
# 1. Write to WAL file: {"op": "SET", "key": "key", "value": "value"}
# 2. fsync() the file
# 3. Apply to in-memory store
tm.commit()
# 1. Write COMMIT record to WAL
# 2. fsync()
# 3. Delete WAL file (or truncate)
# Crash recovery on startup:
# 1. Read WAL file
# 2. If COMMIT record exists: replay all ops
# 3. If no COMMIT: discard (transaction was incomplete){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if you call
set()outside a transaction? - What happens if you roll back to an invalid savepoint?
- How do you handle delete of a non-existent key?
- What if the process crashes between writing to WAL and applying to store?
Common mistakes:
- Shallow copy of values when storing old state (mutable values get corrupted)
- Not storing the old value for delete operations (can't restore on rollback)
- Replaying WAL in forward order instead of reverse during rollback
- Not using fsync for durability (just flush is not enough)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 is a simple in-memory implementation using a log entry list that stores operation type, key, old/new values, and savepoint number. Solution 2 adds persistence with a write-ahead log (WAL) that writes JSON entries to disk with fsync for crash recovery. Solution 3 uses the command pattern where each operation (SetCommand, DeleteCommand) knows how to execute and undo itself. The key difference is durability vs simplicity: Solution 1 is memory-only, Solution 2 survives crashes, and Solution 3 provides clean separation of concerns. Core techniques: write-ahead logging, reverse-order rollback, savepoint markers, command pattern with undo stack, fsync for durability.
Solution 1: Simple In-Memory Implementation Simple in-memory implementation with a log entry list. Each entry stores the operation type, key, old value, new value, and savepoint number. Rollback pops entries from the end and restores old values. Clean and correct but not persistent.
"""
Transaction Log - Solution 1: Simple In-Memory Implementation
Basic ACID transactions with write-ahead logging and savepoints.
"""
from dataclasses import dataclass, field
from enum import Enum
from typing import Any
class OpType(Enum):
SET = "SET"
DELETE = "DELETE"
@dataclass
class LogEntry:
op: OpType
key: str
old_value: Any
new_value: Any
savepoint: int = 0
@dataclass
class TransactionManager:
store: dict[str, Any] = field(default_factory=dict)
wal: list[LogEntry] = field(default_factory=list)
in_transaction: bool = False
savepoint_counter: int = 0
def begin(self) -> None:
if self.in_transaction:
raise RuntimeError("Transaction already active")
self.in_transaction = True
self.wal.clear()
self.savepoint_counter = 0
def set(self, key: str, value: Any) -> None:
self._require_transaction()
old = self.store.get(key)
self.wal.append(LogEntry(OpType.SET, key, old, value, self.savepoint_counter))
self.store[key] = value
def delete(self, key: str) -> None:
self._require_transaction()
if key not in self.store:
raise KeyError(f"Key not found: {key}")
old = self.store[key]
self.wal.append(LogEntry(OpType.DELETE, key, old, None, self.savepoint_counter))
del self.store[key]
def get(self, key: str) -> Any:
return self.store.get(key)
def savepoint(self) -> int:
self._require_transaction()
self.savepoint_counter += 1
return self.savepoint_counter
def rollback_to(self, sp: int) -> None:
self._require_transaction()
while self.wal and self.wal[-1].savepoint >= sp:
entry = self.wal.pop()
if entry.op == OpType.SET:
if entry.old_value is None:
self.store.pop(entry.key, None)
else:
self.store[entry.key] = entry.old_value
elif entry.op == OpType.DELETE:
self.store[entry.key] = entry.old_value
self.savepoint_counter = sp - 1
def rollback(self) -> None:
self._require_transaction()
self.rollback_to(0)
self.in_transaction = False
def commit(self) -> None:
self._require_transaction()
self.wal.clear()
self.in_transaction = False
def _require_transaction(self) -> None:
if not self.in_transaction:
raise RuntimeError("No active transaction")Solution 2: Persistent WAL with Recovery Persistent WAL with crash recovery. Writes JSON log entries to disk with fsync for durability. On startup, replays the log to recover state. Savepoints use a stack of state snapshots for simpler rollback logic.
"""
Transaction Log - Solution 2: Persistent WAL with Recovery
Writes log entries to disk for crash recovery.
"""
from dataclasses import dataclass
from enum import Enum
from pathlib import Path
from typing import Any
import json
import os
class Op(Enum):
BEGIN = "BEGIN"
SET = "SET"
DELETE = "DELETE"
COMMIT = "COMMIT"
SAVEPOINT = "SAVEPOINT"
ROLLBACK_TO = "ROLLBACK_TO"
@dataclass
class PersistentTxManager:
wal_path: Path
store: dict[str, Any]
savepoint_stack: list[dict[str, Any]]
active: bool = False
def __init__(self, wal_path: str = "wal.log"):
self.wal_path = Path(wal_path)
self.store = {}
self.savepoint_stack = []
self.active = False
self._recover()
def _write_log(self, op: Op, key: str = "", value: Any = None) -> None:
entry = {"op": op.value, "key": key, "value": value}
with open(self.wal_path, "a") as f:
f.write(json.dumps(entry) + "\n")
f.flush()
os.fsync(f.fileno())
def _recover(self) -> None:
if not self.wal_path.exists():
return
with open(self.wal_path) as f:
entries = [json.loads(line) for line in f if line.strip()]
temp_store: dict[str, Any] = {}
committed = False
for e in entries:
op = Op(e["op"])
if op == Op.BEGIN:
temp_store = dict(self.store)
committed = False
elif op == Op.SET:
temp_store[e["key"]] = e["value"]
elif op == Op.DELETE:
temp_store.pop(e["key"], None)
elif op == Op.COMMIT:
self.store = dict(temp_store)
committed = True
if committed:
self.wal_path.unlink(missing_ok=True)
def begin(self) -> None:
if self.active:
raise RuntimeError("Transaction already active")
self._write_log(Op.BEGIN)
self.active = True
self.savepoint_stack = [dict(self.store)]
def set(self, key: str, value: Any) -> None:
if not self.active:
raise RuntimeError("No active transaction")
self._write_log(Op.SET, key, value)
self.store[key] = value
def delete(self, key: str) -> None:
if not self.active:
raise RuntimeError("No active transaction")
self._write_log(Op.DELETE, key)
self.store.pop(key, None)
def get(self, key: str) -> Any:
return self.store.get(key)
def savepoint(self) -> int:
if not self.active:
raise RuntimeError("No active transaction")
self.savepoint_stack.append(dict(self.store))
self._write_log(Op.SAVEPOINT)
return len(self.savepoint_stack) - 1
def rollback_to(self, sp: int) -> None:
if not self.active or sp >= len(self.savepoint_stack):
raise RuntimeError("Invalid savepoint")
self._write_log(Op.ROLLBACK_TO, value=sp)
self.store = dict(self.savepoint_stack[sp])
self.savepoint_stack = self.savepoint_stack[:sp + 1]
def rollback(self) -> None:
if not self.active:
raise RuntimeError("No active transaction")
self.store = dict(self.savepoint_stack[0])
self.savepoint_stack.clear()
self.active = False
self.wal_path.unlink(missing_ok=True)
def commit(self) -> None:
if not self.active:
raise RuntimeError("No active transaction")
self._write_log(Op.COMMIT)
self.savepoint_stack.clear()
self.active = False
self.wal_path.unlink(missing_ok=True)Solution 3: Command Pattern with Undo Stack Command pattern with explicit undo stack. Each operation (SetCommand, DeleteCommand) knows how to execute and undo itself. Transactions manage a list of commands and savepoints as indices into that list. Clean separation of concerns.
"""
Transaction Log - Solution 3: Command Pattern with Undo Stack
Uses command objects for clean separation of concerns.
"""
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from typing import Any, Protocol
class Store(Protocol):
def get(self, key: str) -> Any: ...
def put(self, key: str, value: Any) -> None: ...
def remove(self, key: str) -> Any: ...
class Command(ABC):
@abstractmethod
def execute(self, store: Store) -> None: ...
@abstractmethod
def undo(self, store: Store) -> None: ...
@dataclass
class SetCommand(Command):
key: str
new_value: Any
old_value: Any = None
def execute(self, store: Store) -> None:
self.old_value = store.get(self.key)
store.put(self.key, self.new_value)
def undo(self, store: Store) -> None:
if self.old_value is None:
store.remove(self.key)
else:
store.put(self.key, self.old_value)
@dataclass
class DeleteCommand(Command):
key: str
old_value: Any = None
def execute(self, store: Store) -> None:
self.old_value = store.remove(self.key)
def undo(self, store: Store) -> None:
if self.old_value is not None:
store.put(self.key, self.old_value)
@dataclass
class DictStore:
data: dict[str, Any] = field(default_factory=dict)
def get(self, key: str) -> Any:
return self.data.get(key)
def put(self, key: str, value: Any) -> None:
self.data[key] = value
def remove(self, key: str) -> Any:
return self.data.pop(key, None)
@dataclass
class Transaction:
store: DictStore
commands: list[Command] = field(default_factory=list)
savepoints: list[int] = field(default_factory=list)
committed: bool = False
def set(self, key: str, value: Any) -> None:
cmd = SetCommand(key, value)
cmd.execute(self.store)
self.commands.append(cmd)
def delete(self, key: str) -> None:
cmd = DeleteCommand(key)
cmd.execute(self.store)
self.commands.append(cmd)
def savepoint(self) -> int:
self.savepoints.append(len(self.commands))
return len(self.savepoints)
def rollback_to(self, sp: int) -> None:
if sp < 1 or sp > len(self.savepoints):
raise ValueError(f"Invalid savepoint: {sp}")
target_idx = self.savepoints[sp - 1]
while len(self.commands) > target_idx:
self.commands.pop().undo(self.store)
self.savepoints = self.savepoints[:sp - 1]
def rollback(self) -> None:
while self.commands:
self.commands.pop().undo(self.store)
self.savepoints.clear()
def commit(self) -> None:
self.commands.clear()
self.savepoints.clear()
self.committed = True
@dataclass
class TransactionManager:
store: DictStore = field(default_factory=DictStore)
current_tx: Transaction | None = None
def begin(self) -> Transaction:
if self.current_tx:
raise RuntimeError("Nested transactions not supported at top level")
self.current_tx = Transaction(self.store)
return self.current_tx
def commit(self) -> None:
if not self.current_tx:
raise RuntimeError("No active transaction")
self.current_tx.commit()
self.current_tx = None
def rollback(self) -> None:
if not self.current_tx:
raise RuntimeError("No active transaction")
self.current_tx.rollback()
self.current_tx = None
def get(self, key: str) -> Any:
return self.store.get(key){{/fold}}
Question 31 - Indexed Priority Queue
- Difficulty: 9 / 10
- Approximate lines of code: 90 LoC
- Tags: data-structures
Description
An indexed priority queue (IPQ) combines a priority queue with O(1) key lookup, enabling efficient priority updates. This is essential for graph algorithms like Dijkstra's shortest path, where you need to decrease the priority of a vertex when you discover a shorter path. A standard heap gives O(log n) insert and extract-min, but updating a priority requires O(n) to find the element first.
The key insight is maintaining a hash map from keys to their positions in the heap array. Every time you swap elements during bubble-up or bubble-down, you must also update both keys' positions in the hash map. This gives O(1) lookup of any key's heap position, enabling O(log n) priority updates.
Part A: Basic Operations
{{fold}}{Problem: Part A}
Implement insert(key, priority), extract_min(), and peek_min(). The key is a unique identifier (like a vertex ID). Store entries as (key, priority) pairs in a heap array, with a hash map tracking key -> array index. Duplicate keys should raise an error.
pq = IndexedPriorityQueue()
pq.insert("A", 10)
pq.insert("B", 5)
pq.insert("C", 15)
# Internal state:
# _heap = [Entry("B", 5), Entry("A", 10), Entry("C", 15)]
# _key_to_index = {"B": 0, "A": 1, "C": 2}
pq.peek_min() # ("B", 5)
pq.extract_min() # ("B", 5)
# After extract_min:
# _heap = [Entry("A", 10), Entry("C", 15)] # C moved to root, bubbled down
# _key_to_index = {"A": 0, "C": 1}
pq.insert("B", 5) # OK, B was removed
pq.insert("A", 20) # KeyError: "A" already exists{{/fold}}
Part B: Update and Remove
{{fold}}{Problem: Part B}
Add update_priority(key, new_priority) and remove(key). After updating a priority, the element might need to bubble up (if priority decreased) OR bubble down (if priority increased). The hash map enables O(1) lookup of the element's current position.
pq = IndexedPriorityQueue()
pq.insert("A", 10)
pq.insert("B", 5)
pq.insert("C", 15)
# _heap = [Entry("B", 5), Entry("A", 10), Entry("C", 15)]
# _key_to_index = {"B": 0, "A": 1, "C": 2}
pq.update_priority("C", 3) # C now has lowest priority
# After update:
# 1. Find C at index 2
# 2. Change priority: _heap[2].priority = 3
# 3. Since 3 < 15, bubble UP
# 4. Compare with parent at (2-1)//2 = 0, swap with B
# _heap = [Entry("C", 3), Entry("A", 10), Entry("B", 5)]
# Wait, that's wrong - need to continue bubbling B down
# Correct state after bubbling:
# _heap = [Entry("C", 3), Entry("A", 10), Entry("B", 5)]
# No wait: after C bubbles to root, B is at index 2
# _key_to_index = {"C": 0, "A": 1, "B": 2}
pq.remove("A") # Remove from middle
# Swap A with last element, pop, then bubble the swapped element{{/fold}}
Part C: Edge Cases
{{fold}}{Problem: Part C}
Handle operations on empty queue, non-existent keys, and implement decrease_key(key, new_priority) that only updates if the new priority is strictly lower (commonly needed for Dijkstra's).
pq = IndexedPriorityQueue()
pq.extract_min() # IndexError: "Priority queue is empty"
pq.peek_min() # IndexError: "Priority queue is empty"
pq.update_priority("X", 5) # KeyError: "X" not found
pq.remove("X") # KeyError: "X" not found
pq.insert("A", 10)
pq.decrease_key("A", 15) # ValueError: new priority 15 is not less than 10
pq.decrease_key("A", 5) # OK, updates to 5
"A" in pq # True (implement __contains__)
len(pq) # 1 (implement __len__){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens when you update a priority and need to bubble down instead of up?
- How do you handle removing an element from the middle of the heap?
- What's the parent/child index formula? (parent:
(i-1)//2, children:2*i+1,2*i+2) - What if someone tries to insert a duplicate key?
Common mistakes:
- Forgetting to update the hash map on EVERY swap during bubble up/down
- Only bubbling one direction after update (might need up OR down)
- Off-by-one in parent/child calculations: parent is
(i-1)//2noti//2 - Not handling remove from middle correctly (must swap with last, pop, then bubble)
- Using
>instead of>=in bubble comparisons (affects stability)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses a binary heap with a hash map for O(1) key lookup, maintaining the index map on every swap for O(log n) priority updates. Solution 2 uses Python's heapq with lazy deletion, marking old entries as invalid instead of physically removing them. Solution 3 is a simple O(n) dictionary-based approach with linear scans for min/max. They differ in complexity vs. simplicity: optimal heap operations vs. simpler lazy deletion vs. trivial but slower linear scan.
Core techniques: binary heap, hash map indexing, bubble-up/bubble-down, lazy deletion.
Solution 1: Binary heap with hash map Binary heap with hash map for O(1) key lookup. Maintains the index map on every swap. Explicit bubble-up and bubble-down methods.
"""
Indexed Priority Queue - Solution 1: Binary Heap with Hash Map
Uses a min-heap with a dictionary for O(1) key lookups and O(log n) updates.
"""
from dataclasses import dataclass
from typing import Generic, TypeVar, Optional
K = TypeVar('K')
V = TypeVar('V')
@dataclass
class HeapEntry(Generic[K, V]):
key: K
priority: V
class IndexedPriorityQueue(Generic[K, V]):
def __init__(self) -> None:
self._heap: list[HeapEntry[K, V]] = []
self._key_to_index: dict[K, int] = {}
def __len__(self) -> int:
return len(self._heap)
def __contains__(self, key: K) -> bool:
return key in self._key_to_index
def insert(self, key: K, priority: V) -> None:
if key in self._key_to_index:
raise KeyError(f"Key {key} already exists")
index = len(self._heap)
self._heap.append(HeapEntry(key, priority))
self._key_to_index[key] = index
self._bubble_up(index)
def extract_min(self) -> tuple[K, V]:
if not self._heap:
raise IndexError("Priority queue is empty")
min_entry = self._heap[0]
self._remove_at(0)
return min_entry.key, min_entry.priority
def peek_min(self) -> tuple[K, V]:
if not self._heap:
raise IndexError("Priority queue is empty")
return self._heap[0].key, self._heap[0].priority
def update_priority(self, key: K, new_priority: V) -> None:
if key not in self._key_to_index:
raise KeyError(f"Key {key} not found")
index = self._key_to_index[key]
old_priority = self._heap[index].priority
self._heap[index].priority = new_priority
if new_priority < old_priority:
self._bubble_up(index)
else:
self._bubble_down(index)
def _bubble_up(self, index: int) -> None:
while index > 0:
parent = (index - 1) // 2
if self._heap[index].priority >= self._heap[parent].priority:
break
self._swap(index, parent)
index = parent
def _bubble_down(self, index: int) -> None:
size = len(self._heap)
while True:
smallest = index
left, right = 2 * index + 1, 2 * index + 2
if left < size and self._heap[left].priority < self._heap[smallest].priority:
smallest = left
if right < size and self._heap[right].priority < self._heap[smallest].priority:
smallest = right
if smallest == index:
break
self._swap(index, smallest)
index = smallest
def _swap(self, i: int, j: int) -> None:
self._key_to_index[self._heap[i].key] = j
self._key_to_index[self._heap[j].key] = i
self._heap[i], self._heap[j] = self._heap[j], self._heap[i]
def _remove_at(self, index: int) -> None:
del self._key_to_index[self._heap[index].key]
if index == len(self._heap) - 1:
self._heap.pop()
else:
last = self._heap.pop()
self._heap[index] = last
self._key_to_index[last.key] = index
self._bubble_up(index)
self._bubble_down(index)Solution 2: Using heapq with lazy deletion Lazy deletion approach using Python's heapq. Updates mark old entries as invalid and push new ones. Invalid entries are skipped during extraction. Simpler but uses more memory.
"""
Indexed Priority Queue - Solution 2: Using heapq with Lazy Deletion
Simpler implementation using Python's heapq. Deleted/updated entries are
marked invalid and skipped during extraction.
"""
from dataclasses import dataclass, field
from typing import Generic, TypeVar, Optional
import heapq
K = TypeVar('K')
V = TypeVar('V')
REMOVED = object()
@dataclass(order=True)
class Entry(Generic[K, V]):
priority: V
key: K = field(compare=False)
valid: bool = field(default=True, compare=False)
class IndexedPriorityQueue(Generic[K, V]):
def __init__(self) -> None:
self._heap: list[Entry[K, V]] = []
self._entries: dict[K, Entry[K, V]] = {}
def __len__(self) -> int:
return len(self._entries)
def __contains__(self, key: K) -> bool:
return key in self._entries
def insert(self, key: K, priority: V) -> None:
if key in self._entries:
raise KeyError(f"Key {key} already exists")
entry = Entry(priority=priority, key=key)
self._entries[key] = entry
heapq.heappush(self._heap, entry)
def extract_min(self) -> tuple[K, V]:
while self._heap:
entry = heapq.heappop(self._heap)
if entry.valid:
del self._entries[entry.key]
return entry.key, entry.priority
raise IndexError("Priority queue is empty")
def peek_min(self) -> tuple[K, V]:
while self._heap and not self._heap[0].valid:
heapq.heappop(self._heap)
if not self._heap:
raise IndexError("Priority queue is empty")
entry = self._heap[0]
return entry.key, entry.priority
def update_priority(self, key: K, new_priority: V) -> None:
if key not in self._entries:
raise KeyError(f"Key {key} not found")
old_entry = self._entries[key]
old_entry.valid = False
new_entry = Entry(priority=new_priority, key=key)
self._entries[key] = new_entry
heapq.heappush(self._heap, new_entry)
def remove(self, key: K) -> V:
if key not in self._entries:
raise KeyError(f"Key {key} not found")
entry = self._entries.pop(key)
entry.valid = False
return entry.priority
def get_priority(self, key: K) -> V:
if key not in self._entries:
raise KeyError(f"Key {key} not found")
return self._entries[key].prioritySolution 3: Dict-based with linear scan Simple O(n) implementation using a dictionary. Linear scan for min. Useful as a baseline or when n is small. Easy to understand and extend.
"""
Indexed Priority Queue - Solution 3: Dict-based with Linear Scan
Simple O(n) implementation - useful as a baseline or when n is small.
Easy to understand and debug, minimal code.
"""
from dataclasses import dataclass
from typing import Generic, TypeVar, Optional
K = TypeVar('K')
V = TypeVar('V')
@dataclass
class IndexedPriorityQueue(Generic[K, V]):
_data: dict[K, V] = None
def __post_init__(self) -> None:
if self._data is None:
self._data = {}
def __len__(self) -> int:
return len(self._data)
def __contains__(self, key: K) -> bool:
return key in self._data
def insert(self, key: K, priority: V) -> None:
if key in self._data:
raise KeyError(f"Key {key} already exists")
self._data[key] = priority
def extract_min(self) -> tuple[K, V]:
if not self._data:
raise IndexError("Priority queue is empty")
min_key = min(self._data, key=lambda k: self._data[k])
priority = self._data.pop(min_key)
return min_key, priority
def extract_max(self) -> tuple[K, V]:
if not self._data:
raise IndexError("Priority queue is empty")
max_key = max(self._data, key=lambda k: self._data[k])
priority = self._data.pop(max_key)
return max_key, priority
def peek_min(self) -> tuple[K, V]:
if not self._data:
raise IndexError("Priority queue is empty")
min_key = min(self._data, key=lambda k: self._data[k])
return min_key, self._data[min_key]
def peek_max(self) -> tuple[K, V]:
if not self._data:
raise IndexError("Priority queue is empty")
max_key = max(self._data, key=lambda k: self._data[k])
return max_key, self._data[max_key]
def update_priority(self, key: K, new_priority: V) -> None:
if key not in self._data:
raise KeyError(f"Key {key} not found")
self._data[key] = new_priority
def decrease_key(self, key: K, new_priority: V) -> None:
if key not in self._data:
raise KeyError(f"Key {key} not found")
if new_priority > self._data[key]:
raise ValueError("New priority must be less than current")
self._data[key] = new_priority
def increase_key(self, key: K, new_priority: V) -> None:
if key not in self._data:
raise KeyError(f"Key {key} not found")
if new_priority < self._data[key]:
raise ValueError("New priority must be greater than current")
self._data[key] = new_priority
def remove(self, key: K) -> V:
if key not in self._data:
raise KeyError(f"Key {key} not found")
return self._data.pop(key)
def get_priority(self, key: K) -> V:
if key not in self._data:
raise KeyError(f"Key {key} not found")
return self._data[key]{{/fold}}
Question 32 - Game of Life
- Difficulty: 2 / 10
- Approximate lines of code: 100 LoC
- Tags: game/simulation
Description
Conway's Game of Life is a cellular automaton on a 2D grid where each cell is either alive or dead. Cells evolve simultaneously according to four rules based on neighbor count (the 8 adjacent cells):
- Underpopulation: A live cell with < 2 neighbors dies
- Survival: A live cell with 2-3 neighbors survives
- Overpopulation: A live cell with > 3 neighbors dies
- Reproduction: A dead cell with exactly 3 neighbors becomes alive
The critical implementation detail is that all cells update simultaneously - you cannot modify the grid in-place while iterating. You need either a second buffer or a way to encode both old and new states.
Part A: Basic Simulation
{{fold}}{Problem: Part A}
Implement a fixed-size grid with set_alive(cells) to initialize and step() to advance one generation. All cells must update simultaneously based on the previous state.
game = GameOfLife(rows=5, cols=5)
# Initialize a "blinker" - oscillates between horizontal and vertical
game.set_alive({(2, 1), (2, 2), (2, 3)})
# Internal state:
# .....
# .....
# .###. <- Three horizontal cells
# .....
# .....
game.step()
# After one step:
# .....
# ..#..
# ..#.. <- Three vertical cells
# ..#..
# .....
game.step()
# Returns to original horizontal pattern
assert game.get_live_cells() == {(2, 1), (2, 2), (2, 3)}{{/fold}}
Part B: Boundary Handling
{{fold}}{Problem: Part B}
Handle grid edges. Two common approaches:
- Toroidal (wrap-around): Cells on opposite edges are neighbors
- Dead boundary: Cells outside the grid are always dead
# Wrap-around example on 3x3 grid
game = GameOfLife(rows=3, cols=3, wrap=True)
game.set_alive({(0, 0), (0, 1), (0, 2)}) # Top row
# With wrap-around, top row neighbors include bottom row
game.step()
assert (2, 1) in game.get_live_cells() # Cell born at bottom
# Dead boundary example
game2 = GameOfLife(rows=3, cols=3, wrap=False)
game2.set_alive({(0, 0), (0, 1), (0, 2)})
game2.step()
# (2, 1) not born because top row has no neighbors wrapping{{/fold}}
Part C: Known Patterns and Infinite Grid
{{fold}}{Problem: Part C}
Implement support for known patterns and discuss infinite grid representation using sparse sets.
# Still life - "Block" (stable, doesn't change)
block = {(1, 1), (1, 2), (2, 1), (2, 2)}
game.set_alive(block)
game.step()
assert game.get_live_cells() == block
# Glider - moves diagonally over time
glider = {(0, 1), (1, 2), (2, 0), (2, 1), (2, 2)}
game.set_alive(glider)
for _ in range(4):
game.step()
# After 4 generations, glider has moved (1, 1) diagonally
expected = {(r + 1, c + 1) for r, c in glider}
assert game.get_live_cells() == expected
# Infinite grid: Use set of (row, col) tuples instead of 2D array
# Only store live cells, check neighbors on demand{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens to a single isolated cell? (Dies from underpopulation)
- What if you forget to use a buffer? (Earlier updates affect later cells incorrectly)
- How do you count neighbors efficiently? (8 directions, handle bounds)
- What's the complexity of step() for a dense grid vs. sparse grid?
Common mistakes:
- In-place updates instead of using a buffer (the #1 bug)
- Including the center cell in the neighbor count
- Off-by-one errors in wrap-around modulo arithmetic
- Checking only live cells for reproduction (must also check dead neighbors of live cells)
- Not handling empty grid (should remain empty)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses a fixed-size 2D list with wrap-around (toroidal) topology and creates a new grid each step to avoid in-place mutation. Solution 2 uses a sparse set representation for infinite grids, storing only live cells and using Counter for neighbor counting. Solution 3 uses NumPy arrays with vectorized operations and np.roll for neighbor counting, supporting both wrap-around and dead boundary modes. The key differences are grid representation (dense array vs sparse set) and boundary handling (toroidal vs infinite vs configurable). Core techniques: double buffering, modular arithmetic for wrap-around, sparse set with neighbor counting, vectorized array operations.
Solution 1: Fixed Grid with Wrap-around Fixed grid using 2D list with wrap-around (toroidal topology). Uses modular arithmetic for neighbor access. Creates new grid each step to avoid in-place mutation.
"""
Conway's Game of Life - Solution 1: Fixed Grid with Wrap-around
Uses a 2D list with modular arithmetic for toroidal topology.
"""
from dataclasses import dataclass, field
from typing import List, Set, Tuple
@dataclass
class GameOfLife:
"""Fixed-size grid with wrap-around edges (toroidal topology)."""
rows: int
cols: int
grid: List[List[bool]] = field(default_factory=list)
def __post_init__(self) -> None:
if not self.grid:
self.grid = [[False] * self.cols for _ in range(self.rows)]
def set_alive(self, cells: Set[Tuple[int, int]]) -> None:
"""Initialize live cells."""
for r, c in cells:
self.grid[r % self.rows][c % self.cols] = True
def count_neighbors(self, row: int, col: int) -> int:
"""Count live neighbors with wrap-around."""
count = 0
for dr in (-1, 0, 1):
for dc in (-1, 0, 1):
if dr == 0 and dc == 0:
continue
nr = (row + dr) % self.rows
nc = (col + dc) % self.cols
if self.grid[nr][nc]:
count += 1
return count
def step(self) -> None:
"""Advance simulation by one generation."""
new_grid = [[False] * self.cols for _ in range(self.rows)]
for r in range(self.rows):
for c in range(self.cols):
neighbors = self.count_neighbors(r, c)
alive = self.grid[r][c]
# Rules: survive with 2-3 neighbors, born with exactly 3
if alive and neighbors in (2, 3):
new_grid[r][c] = True
elif not alive and neighbors == 3:
new_grid[r][c] = True
self.grid = new_grid
def get_live_cells(self) -> Set[Tuple[int, int]]:
"""Return set of live cell coordinates."""
return {(r, c) for r in range(self.rows) for c in range(self.cols) if self.grid[r][c]}
def display(self) -> str:
"""Return string representation of grid."""
return "\n".join("".join("#" if cell else "." for cell in row) for row in self.grid)
if __name__ == "__main__":
# Test 1: Blinker oscillator (period 2)
game = GameOfLife(5, 5)
game.set_alive({(2, 1), (2, 2), (2, 3)}) # Horizontal line
initial = game.get_live_cells()
game.step()
after_one = game.get_live_cells()
game.step()
after_two = game.get_live_cells()
assert after_one == {(1, 2), (2, 2), (3, 2)}, f"Blinker step 1 failed: {after_one}"
assert after_two == initial, f"Blinker should return to initial: {after_two}"
print("Blinker test passed!")
# Test 2: Block still life (stable)
game2 = GameOfLife(4, 4)
block = {(1, 1), (1, 2), (2, 1), (2, 2)}
game2.set_alive(block)
game2.step()
assert game2.get_live_cells() == block, "Block should be stable"
print("Block test passed!")
# Test 3: Wrap-around
game3 = GameOfLife(3, 3)
game3.set_alive({(0, 0), (0, 1), (0, 2)}) # Top row
game3.step()
assert (2, 1) in game3.get_live_cells(), "Wrap-around should create cell at bottom"
print("Wrap-around test passed!")
print("All tests passed!")Solution 2: Infinite Grid with Sparse Representation Infinite grid using sparse set representation. Only stores live cells. Uses Counter to efficiently track neighbor counts. Memory-efficient for sparse patterns like gliders.
"""
Conway's Game of Life - Solution 2: Infinite Grid with Sparse Representation
Uses a set of live cell coordinates - efficient for sparse patterns.
"""
from dataclasses import dataclass, field
from typing import Set, Tuple, Dict
from collections import Counter
@dataclass
class InfiniteGameOfLife:
"""Infinite grid using sparse set representation."""
live_cells: Set[Tuple[int, int]] = field(default_factory=set)
def set_alive(self, cells: Set[Tuple[int, int]]) -> None:
"""Initialize live cells."""
self.live_cells = set(cells)
def _get_neighbors(self, row: int, col: int) -> Set[Tuple[int, int]]:
"""Return all 8 neighbors of a cell."""
return {
(row + dr, col + dc)
for dr in (-1, 0, 1)
for dc in (-1, 0, 1)
if not (dr == 0 and dc == 0)
}
def step(self) -> None:
"""Advance simulation by one generation using neighbor counting."""
# Count how many live neighbors each cell has
neighbor_counts: Dict[Tuple[int, int], int] = Counter()
for cell in self.live_cells:
for neighbor in self._get_neighbors(*cell):
neighbor_counts[neighbor] += 1
new_live: Set[Tuple[int, int]] = set()
# Check all cells that could potentially be alive
candidates = self.live_cells | set(neighbor_counts.keys())
for cell in candidates:
count = neighbor_counts.get(cell, 0)
alive = cell in self.live_cells
if alive and count in (2, 3):
new_live.add(cell)
elif not alive and count == 3:
new_live.add(cell)
self.live_cells = new_live
def get_live_cells(self) -> Set[Tuple[int, int]]:
"""Return set of live cell coordinates."""
return set(self.live_cells)
def get_bounds(self) -> Tuple[int, int, int, int]:
"""Return (min_row, max_row, min_col, max_col) or (0,0,0,0) if empty."""
if not self.live_cells:
return (0, 0, 0, 0)
rows = [r for r, c in self.live_cells]
cols = [c for r, c in self.live_cells]
return (min(rows), max(rows), min(cols), max(cols))
def display(self, padding: int = 1) -> str:
"""Return string representation of bounding box with padding."""
if not self.live_cells:
return "."
min_r, max_r, min_c, max_c = self.get_bounds()
lines = []
for r in range(min_r - padding, max_r + padding + 1):
row = ""
for c in range(min_c - padding, max_c + padding + 1):
row += "#" if (r, c) in self.live_cells else "."
lines.append(row)
return "\n".join(lines)
if __name__ == "__main__":
# Test 1: Glider moves diagonally
game = InfiniteGameOfLife()
glider = {(0, 1), (1, 2), (2, 0), (2, 1), (2, 2)}
game.set_alive(glider)
for _ in range(4):
game.step()
# After 4 steps, glider moves down-right by (1, 1)
expected = {(r + 1, c + 1) for r, c in glider}
assert game.get_live_cells() == expected, f"Glider failed: {game.get_live_cells()}"
print("Glider test passed!")
# Test 2: Blinker
game2 = InfiniteGameOfLife()
game2.set_alive({(0, -1), (0, 0), (0, 1)})
game2.step()
assert game2.get_live_cells() == {(-1, 0), (0, 0), (1, 0)}, "Blinker step 1 failed"
game2.step()
assert game2.get_live_cells() == {(0, -1), (0, 0), (0, 1)}, "Blinker step 2 failed"
print("Blinker test passed!")
# Test 3: Empty grid stays empty
game3 = InfiniteGameOfLife()
game3.step()
assert game3.get_live_cells() == set(), "Empty grid should stay empty"
print("Empty grid test passed!")
# Test 4: Single cell dies
game4 = InfiniteGameOfLife()
game4.set_alive({(0, 0)})
game4.step()
assert game4.get_live_cells() == set(), "Single cell should die"
print("Single cell test passed!")
print("All tests passed!")Solution 3: NumPy-based for Performance NumPy-based implementation for performance on large grids. Uses np.roll for neighbor counting and vectorized boolean operations. Supports both wrap-around and dead boundary modes.
"""
Conway's Game of Life - Solution 3: NumPy-based for Performance
Uses 2D numpy array with manual neighbor counting via array slicing.
"""
from dataclasses import dataclass
from typing import Set, Tuple
import numpy as np
@dataclass
class NumpyGameOfLife:
"""Fixed-size grid using numpy for efficient computation."""
rows: int
cols: int
wrap: bool = True
def __post_init__(self) -> None:
self.grid: np.ndarray = np.zeros((self.rows, self.cols), dtype=np.int8)
def set_alive(self, cells: Set[Tuple[int, int]]) -> None:
"""Initialize live cells."""
self.grid.fill(0)
for r, c in cells:
self.grid[r % self.rows, c % self.cols] = 1
def _count_neighbors(self) -> np.ndarray:
"""Count neighbors for all cells using array rolling."""
counts = np.zeros_like(self.grid, dtype=np.int8)
for dr in (-1, 0, 1):
for dc in (-1, 0, 1):
if dr == 0 and dc == 0:
continue
shifted = np.roll(np.roll(self.grid, dr, axis=0), dc, axis=1)
if not self.wrap:
# Zero out wrapped edges for non-wrapping mode
if dr == -1:
shifted[-1, :] = 0
elif dr == 1:
shifted[0, :] = 0
if dc == -1:
shifted[:, -1] = 0
elif dc == 1:
shifted[:, 0] = 0
counts += shifted
return counts
def step(self) -> None:
"""Advance simulation using vectorized operations."""
neighbor_count = self._count_neighbors()
# Apply rules vectorized:
# Survive: alive and 2-3 neighbors
# Born: dead and exactly 3 neighbors
survive = (self.grid == 1) & ((neighbor_count == 2) | (neighbor_count == 3))
born = (self.grid == 0) & (neighbor_count == 3)
self.grid = (survive | born).astype(np.int8)
def get_live_cells(self) -> Set[Tuple[int, int]]:
"""Return set of live cell coordinates."""
rows, cols = np.where(self.grid == 1)
return set(zip(rows.tolist(), cols.tolist()))
def count_alive(self) -> int:
"""Return total number of live cells."""
return int(np.sum(self.grid))
def display(self) -> str:
"""Return string representation of grid."""
chars = np.where(self.grid == 1, "#", ".")
return "\n".join("".join(row) for row in chars)
if __name__ == "__main__":
# Test 1: Blinker oscillator
game = NumpyGameOfLife(5, 5)
game.set_alive({(2, 1), (2, 2), (2, 3)})
initial = game.get_live_cells()
game.step()
after_one = game.get_live_cells()
game.step()
after_two = game.get_live_cells()
assert after_one == {(1, 2), (2, 2), (3, 2)}, f"Blinker step 1 failed: {after_one}"
assert after_two == initial, f"Blinker should oscillate: {after_two}"
print("Blinker test passed!")
# Test 2: Block still life
game2 = NumpyGameOfLife(4, 4)
block = {(1, 1), (1, 2), (2, 1), (2, 2)}
game2.set_alive(block)
game2.step()
assert game2.get_live_cells() == block, "Block should be stable"
print("Block test passed!")
# Test 3: Glider (4 generations)
game3 = NumpyGameOfLife(10, 10)
glider = {(1, 2), (2, 3), (3, 1), (3, 2), (3, 3)}
game3.set_alive(glider)
for _ in range(4):
game3.step()
expected = {(r + 1, c + 1) for r, c in glider}
assert game3.get_live_cells() == expected, f"Glider failed: {game3.get_live_cells()}"
print("Glider test passed!")
# Test 4: Performance - large grid
big_game = NumpyGameOfLife(100, 100)
import random
random.seed(42)
cells = {(random.randint(0, 99), random.randint(0, 99)) for _ in range(1000)}
big_game.set_alive(cells)
for _ in range(10):
big_game.step()
print(f"Large grid test passed! Final population: {big_game.count_alive()}")
print("All tests passed!"){{/fold}}
Question 33 - Barrier Sync
- Difficulty: 7 / 10
- Approximate lines of code: 90 LoC
- Tags: concurrency
Description
{{fold}}{Concurrency Cheat Sheet}
This problem involves concurrency. Here is a cheat sheet of relevant Python syntax. You may not need all of these; this list is not exhaustive or suggestive for the problem.
# threading.Thread
t = threading.Thread(target=fn, args=(arg1,))
t.start()
t.join() # wait for completion
# threading.Lock
lock = threading.Lock()
lock.acquire()
lock.release()
with lock: # auto acquire/release
pass
# threading.Condition
cond = threading.Condition(lock) # or Condition() for internal lock
with cond:
cond.wait() # release lock, block until notify, re-acquire
cond.wait(timeout) # returns False on timeout
cond.notify() # wake one waiter
cond.notify_all() # wake all waiters
# threading.Semaphore
sem = threading.Semaphore(n) # n permits
sem.acquire() # block if count=0
sem.release() # increment count
sem.acquire(timeout=1.0) # returns False on timeout
# threading.Event
event = threading.Event()
event.set() # set flag, wake all waiters
event.clear() # reset flag
event.wait() # block until flag is set
event.wait(timeout) # returns False on timeout
event.is_set() # check flag
# threading.Barrier (built-in reference)
barrier = threading.Barrier(n)
barrier.wait() # block until n threads arrive
barrier.wait(timeout) # raises BrokenBarrierError on timeout
barrier.reset() # reset to initial state
barrier.abort() # break barrier{{/fold}}
A barrier is a synchronization primitive that blocks a group of threads until all of them have reached a certain point. Once all N threads call wait(), they are all released simultaneously. This is commonly used in parallel algorithms where each phase must complete before the next begins (e.g., parallel matrix operations, simulation steps).
The key implementation challenge is making the barrier reusable - after all threads pass through, the barrier should reset for the next round. A naive implementation fails when a fast thread re-enters the barrier before a slow thread has exited, causing the count to be wrong. The solution is "generation counting" - each barrier cycle has a generation number, and threads check their generation before proceeding.
Part A: Basic Barrier
{{fold}}{Problem: Part A}
Implement a barrier where wait() blocks until all N parties have arrived.
barrier = Barrier(parties=3)
# Thread 1, 2, 3 all call wait()
def worker(thread_id):
print(f"Thread {thread_id} before barrier")
barrier.wait() # Blocks until all 3 arrive
print(f"Thread {thread_id} after barrier")
# Output (before lines all complete, then after lines):
# Thread 0 before barrier
# Thread 1 before barrier
# Thread 2 before barrier
# Thread 0 after barrier # These three can be in any order
# Thread 1 after barrier
# Thread 2 after barrierInternal state progression:
Initial: count=0, generation=0
Thread 0 arrives: count=1, waiting...
Thread 1 arrives: count=2, waiting...
Thread 2 arrives: count=3 == parties
-> Reset count=0, generation=1
-> notify_all()
-> All threads wake and proceed{{/fold}}
Part B: Reusability
{{fold}}{Problem: Part B}
Make the barrier reusable for multiple rounds. Handle the "fast thread" race condition using generation counting.
barrier = Barrier(parties=2)
def worker():
for round in range(3):
# Do work...
barrier.wait() # Must work correctly for all 3 rounds
# Without generation counting, this breaks:
# Round 1: Thread A arrives, Thread B arrives, both released
# Round 2: Thread A (fast) re-enters while Thread B still exiting
# count becomes 1, Thread A waits, Thread B exits
# Thread B re-enters, count=2, releases both
# But Thread A was waiting in round 2 with round 1's state!{{/fold}}
Part C: Timeout and Callback
{{fold}}{Problem: Part C}
Add timeout support (returns False on timeout without corrupting barrier state) and a callback that executes exactly once when all threads arrive.
# Timeout
barrier = Barrier(parties=2)
result = barrier.wait(timeout=1.0) # Returns False after 1 second
# Barrier is now "broken" - subsequent waits raise BrokenBarrierError
# Callback (runs once, by the last arriving thread)
def on_all_arrived():
print("All threads synchronized!")
barrier = Barrier(parties=3, callback=on_all_arrived)
# When third thread arrives, callback runs before any thread proceeds{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if a thread dies while waiting? (Barrier hangs or breaks)
- Why is generation counting necessary? (Fast thread reentry race)
- What if callback raises an exception?
- Can you implement without condition variables (e.g., with semaphores)?
Common mistakes:
- Forgetting generation counting (causes reuse bugs)
- Timeout corrupting the count (must handle cleanly)
- Holding the lock while waiting (blocks other threads from arriving)
- Using
notify()instead ofnotify_all()(only one thread wakes)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 uses threading.Condition with generation counting - waiting threads check their generation to know when to proceed. Solution 2 uses a two-phase turnstile pattern with semaphores, ensuring clean separation between arrival and departure phases. Solution 3 uses threading.Event where each generation gets its own Event object that gets set and replaced. The key difference is the synchronization primitive used. Core techniques: generation counting, condition variables, semaphores, event signaling.
Solution 1: Condition variable approach Uses threading.Condition with generation counting. Last thread to arrive resets count, increments generation, and calls notify_all(). Waiting threads check their generation to know if they should proceed.
"""
Barrier Sync Solution 1: Condition Variable Approach
A reusable thread barrier using threading.Condition for synchronization.
Supports timeout, callback, and graceful handling of thread failures.
"""
import threading
from dataclasses import dataclass, field
from typing import Callable, Optional
@dataclass
class Barrier:
"""A reusable thread barrier with timeout and callback support."""
parties: int
callback: Optional[Callable[[], None]] = None
_lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
_condition: threading.Condition = field(init=False, repr=False)
_count: int = field(default=0, init=False)
_generation: int = field(default=0, init=False)
_broken: bool = field(default=False, init=False)
def __post_init__(self) -> None:
if self.parties <= 0:
raise ValueError("parties must be positive")
self._condition = threading.Condition(self._lock)
def wait(self, timeout: Optional[float] = None) -> bool:
"""
Wait for all parties to reach the barrier.
Returns True if barrier was successfully crossed, False on timeout.
Raises BrokenBarrierError if barrier is broken.
"""
with self._condition:
if self._broken:
raise BrokenBarrierError("Barrier is broken")
gen = self._generation
self._count += 1
if self._count == self.parties:
# Last thread to arrive: run callback and release everyone
if self.callback:
self.callback()
self._count = 0
self._generation += 1
self._condition.notify_all()
return True
# Wait for other threads
while gen == self._generation and not self._broken:
if not self._condition.wait(timeout):
# Timeout occurred - break the barrier
self._broken = True
self._condition.notify_all()
return False
if self._broken:
raise BrokenBarrierError("Barrier is broken")
return True
def reset(self) -> None:
"""Reset the barrier to initial state."""
with self._condition:
self._count = 0
self._generation += 1
self._broken = False
self._condition.notify_all()
def abort(self) -> None:
"""Break the barrier, causing all waiting threads to raise."""
with self._condition:
self._broken = True
self._condition.notify_all()
class BrokenBarrierError(Exception):
"""Raised when a barrier is broken."""
passSolution 2: Semaphore-based approach Two-phase turnstile pattern using semaphores. Phase 1: all threads arrive and wait on turnstile1. Phase 2: all threads depart through turnstile2. Ensures clean separation between rounds.
"""
Barrier Sync Solution 2: Semaphore-Based Approach
A reusable thread barrier using two semaphores (turnstile pattern).
Supports timeout, callback, and graceful handling of thread failures.
"""
import threading
from dataclasses import dataclass, field
from typing import Callable, Optional
@dataclass
class Barrier:
"""A reusable barrier using the two-phase turnstile pattern."""
parties: int
callback: Optional[Callable[[], None]] = None
_mutex: threading.Lock = field(default_factory=threading.Lock, repr=False)
_turnstile1: threading.Semaphore = field(init=False, repr=False)
_turnstile2: threading.Semaphore = field(init=False, repr=False)
_count: int = field(default=0, init=False)
_broken: bool = field(default=False, init=False)
def __post_init__(self) -> None:
if self.parties <= 0:
raise ValueError("parties must be positive")
self._turnstile1 = threading.Semaphore(0)
self._turnstile2 = threading.Semaphore(0)
def wait(self, timeout: Optional[float] = None) -> bool:
"""Wait for all parties. Returns False on timeout."""
# Phase 1: Wait for all threads to arrive
with self._mutex:
if self._broken:
raise BrokenBarrierError("Barrier is broken")
self._count += 1
if self._count == self.parties:
if self.callback:
self.callback()
for _ in range(self.parties):
self._turnstile1.release()
if not self._turnstile1.acquire(timeout=timeout):
self._break_barrier()
return False
# Phase 2: Wait for all threads to pass turnstile1
with self._mutex:
if self._broken:
raise BrokenBarrierError("Barrier is broken")
self._count -= 1
if self._count == 0:
for _ in range(self.parties):
self._turnstile2.release()
if not self._turnstile2.acquire(timeout=timeout):
self._break_barrier()
return False
if self._broken:
raise BrokenBarrierError("Barrier is broken")
return True
def _break_barrier(self) -> None:
"""Mark barrier as broken and release waiting threads."""
with self._mutex:
self._broken = True
# Release all potentially waiting threads
for _ in range(self.parties):
self._turnstile1.release()
self._turnstile2.release()
def reset(self) -> None:
"""Reset barrier to initial state."""
with self._mutex:
self._count = 0
self._broken = False
self._turnstile1 = threading.Semaphore(0)
self._turnstile2 = threading.Semaphore(0)
def abort(self) -> None:
"""Break the barrier."""
self._break_barrier()
class BrokenBarrierError(Exception):
"""Raised when a barrier is broken."""
passSolution 3: Event-based approach Event-based approach. Each generation gets its own Event object. Last thread sets the event and creates a new one for the next round. Clean and minimal.
"""
Barrier Sync Solution 3: Event-Based Approach
A reusable thread barrier using threading.Event for signaling.
Uses generation counting for reusability. Clean, minimal implementation.
"""
import threading
from dataclasses import dataclass, field
from typing import Callable, Optional
@dataclass
class Barrier:
"""A reusable barrier using Event signaling with generation tracking."""
parties: int
callback: Optional[Callable[[], None]] = None
_lock: threading.Lock = field(default_factory=threading.Lock, repr=False)
_event: threading.Event = field(default_factory=threading.Event, repr=False)
_count: int = field(default=0, init=False)
_generation: int = field(default=0, init=False)
_broken: bool = field(default=False, init=False)
def __post_init__(self) -> None:
if self.parties <= 0:
raise ValueError("parties must be positive")
def wait(self, timeout: Optional[float] = None) -> bool:
"""
Block until all parties arrive. Returns True on success, False on timeout.
Raises BrokenBarrierError if barrier breaks.
"""
with self._lock:
if self._broken:
raise BrokenBarrierError("Barrier is broken")
my_gen = self._generation
self._count += 1
if self._count == self.parties:
# We're the last one - run callback, reset and signal everyone
if self.callback:
self.callback()
self._count = 0
self._generation += 1
self._event.set()
self._event = threading.Event() # New event for next round
return True
# Store current event before releasing lock
current_event = self._event
# Wait outside the lock
signaled = current_event.wait(timeout)
if not signaled:
# Timeout - break the barrier
with self._lock:
if self._generation == my_gen: # Still our generation
self._broken = True
self._event.set() # Wake everyone
return False
with self._lock:
if self._broken and self._generation == my_gen:
raise BrokenBarrierError("Barrier is broken")
return True
def reset(self) -> None:
"""Reset barrier to clean state."""
with self._lock:
self._count = 0
self._generation += 1
self._broken = False
self._event.set()
self._event = threading.Event()
def abort(self) -> None:
"""Break the barrier, waking all waiters."""
with self._lock:
self._broken = True
self._event.set()
@property
def n_waiting(self) -> int:
"""Number of threads currently waiting."""
with self._lock:
return self._count
class BrokenBarrierError(Exception):
"""Raised when a barrier is broken by timeout or abort."""
pass{{/fold}}
Question 34 - Minesweeper
- Difficulty: 3 / 10
- Approximate lines of code: 80 LoC
- Tags: game/simulation
Description
Minesweeper is a classic puzzle game where a grid contains hidden mines. Each non-mine cell displays the count of adjacent mines (0-8). The player reveals cells; revealing a mine loses the game, revealing all non-mine cells wins. The key data structure is a 2D grid of cells, each with state (hidden/revealed/flagged), whether it's a mine, and its adjacent mine count.
The main algorithmic challenge is the cascade reveal: when revealing a cell with 0 adjacent mines, automatically reveal all neighbors recursively. This is a flood-fill algorithm (BFS or DFS) that stops when it hits cells with non-zero counts.
Part A: Board Setup with Adjacent Counts
{{fold}}{Problem: Part A}
Create a board with randomly placed mines and pre-compute adjacent mine counts for all cells. Each cell needs to know how many of its 8 neighbors contain mines.
game = Minesweeper(rows=5, cols=5, num_mines=3)
# Internal state after creation:
# - 3 cells have is_mine=True (random positions)
# - Each non-mine cell has adjacent_mines computed
# - All cells start with state=HIDDEN
# For example, if mines are at (0,0), (2,2), (4,4):
# Adjacent counts would be:
# * 1 0 0 0
# 1 2 1 1 0
# 0 1 * 1 0
# 0 1 1 2 1
# 0 0 0 1 *{{/fold}}
Part B: Reveal with Cascade
{{fold}}{Problem: Part B}
Implement reveal(row, col) that:
- Returns False if a mine is hit
- Reveals the cell
- If adjacent_mines == 0, recursively reveals all 8 neighbors
- Cascade stops at cells with non-zero counts (they're revealed but don't cascade further)
game = Minesweeper(rows=5, cols=5, num_mines=3)
# Assume mine at (2,2) only, so many cells have count 0
result = game.reveal(0, 0) # True (not a mine)
# If (0,0) has count 0, cascade reveals neighbors
# Cascade continues until hitting cells with count > 0
# Internal state: cells with count 0 in connected region all revealed
# Cells bordering the mine (1,1), (1,2), (1,3), etc. revealed and show counts
result = game.reveal(2, 2) # False (hit mine, game over){{/fold}}
Part C: Flags and Win Condition
{{fold}}{Problem: Part C}
Add flag toggling (mark suspected mines) and win detection (all non-mine cells revealed).
game = Minesweeper(rows=3, cols=3, num_mines=1)
# Mine at (1,1)
game.toggle_flag(1, 1) # Flag the suspected mine
# Internal: cell (1,1) state = FLAGGED
game.toggle_flag(1, 1) # Unflag
# Internal: cell (1,1) state = HIDDEN
# Reveal all non-mine cells
for r in range(3):
for c in range(3):
if (r, c) != (1, 1):
game.reveal(r, c)
game.check_win() # True (all 8 non-mine cells revealed){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- Revealing an already-revealed cell?
- Flagging a revealed cell?
- What if num_mines >= rows * cols?
- Revealing a flagged cell (should it unflag first or be blocked)?
Common mistakes:
- Cascade through numbered cells (should stop at them, just reveal)
- Modifying board during iteration (use BFS queue or recursion stack)
- Not handling first-click-is-mine (common game variant)
- Including the cell itself in neighbor count
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses an object-oriented approach with a Cell dataclass containing state, is_mine, and adjacent_mines, using recursion for cascade reveal. Solution 2 takes a functional approach with separate 2D arrays for state and counts, keeping the data structures lightweight with string literals. Solution 3 uses sets and itertools for a compact implementation, with BFS (deque) for iterative flood-fill instead of recursion. The key difference is the data representation: nested objects vs parallel arrays vs set-based tracking. Core techniques: flood-fill (DFS/BFS), 2D grid traversal, neighbor enumeration.
Solution 1: Object-Oriented with Cell dataclass An object-oriented approach with a Cell dataclass containing state, is_mine, and adjacent_mines. Uses recursion for cascade reveal.
"""Minesweeper - Solution 1: Object-Oriented with Cell dataclass."""
from dataclasses import dataclass, field
from enum import Enum
from random import sample
from typing import Iterator
class CellState(Enum):
HIDDEN = "hidden"
REVEALED = "revealed"
FLAGGED = "flagged"
@dataclass
class Cell:
is_mine: bool = False
state: CellState = CellState.HIDDEN
adjacent_mines: int = 0
@dataclass
class Minesweeper:
rows: int
cols: int
num_mines: int
board: list[list[Cell]] = field(default_factory=list)
def __post_init__(self) -> None:
self.board = [[Cell() for _ in range(self.cols)] for _ in range(self.rows)]
self._place_mines()
self._calculate_adjacent()
def _place_mines(self) -> None:
positions = sample(range(self.rows * self.cols), self.num_mines)
for pos in positions:
r, c = divmod(pos, self.cols)
self.board[r][c].is_mine = True
def _neighbors(self, r: int, c: int) -> Iterator[tuple[int, int]]:
for dr in (-1, 0, 1):
for dc in (-1, 0, 1):
if dr == 0 and dc == 0:
continue
nr, nc = r + dr, c + dc
if 0 <= nr < self.rows and 0 <= nc < self.cols:
yield nr, nc
def _calculate_adjacent(self) -> None:
for r in range(self.rows):
for c in range(self.cols):
if not self.board[r][c].is_mine:
self.board[r][c].adjacent_mines = sum(
1 for nr, nc in self._neighbors(r, c) if self.board[nr][nc].is_mine
)
def reveal(self, r: int, c: int) -> bool:
"""Reveal cell. Returns False if mine hit, True otherwise."""
cell = self.board[r][c]
if cell.state != CellState.HIDDEN:
return True
cell.state = CellState.REVEALED
if cell.is_mine:
return False
if cell.adjacent_mines == 0:
for nr, nc in self._neighbors(r, c):
self.reveal(nr, nc)
return True
def toggle_flag(self, r: int, c: int) -> None:
cell = self.board[r][c]
if cell.state == CellState.HIDDEN:
cell.state = CellState.FLAGGED
elif cell.state == CellState.FLAGGED:
cell.state = CellState.HIDDEN
def check_win(self) -> bool:
for row in self.board:
for cell in row:
if not cell.is_mine and cell.state != CellState.REVEALED:
return False
return TrueSolution 2: Functional approach with 2D arrays A functional approach using 2D arrays for state and counts, with separate functions for game logic. Uses string literals for state to keep it lightweight.
"""Minesweeper - Solution 2: Functional approach with 2D arrays."""
from dataclasses import dataclass
from random import sample
from typing import Literal
State = Literal["H", "R", "F"] # Hidden, Revealed, Flagged
@dataclass
class Board:
rows: int
cols: int
mines: set[tuple[int, int]]
states: list[list[State]]
counts: list[list[int]]
@classmethod
def create(cls, rows: int, cols: int, num_mines: int) -> "Board":
positions = sample([(r, c) for r in range(rows) for c in range(cols)], num_mines)
mines = set(positions)
states: list[list[State]] = [["H"] * cols for _ in range(rows)]
counts = [[0] * cols for _ in range(rows)]
for r in range(rows):
for c in range(cols):
if (r, c) not in mines:
counts[r][c] = sum(
1 for nr, nc in neighbors(r, c, rows, cols) if (nr, nc) in mines
)
return cls(rows, cols, mines, states, counts)
def neighbors(r: int, c: int, rows: int, cols: int) -> list[tuple[int, int]]:
result = []
for dr in (-1, 0, 1):
for dc in (-1, 0, 1):
if dr == 0 and dc == 0:
continue
nr, nc = r + dr, c + dc
if 0 <= nr < rows and 0 <= nc < cols:
result.append((nr, nc))
return result
def reveal(board: Board, r: int, c: int) -> bool:
"""Returns False if mine hit."""
if board.states[r][c] != "H":
return True
board.states[r][c] = "R"
if (r, c) in board.mines:
return False
if board.counts[r][c] == 0:
for nr, nc in neighbors(r, c, board.rows, board.cols):
reveal(board, nr, nc)
return True
def toggle_flag(board: Board, r: int, c: int) -> None:
if board.states[r][c] == "H":
board.states[r][c] = "F"
elif board.states[r][c] == "F":
board.states[r][c] = "H"
def check_win(board: Board) -> bool:
for r in range(board.rows):
for c in range(board.cols):
if (r, c) not in board.mines and board.states[r][c] != "R":
return False
return True
def check_loss(board: Board) -> bool:
return any(board.states[r][c] == "R" for r, c in board.mines)Solution 3: Using itertools and more compact logic Uses itertools and sets for a more compact implementation. Cascade reveal uses BFS with a deque for iterative flood-fill instead of recursion.
"""Minesweeper - Solution 3: Using itertools and more compact logic."""
from dataclasses import dataclass, field
from itertools import product
from random import sample
from collections import deque
@dataclass
class Minesweeper:
rows: int
cols: int
mines: frozenset[tuple[int, int]] = field(default_factory=frozenset)
revealed: set[tuple[int, int]] = field(default_factory=set)
flagged: set[tuple[int, int]] = field(default_factory=set)
counts: dict[tuple[int, int], int] = field(default_factory=dict)
@classmethod
def new_game(cls, rows: int, cols: int, num_mines: int) -> "Minesweeper":
all_cells = list(product(range(rows), range(cols)))
mines = frozenset(sample(all_cells, num_mines))
game = cls(rows=rows, cols=cols, mines=mines)
game._compute_counts()
return game
def _neighbors(self, r: int, c: int) -> list[tuple[int, int]]:
return [
(r + dr, c + dc)
for dr, dc in product((-1, 0, 1), repeat=2)
if (dr, dc) != (0, 0) and 0 <= r + dr < self.rows and 0 <= c + dc < self.cols
]
def _compute_counts(self) -> None:
for r, c in product(range(self.rows), range(self.cols)):
if (r, c) not in self.mines:
self.counts[(r, c)] = sum(1 for n in self._neighbors(r, c) if n in self.mines)
def reveal(self, r: int, c: int) -> bool:
"""BFS-based reveal. Returns False if hit mine."""
if (r, c) in self.revealed or (r, c) in self.flagged:
return True
if (r, c) in self.mines:
self.revealed.add((r, c))
return False
queue = deque([(r, c)])
while queue:
pos = queue.popleft()
if pos in self.revealed:
continue
self.revealed.add(pos)
if self.counts.get(pos, 0) == 0:
for neighbor in self._neighbors(*pos):
if neighbor not in self.revealed and neighbor not in self.mines:
queue.append(neighbor)
return True
def toggle_flag(self, r: int, c: int) -> None:
if (r, c) in self.revealed:
return
if (r, c) in self.flagged:
self.flagged.remove((r, c))
else:
self.flagged.add((r, c))
def is_won(self) -> bool:
non_mine_cells = self.rows * self.cols - len(self.mines)
return len(self.revealed) == non_mine_cells
def is_lost(self) -> bool:
return bool(self.revealed & self.mines){{/fold}}
Question 35 - Deadlock Detector
- Difficulty: 10 / 10
- Approximate lines of code: 90 LoC
- Tags: concurrency, algorithms
Description
A deadlock occurs when threads are stuck waiting for each other in a cycle: Thread A holds Resource 1 and waits for Resource 2, while Thread B holds Resource 2 and waits for Resource 1. Neither can proceed. This is fundamentally a cycle detection problem in a directed graph called the "wait-for graph."
The wait-for graph has threads as nodes. An edge from T1 to T2 means "T1 is waiting for a resource held by T2." Internal state tracks two mappings: resource_owner: dict[resource_id, thread_id] (who holds each resource) and thread_waiting_for: dict[thread_id, resource_id] (what each blocked thread wants). From these, you can construct edges: if thread T waits for resource R, and R is owned by thread U, then there's an edge T -> U. A cycle in this graph means deadlock.
Part A: Resource Tracking
{{fold}}{Problem: Part A}
Implement acquire(thread_id, resource_id), wait(thread_id, resource_id), and release(thread_id, resource_id). Track who owns what and who is waiting for what.
detector = DeadlockDetector()
detector.acquire("T1", "R1") # T1 gets R1
# resource_owner = {"R1": "T1"}
# thread_waiting_for = {}
detector.acquire("T2", "R2") # T2 gets R2
# resource_owner = {"R1": "T1", "R2": "T2"}
detector.wait("T1", "R2") # T1 wants R2 (held by T2)
# thread_waiting_for = {"T1": "R2"}
# Implicit edge: T1 -> T2
detector.wait("T2", "R1") # T2 wants R1 (held by T1)
# thread_waiting_for = {"T1": "R2", "T2": "R1"}
# Edges: T1 -> T2, T2 -> T1 (CYCLE!){{/fold}}
Part B: Cycle Detection
{{fold}}{Problem: Part B}
Model wait-for relationships as a directed graph. Implement detect_deadlock() that returns the list of threads in the cycle, or None if no deadlock. Use DFS with three-color marking (WHITE=unvisited, GRAY=in current path, BLACK=done) to detect back-edges.
detector.detect_deadlock()
# Returns: ["T1", "T2", "T1"] (the cycle path)
# Three-thread cycle example:
detector2 = DeadlockDetector()
detector2.acquire("T1", "R1")
detector2.acquire("T2", "R2")
detector2.acquire("T3", "R3")
detector2.wait("T1", "R2") # T1 -> T2
detector2.wait("T2", "R3") # T2 -> T3
detector2.wait("T3", "R1") # T3 -> T1
detector2.detect_deadlock()
# Returns: ["T1", "T2", "T3", "T1"]{{/fold}}
Part C: Dynamic Updates
{{fold}}{Problem: Part C}
Handle the full lifecycle. When a thread acquires a resource it was waiting for, remove the wait edge. When a thread releases a resource, clear the ownership. Support re-entrant locks where a thread can re-acquire what it already owns (no-op, no self-loop).
detector = DeadlockDetector()
detector.acquire("T1", "R1")
detector.wait("T2", "R1") # T2 waiting for T1's resource
# thread_waiting_for = {"T2": "R1"}
detector.release("T1", "R1") # T1 releases
# resource_owner = {}
# thread_waiting_for = {"T2": "R1"} (T2 still waiting, but R1 now free)
detector.acquire("T2", "R1") # T2 finally gets it
# resource_owner = {"R1": "T2"}
# thread_waiting_for = {} (T2 no longer waiting)
# Re-entrant case:
detector.acquire("T2", "R1") # T2 already owns R1 - no-op, returns True{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if a thread tries to acquire a resource it already owns?
- What if
wait()is called for a resource that's not held by anyone? - What happens when a thread releases a resource others are waiting for?
- How do you handle a thread that's waiting for multiple resources?
Common mistakes:
- Wrong edge direction (should be: waiter -> owner, not owner -> waiter)
- Using simple visited set instead of three-color marking (misses back-edges in complex graphs)
- Creating self-loop when thread re-acquires owned resource
- Forgetting to clear wait state when thread finally acquires
- Not removing edges when resources are released
- Returning boolean instead of actual cycle participants
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses simple DFS-based cycle detection following the wait chain from thread to resource owner. Solution 2 builds an explicit graph with adjacency lists and uses three-color DFS (WHITE/GRAY/BLACK) for proper cycle detection in complex graphs. Solution 3 is event-driven, processing a stream of lock events and returning detailed DeadlockInfo with the full wait chain. The key difference is how they represent and traverse the wait-for graph. Core techniques: directed graph modeling, DFS cycle detection, three-color marking.
Solution 1: Simple DFS-based cycle detection Simple DFS-based cycle detection. Stores resource_owner and thread_waiting_for mappings. Cycle detection follows the wait chain: if thread T waits for resource R owned by U, check if U eventually waits for something T owns.
"""
Deadlock Detector - Solution 1: Simple DFS-based cycle detection
Builds a wait-for graph and uses DFS to detect cycles.
"""
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class DeadlockDetector:
"""Tracks resource ownership and waits, detects deadlock cycles."""
resource_owner: dict[str, str] = field(default_factory=dict) # resource -> thread
thread_waiting_for: dict[str, str] = field(default_factory=dict) # thread -> resource
def acquire(self, thread_id: str, resource_id: str) -> bool:
"""Thread acquires a resource. Returns True if successful."""
if resource_id not in self.resource_owner:
self.resource_owner[resource_id] = thread_id
self.thread_waiting_for.pop(thread_id, None)
return True
if self.resource_owner[resource_id] == thread_id:
return True # Already owns it
return False
def wait(self, thread_id: str, resource_id: str) -> None:
"""Thread starts waiting for a resource."""
if resource_id in self.resource_owner and self.resource_owner[resource_id] != thread_id:
self.thread_waiting_for[thread_id] = resource_id
def release(self, thread_id: str, resource_id: str) -> None:
"""Thread releases a resource."""
if self.resource_owner.get(resource_id) == thread_id:
del self.resource_owner[resource_id]
def detect_deadlock(self) -> Optional[list[str]]:
"""Returns list of threads in deadlock cycle, or None if no deadlock."""
for start_thread in self.thread_waiting_for:
cycle = self._find_cycle_from(start_thread)
if cycle:
return cycle
return None
def _find_cycle_from(self, start: str) -> Optional[list[str]]:
"""DFS to find cycle starting from given thread."""
visited = set()
path = []
current = start
while current and current not in visited:
visited.add(current)
path.append(current)
resource = self.thread_waiting_for.get(current)
if not resource:
return None
owner = self.resource_owner.get(resource)
if owner == start:
path.append(start)
return path
current = owner
return NoneSolution 2: Explicit graph with three-color DFS Explicit graph representation using adjacency lists. Uses three-color DFS (WHITE/GRAY/BLACK) for proper cycle detection that handles complex graphs with multiple components. Tracks which resources each thread holds for better edge management on release.
"""
Deadlock Detector - Solution 2: Graph-based with explicit edge representation
Uses an adjacency list to represent the wait-for graph more explicitly.
"""
from dataclasses import dataclass, field
from enum import Enum
from typing import Optional
class Color(Enum):
WHITE = 0 # Unvisited
GRAY = 1 # In current DFS path
BLACK = 2 # Fully processed
@dataclass
class WaitForGraph:
"""Explicit graph structure for wait-for relationships."""
edges: dict[str, set[str]] = field(default_factory=dict) # thread -> threads it waits for
resource_owner: dict[str, str] = field(default_factory=dict)
thread_resources: dict[str, set[str]] = field(default_factory=dict)
def add_thread(self, thread_id: str) -> None:
if thread_id not in self.edges:
self.edges[thread_id] = set()
self.thread_resources[thread_id] = set()
def acquire(self, thread_id: str, resource_id: str) -> bool:
self.add_thread(thread_id)
if resource_id not in self.resource_owner:
self.resource_owner[resource_id] = thread_id
self.thread_resources[thread_id].add(resource_id)
return True
return self.resource_owner[resource_id] == thread_id
def request(self, thread_id: str, resource_id: str) -> None:
"""Thread requests a resource, creating wait-for edge if blocked."""
self.add_thread(thread_id)
owner = self.resource_owner.get(resource_id)
if owner and owner != thread_id:
self.add_thread(owner)
self.edges[thread_id].add(owner)
def release(self, thread_id: str, resource_id: str) -> None:
if self.resource_owner.get(resource_id) == thread_id:
del self.resource_owner[resource_id]
self.thread_resources[thread_id].discard(resource_id)
# Remove edges pointing to this thread for this resource
for t in self.edges:
self.edges[t].discard(thread_id)
def find_cycle(self) -> Optional[list[str]]:
"""Find a cycle using DFS with coloring."""
color = {t: Color.WHITE for t in self.edges}
parent = {}
for start in self.edges:
if color[start] == Color.WHITE:
cycle = self._dfs_cycle(start, color, parent)
if cycle:
return cycle
return None
def _dfs_cycle(
self, node: str, color: dict[str, Color], parent: dict[str, str]
) -> Optional[list[str]]:
color[node] = Color.GRAY
for neighbor in self.edges.get(node, set()):
if neighbor not in color:
continue
if color[neighbor] == Color.GRAY:
# Found cycle - reconstruct it
cycle = [neighbor]
curr = node
while curr != neighbor:
cycle.append(curr)
curr = parent.get(curr, neighbor)
cycle.append(neighbor)
return cycle[::-1]
if color[neighbor] == Color.WHITE:
parent[neighbor] = node
result = self._dfs_cycle(neighbor, color, parent)
if result:
return result
color[node] = Color.BLACK
return NoneSolution 3: Event-driven with detailed reporting Event-driven design that processes a stream of lock events (ACQUIRE, RELEASE, WAIT). Returns detailed DeadlockInfo with the full wait chain showing which thread waits for which thread via which resource. Good for integration with monitoring systems.
"""
Deadlock Detector - Solution 3: Event-driven with comprehensive reporting
Processes a stream of lock events and provides detailed deadlock information.
"""
from dataclasses import dataclass, field
from enum import Enum, auto
from typing import Optional
class EventType(Enum):
ACQUIRE = auto()
RELEASE = auto()
WAIT = auto()
@dataclass
class LockEvent:
event_type: EventType
thread_id: str
resource_id: str
timestamp: int = 0
@dataclass
class DeadlockInfo:
threads: list[str]
resources: list[str]
wait_chain: list[tuple[str, str, str]] # (thread, waits_for, resource)
@dataclass
class DeadlockDetector:
"""Event-driven deadlock detector with detailed reporting."""
holdings: dict[str, set[str]] = field(default_factory=dict) # thread -> resources held
resource_owner: dict[str, str] = field(default_factory=dict) # resource -> owner thread
wait_for_resource: dict[str, str] = field(default_factory=dict) # thread -> resource
def process_event(self, event: LockEvent) -> Optional[DeadlockInfo]:
"""Process an event and return deadlock info if one is detected."""
if event.event_type == EventType.ACQUIRE:
return self._handle_acquire(event.thread_id, event.resource_id)
elif event.event_type == EventType.RELEASE:
self._handle_release(event.thread_id, event.resource_id)
elif event.event_type == EventType.WAIT:
return self._handle_wait(event.thread_id, event.resource_id)
return None
def _handle_acquire(self, thread: str, resource: str) -> Optional[DeadlockInfo]:
if resource in self.resource_owner:
if self.resource_owner[resource] != thread:
return None # Blocked - should use WAIT event
self.resource_owner[resource] = thread
self.holdings.setdefault(thread, set()).add(resource)
self.wait_for_resource.pop(thread, None)
return None
def _handle_release(self, thread: str, resource: str) -> None:
if self.resource_owner.get(resource) == thread:
del self.resource_owner[resource]
self.holdings.get(thread, set()).discard(resource)
def _handle_wait(self, thread: str, resource: str) -> Optional[DeadlockInfo]:
owner = self.resource_owner.get(resource)
if not owner or owner == thread:
return None
self.wait_for_resource[thread] = resource
return self._check_deadlock(thread)
def _check_deadlock(self, start_thread: str) -> Optional[DeadlockInfo]:
"""Check if adding this wait creates a cycle."""
visited = set()
path_threads = []
path_resources = []
current = start_thread
while current and current not in visited:
visited.add(current)
path_threads.append(current)
resource = self.wait_for_resource.get(current)
if not resource:
return None
path_resources.append(resource)
owner = self.resource_owner.get(resource)
if owner == start_thread:
# Found cycle
wait_chain = [
(path_threads[i], path_threads[(i + 1) % len(path_threads)], path_resources[i])
for i in range(len(path_threads))
]
return DeadlockInfo(
threads=path_threads,
resources=path_resources,
wait_chain=wait_chain,
)
current = owner
return None{{/fold}}
Question 36 - Metrics Collector
- Difficulty: 5 / 10
- Approximate lines of code: 90 LoC
- Tags: storage
Description
A metrics collector is the foundation of application monitoring systems like Prometheus, StatsD, or Datadog. It tracks three fundamental metric types: counters (monotonically increasing values like request counts), gauges (point-in-time values like CPU usage), and histograms (distributions of observations like latency). Each observation is timestamped to enable time-range queries.
The core data structures are: (1) timestamped value lists per metric name, and (2) aggregation logic that differs by metric type. Counters accumulate, gauges return the latest value, and histograms compute statistics over observations.
Note: The
sortedcontainerslibrary (SortedList) is available. For histogram percentile queries, usingSortedListinstead ofbisect.insortgives O(log n) insertions.
Part A: Counters and Gauges
{{fold}}{Problem: Part A}
Implement counters that only increment and gauges that can be set to any value.
collector = MetricsCollector()
# Counter: increment only, never decreases
collector.increment("http_requests", 1)
collector.increment("http_requests", 5)
collector.get_counter("http_requests") # Returns 6
collector.increment("http_requests", -1) # Raises ValueError
# Gauge: set to arbitrary value
collector.set_gauge("cpu_percent", 45.2)
collector.set_gauge("cpu_percent", 38.7)
collector.get_gauge("cpu_percent") # Returns 38.7 (latest)
# Internal state:
# counters = {"http_requests": [Entry(6, t1), Entry(11, t2)]}
# gauges = {"cpu_percent": [Entry(45.2, t1), Entry(38.7, t2)]}{{/fold}}
Part B: Histograms
{{fold}}{Problem: Part B}
Add histogram support for tracking distributions. Compute min, max, sum, count, and average over observations.
collector = MetricsCollector()
collector.observe("request_latency_ms", 45)
collector.observe("request_latency_ms", 120)
collector.observe("request_latency_ms", 89)
collector.observe("request_latency_ms", 230)
stats = collector.get_histogram("request_latency_ms")
# Returns:
# {
# "count": 4,
# "sum": 484,
# "min": 45,
# "max": 230,
# "avg": 121.0
# }
# Empty histogram edge case
collector.get_histogram("nonexistent")
# Returns: {"count": 0, "sum": 0, "min": None, "max": None, "avg": None}{{/fold}}
Part C: Time Range Queries
{{fold}}{Problem: Part C}
Support querying metrics within a specific time window. Filter observations by start/end timestamps.
collector = MetricsCollector()
t1 = time.time()
collector.observe("latency", 100)
time.sleep(1)
t2 = time.time()
collector.observe("latency", 200)
time.sleep(1)
t3 = time.time()
collector.observe("latency", 300)
# Query specific time range
stats = collector.get_histogram("latency", start=t2, end=t3)
# Returns stats for observations between t2 and t3 only
# {"count": 2, "sum": 500, "min": 200, "max": 300, "avg": 250}
# Get gauge value at specific time
collector.get_gauge("cpu", start=t1, end=t2) # Latest value in range{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What does
get_histogramreturn for a metric with zero observations? - What happens if you query a counter for a time range before any increments?
- How do you handle
avgwhen count is zero (division by zero)? - Should time range be inclusive or exclusive on boundaries?
Common mistakes:
- Division by zero when computing average of empty histogram
- Allowing negative increments on counters
- Not storing timestamps, making time-range queries impossible
- Returning 0 instead of None for missing gauges (0 is a valid gauge value)
- O(n) linear scan for every query instead of using efficient data structures
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses a simple dictionary-based approach with timestamped entries for each metric type. Solution 2 takes an object-oriented approach with separate Counter, Gauge, and Histogram classes. Solution 3 uses time-bucketed storage with sorted insertion for efficient range queries and percentile calculations. The key difference is storage granularity: flat lists vs encapsulated classes vs time-bucketed structures. Core techniques: timestamped entries, list comprehension filtering, bisect for sorted insertion, defaultdict for auto-initialization.
Solution 1: Simple dictionary-based approach Simple dictionary-based approach with timestamped entries. Each metric type stored in separate defaultdict. Time filtering done via list comprehension.
"""
Metrics Collector - Solution 1: Simple In-Memory Implementation
Uses dictionaries with timestamped entries for all metric types.
"""
from dataclasses import dataclass, field
from typing import Optional
from collections import defaultdict
import time
@dataclass
class MetricEntry:
value: float
timestamp: float
@dataclass
class MetricsCollector:
counters: dict[str, list[MetricEntry]] = field(default_factory=lambda: defaultdict(list))
gauges: dict[str, list[MetricEntry]] = field(default_factory=lambda: defaultdict(list))
histograms: dict[str, list[MetricEntry]] = field(default_factory=lambda: defaultdict(list))
def _now(self) -> float:
return time.time()
def increment(self, name: str, value: float = 1.0) -> None:
"""Increment a counter by value (must be positive)."""
if value < 0:
raise ValueError("Counter increments must be non-negative")
entries = self.counters[name]
current = entries[-1].value if entries else 0.0
entries.append(MetricEntry(current + value, self._now()))
def set_gauge(self, name: str, value: float) -> None:
"""Set a gauge to an arbitrary value."""
self.gauges[name].append(MetricEntry(value, self._now()))
def observe(self, name: str, value: float) -> None:
"""Record an observation in a histogram."""
self.histograms[name].append(MetricEntry(value, self._now()))
def get_counter(self, name: str, start: Optional[float] = None, end: Optional[float] = None) -> float:
"""Get current counter value, optionally filtered by time range."""
entries = self._filter_by_time(self.counters[name], start, end)
return entries[-1].value if entries else 0.0
def get_gauge(self, name: str, start: Optional[float] = None, end: Optional[float] = None) -> Optional[float]:
"""Get most recent gauge value in time range."""
entries = self._filter_by_time(self.gauges[name], start, end)
return entries[-1].value if entries else None
def get_histogram(self, name: str, start: Optional[float] = None, end: Optional[float] = None) -> dict:
"""Get histogram statistics: count, sum, min, max, avg."""
entries = self._filter_by_time(self.histograms[name], start, end)
if not entries:
return {"count": 0, "sum": 0.0, "min": None, "max": None, "avg": None}
values = [e.value for e in entries]
return {
"count": len(values),
"sum": sum(values),
"min": min(values),
"max": max(values),
"avg": sum(values) / len(values),
}
def _filter_by_time(
self, entries: list[MetricEntry], start: Optional[float], end: Optional[float]
) -> list[MetricEntry]:
result = entries
if start is not None:
result = [e for e in result if e.timestamp >= start]
if end is not None:
result = [e for e in result if e.timestamp <= end]
return resultSolution 2: Object-oriented with metric classes Object-oriented approach with separate Counter, Gauge, and Histogram classes. Each metric type encapsulates its own behavior and storage. A MetricsRegistry provides named access to metrics.
"""
Metrics Collector - Solution 2: Separation of Concerns with Metric Classes
Each metric type is its own class with dedicated storage and behavior.
"""
from dataclasses import dataclass, field
from typing import Optional, Protocol
from abc import ABC, abstractmethod
import time
@dataclass
class TimestampedValue:
value: float
timestamp: float = field(default_factory=time.time)
class Metric(ABC):
@abstractmethod
def query(self, start: Optional[float] = None, end: Optional[float] = None) -> any:
pass
@dataclass
class Counter(Metric):
_values: list[TimestampedValue] = field(default_factory=list)
_total: float = 0.0
def increment(self, amount: float = 1.0) -> None:
if amount < 0:
raise ValueError("Cannot decrement a counter")
self._total += amount
self._values.append(TimestampedValue(self._total))
def query(self, start: Optional[float] = None, end: Optional[float] = None) -> float:
filtered = self._filter(start, end)
return filtered[-1].value if filtered else 0.0
def _filter(self, start: Optional[float], end: Optional[float]) -> list[TimestampedValue]:
return [v for v in self._values
if (start is None or v.timestamp >= start)
and (end is None or v.timestamp <= end)]
@dataclass
class Gauge(Metric):
_values: list[TimestampedValue] = field(default_factory=list)
def set(self, value: float) -> None:
self._values.append(TimestampedValue(value))
def query(self, start: Optional[float] = None, end: Optional[float] = None) -> Optional[float]:
filtered = [v for v in self._values
if (start is None or v.timestamp >= start)
and (end is None or v.timestamp <= end)]
return filtered[-1].value if filtered else None
@dataclass
class Histogram(Metric):
_observations: list[TimestampedValue] = field(default_factory=list)
def observe(self, value: float) -> None:
self._observations.append(TimestampedValue(value))
def query(self, start: Optional[float] = None, end: Optional[float] = None) -> dict:
filtered = [v.value for v in self._observations
if (start is None or v.timestamp >= start)
and (end is None or v.timestamp <= end)]
if not filtered:
return {"count": 0, "sum": 0.0, "min": None, "max": None, "avg": None}
return {
"count": len(filtered),
"sum": sum(filtered),
"min": min(filtered),
"max": max(filtered),
"avg": sum(filtered) / len(filtered),
}
@dataclass
class MetricsRegistry:
_counters: dict[str, Counter] = field(default_factory=dict)
_gauges: dict[str, Gauge] = field(default_factory=dict)
_histograms: dict[str, Histogram] = field(default_factory=dict)
def counter(self, name: str) -> Counter:
if name not in self._counters:
self._counters[name] = Counter()
return self._counters[name]
def gauge(self, name: str) -> Gauge:
if name not in self._gauges:
self._gauges[name] = Gauge()
return self._gauges[name]
def histogram(self, name: str) -> Histogram:
if name not in self._histograms:
self._histograms[name] = Histogram()
return self._histograms[name]Solution 3: Time-bucketed storage with percentiles Time-bucketed storage for efficient range queries. Uses sorted insertion (bisect) within buckets for percentile calculations. Supports percentile queries (p50, p90, p99) in addition to basic statistics.
"""
Metrics Collector - Solution 3: Time-Bucketed Storage with Percentiles
Uses time buckets for efficient range queries and supports percentile calculations.
"""
from dataclasses import dataclass, field
from typing import Optional
from bisect import bisect_left, bisect_right, insort
import time
BUCKET_SIZE = 60.0 # 1 minute buckets
@dataclass
class TimeBucket:
start_time: float
values: list[float] = field(default_factory=list)
def add(self, value: float) -> None:
insort(self.values, value) # Keep sorted for percentile queries
@dataclass
class TimeSeriesStore:
buckets: list[TimeBucket] = field(default_factory=list)
_bucket_starts: list[float] = field(default_factory=list)
def _get_bucket(self, timestamp: float) -> TimeBucket:
bucket_start = (timestamp // BUCKET_SIZE) * BUCKET_SIZE
idx = bisect_left(self._bucket_starts, bucket_start)
if idx < len(self._bucket_starts) and self._bucket_starts[idx] == bucket_start:
return self.buckets[idx]
bucket = TimeBucket(bucket_start)
self.buckets.insert(idx, bucket)
self._bucket_starts.insert(idx, bucket_start)
return bucket
def add(self, value: float, timestamp: Optional[float] = None) -> None:
ts = timestamp or time.time()
self._get_bucket(ts).add(value)
def get_values(self, start: Optional[float], end: Optional[float]) -> list[float]:
result = []
for bucket in self.buckets:
if start and bucket.start_time + BUCKET_SIZE < start:
continue
if end and bucket.start_time > end:
break
result.extend(bucket.values)
return result
@dataclass
class MetricsCollector:
_counters: dict[str, float] = field(default_factory=dict)
_counter_history: dict[str, TimeSeriesStore] = field(default_factory=dict)
_gauges: dict[str, TimeSeriesStore] = field(default_factory=dict)
_histograms: dict[str, TimeSeriesStore] = field(default_factory=dict)
def increment(self, name: str, value: float = 1.0) -> None:
if value < 0:
raise ValueError("Counter increment must be non-negative")
self._counters[name] = self._counters.get(name, 0.0) + value
if name not in self._counter_history:
self._counter_history[name] = TimeSeriesStore()
self._counter_history[name].add(self._counters[name])
def set_gauge(self, name: str, value: float) -> None:
if name not in self._gauges:
self._gauges[name] = TimeSeriesStore()
self._gauges[name].add(value)
def observe(self, name: str, value: float) -> None:
if name not in self._histograms:
self._histograms[name] = TimeSeriesStore()
self._histograms[name].add(value)
def get_counter(self, name: str) -> float:
return self._counters.get(name, 0.0)
def get_gauge(self, name: str, start: Optional[float] = None, end: Optional[float] = None) -> Optional[float]:
if name not in self._gauges:
return None
values = self._gauges[name].get_values(start, end)
return values[-1] if values else None
def get_histogram(
self, name: str, start: Optional[float] = None, end: Optional[float] = None, percentiles: list[float] = None
) -> dict:
if name not in self._histograms:
return {"count": 0, "sum": 0.0, "min": None, "max": None, "avg": None, "percentiles": {}}
values = self._histograms[name].get_values(start, end)
if not values:
return {"count": 0, "sum": 0.0, "min": None, "max": None, "avg": None, "percentiles": {}}
sorted_vals = sorted(values)
pcts = {}
for p in (percentiles or []):
idx = int(len(sorted_vals) * p / 100)
pcts[p] = sorted_vals[min(idx, len(sorted_vals) - 1)]
return {
"count": len(values), "sum": sum(values), "min": min(values),
"max": max(values), "avg": sum(values) / len(values), "percentiles": pcts,
}{{/fold}}
Question 37 - Packet Reassembler
- Difficulty: 4 / 10
- Approximate lines of code: 80 LoC
- Tags: data-structures
Description
Network packets often arrive out of order due to routing differences, retransmissions, and varying network paths. A packet reassembler buffers incoming packets and reconstructs the original data stream by ordering packets by their sequence numbers. The core data structure is a dictionary or buffer mapping sequence numbers to packet data, combined with a pointer tracking the next expected sequence number. When contiguous packets are available starting from this pointer, they can be "flushed" to produce the reassembled output.
The key insight is that you need O(1) lookup by sequence number (dictionary) while also tracking what's missing. Gap detection becomes important when you need to request retransmissions - you need to know which sequence numbers haven't arrived yet between your expected position and the highest seen.
Part A: Basic Buffering and Reassembly
{{fold}}{Problem: Part A}
Implement a packet reassembler with receive(packet) and reassemble() methods. Packets have a sequence number and data payload. Buffer out-of-order packets until you can produce a contiguous stream.
reassembler = PacketReassembler()
# Receive packets out of order
reassembler.receive(Packet(seq_num=2, data=b"C"))
reassembler.receive(Packet(seq_num=0, data=b"A"))
# Internal state: buffer = {0: b"A", 2: b"C"}, expected_seq = 0
result = reassembler.reassemble()
# Returns b"A" (only seq 0 is contiguous from expected)
# Internal state: buffer = {2: b"C"}, expected_seq = 1
reassembler.receive(Packet(seq_num=1, data=b"B"))
result = reassembler.reassemble()
# Returns b"BC" (now seq 1,2 are contiguous)
# Internal state: buffer = {}, expected_seq = 3{{/fold}}
Part B: Duplicate and Gap Detection
{{fold}}{Problem: Part B}
Add get_missing_sequences() to return gaps between expected and highest received. Also handle duplicates - receive() should return False for duplicate packets.
reassembler = PacketReassembler()
reassembler.receive(Packet(seq_num=0, data=b"A"))
reassembler.receive(Packet(seq_num=5, data=b"F"))
missing = reassembler.get_missing_sequences()
# Returns [1, 2, 3, 4]
# Duplicate detection
was_new = reassembler.receive(Packet(seq_num=0, data=b"A"))
# Returns False (duplicate){{/fold}}
Part C: Timeout-Based Retransmit Requests
{{fold}}{Problem: Part C}
Add timeout tracking so you can request retransmissions for missing packets that have been missing "too long". Track when gaps are first detected and return timed-out sequences.
reassembler = PacketReassembler(timeout_seconds=5.0)
reassembler.receive(Packet(seq_num=0, data=b"A"))
reassembler.receive(Packet(seq_num=3, data=b"D")) # Gap detected at t=0
# At t=3 seconds
retransmit = reassembler.get_retransmit_requests()
# Returns [] (not timed out yet)
# At t=6 seconds
retransmit = reassembler.get_retransmit_requests()
# Returns [1, 2] (missing sequences that have timed out){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if you receive the same packet twice?
- What if packets arrive before sequence 0?
- How do you handle window overflow (very large gaps)?
- What if packet data is empty?
Common mistakes:
- Not advancing expected_seq after reassembly
- O(n) linear scan for missing sequences instead of using set difference
- Storing already-processed packets (memory leak)
- Not removing packets from buffer after reassembly
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses a simple dictionary mapping sequence numbers to packets, with linear iteration to find contiguous runs. Solution 2 uses a min-heap ordered by sequence number for efficient retrieval of the next expected packet, with streaming callback support. Solution 3 maintains explicit Gap objects to track missing ranges, which is more memory-efficient for sparse sequences. The key difference is how they track and detect gaps: dictionary lookup vs heap ordering vs explicit gap ranges. Core techniques: hash maps, min-heaps, interval tracking.
Solution 1: Simple Dictionary-Based Approach A straightforward dictionary-based approach. Packets are stored by sequence number, and reassembly iterates from expected_seq until a gap is found. Gap detection scans from expected to max seen.
"""
Packet Reassembler - Solution 1: Simple Dictionary-Based Approach
Uses a dictionary to store packets by sequence number, with periodic
reassembly checks.
"""
from dataclasses import dataclass
from typing import Optional
import time
@dataclass
class Packet:
seq_num: int
data: bytes
timestamp: float = 0.0
def __post_init__(self) -> None:
if self.timestamp == 0.0:
self.timestamp = time.time()
class PacketReassembler:
def __init__(self, timeout_seconds: float = 5.0) -> None:
self.packets: dict[int, Packet] = {}
self.expected_seq: int = 0
self.timeout_seconds = timeout_seconds
self.duplicates_received: int = 0
def receive(self, packet: Packet) -> bool:
"""Receive a packet. Returns True if new, False if duplicate."""
if packet.seq_num in self.packets:
self.duplicates_received += 1
return False
self.packets[packet.seq_num] = packet
return True
def get_missing_sequences(self) -> list[int]:
"""Return list of missing sequence numbers up to highest received."""
if not self.packets:
return []
max_seq = max(self.packets.keys())
missing = []
for seq in range(self.expected_seq, max_seq):
if seq not in self.packets:
missing.append(seq)
return missing
def get_timed_out_sequences(self) -> list[int]:
"""Return missing sequences that have timed out."""
if not self.packets:
return []
current_time = time.time()
oldest_packet_time = min(p.timestamp for p in self.packets.values())
if current_time - oldest_packet_time < self.timeout_seconds:
return []
return self.get_missing_sequences()
def reassemble(self) -> Optional[bytes]:
"""Try to reassemble contiguous packets from expected_seq."""
if not self.packets:
return None
result = bytearray()
while self.expected_seq in self.packets:
result.extend(self.packets[self.expected_seq].data)
del self.packets[self.expected_seq]
self.expected_seq += 1
return bytes(result) if result else NoneSolution 2: Heap-Based with Streaming Output A heap-based streaming approach. Uses a min-heap ordered by sequence number for efficient retrieval of the next expected packet. Supports callbacks for real-time streaming output.
"""
Packet Reassembler - Solution 2: Heap-Based with Streaming Output
Uses a min-heap for efficient retrieval of the next expected packet.
Supports streaming reassembly with callbacks.
"""
from dataclasses import dataclass, field
from typing import Callable, Optional
import heapq
import time
@dataclass(order=True)
class Packet:
seq_num: int
data: bytes = field(compare=False)
timestamp: float = field(compare=False, default_factory=time.time)
class StreamingPacketReassembler:
def __init__(
self,
on_data: Optional[Callable[[bytes], None]] = None,
timeout_seconds: float = 5.0,
) -> None:
self.heap: list[Packet] = []
self.seen_sequences: set[int] = set()
self.expected_seq: int = 0
self.on_data = on_data
self.timeout_seconds = timeout_seconds
self.duplicate_count: int = 0
def receive(self, packet: Packet) -> bool:
"""Receive packet, auto-flush if contiguous. Returns False if dup."""
if packet.seq_num in self.seen_sequences:
self.duplicate_count += 1
return False
self.seen_sequences.add(packet.seq_num)
heapq.heappush(self.heap, packet)
self._try_flush()
return True
def _try_flush(self) -> None:
"""Flush contiguous packets to callback."""
while self.heap and self.heap[0].seq_num == self.expected_seq:
packet = heapq.heappop(self.heap)
if self.on_data:
self.on_data(packet.data)
self.expected_seq += 1
def get_missing_sequences(self) -> list[int]:
"""Return missing sequence numbers."""
if not self.heap:
return []
max_seq = max(p.seq_num for p in self.heap)
return [s for s in range(self.expected_seq, max_seq)
if s not in self.seen_sequences]
def request_retransmit(self) -> list[int]:
"""Return sequences needing retransmit based on timeout."""
if not self.heap:
return []
now = time.time()
oldest = min(p.timestamp for p in self.heap)
if now - oldest >= self.timeout_seconds:
return self.get_missing_sequences()
return []
def get_buffered_data(self) -> bytes:
"""Get all buffered data in order (doesn't advance expected_seq)."""
sorted_packets = sorted(self.heap, key=lambda p: p.seq_num)
return b"".join(p.data for p in sorted_packets)Solution 3: Sliding Window with Gap Tracking A sliding window approach with explicit gap tracking. Maintains a list of Gap objects representing missing ranges, which is more memory-efficient for sparse sequences than tracking individual missing numbers.
"""
Packet Reassembler - Solution 3: Sliding Window with Gap Tracking
Uses a sliding window buffer with explicit gap tracking for efficient
missing packet detection. More memory-efficient for sparse sequences.
"""
from dataclasses import dataclass
from typing import Optional
import time
@dataclass
class Packet:
seq_num: int
data: bytes
timestamp: float = 0.0
def __post_init__(self) -> None:
if self.timestamp == 0.0:
self.timestamp = time.time()
@dataclass
class Gap:
start: int # inclusive
end: int # exclusive
first_detected: float = 0.0
def __post_init__(self) -> None:
if self.first_detected == 0.0:
self.first_detected = time.time()
class SlidingWindowReassembler:
def __init__(self, window_size: int = 1024, timeout_s: float = 5.0) -> None:
self.window_size = window_size
self.timeout_seconds = timeout_s
self.buffer: dict[int, Packet] = {}
self.gaps: list[Gap] = []
self.next_expected: int = 0
self.highest_seen: int = -1
self.duplicates: int = 0
def receive(self, packet: Packet) -> bool:
"""Receive a packet. Returns False if duplicate or out of window."""
seq = packet.seq_num
# Reject if already processed or duplicate
if seq < self.next_expected or seq in self.buffer:
self.duplicates += 1
return False
# Reject if too far ahead
if seq >= self.next_expected + self.window_size:
return False
self.buffer[seq] = packet
# Update gap tracking
if seq > self.highest_seen + 1:
self.gaps.append(Gap(start=self.highest_seen + 1, end=seq))
if seq > self.highest_seen:
self.highest_seen = seq
self._update_gaps(seq)
return True
def _update_gaps(self, filled_seq: int) -> None:
"""Remove or shrink gaps when a sequence is filled."""
new_gaps = []
for gap in self.gaps:
if filled_seq < gap.start or filled_seq >= gap.end:
new_gaps.append(gap)
elif filled_seq == gap.start:
if gap.start + 1 < gap.end:
new_gaps.append(Gap(gap.start + 1, gap.end, gap.first_detected))
elif filled_seq == gap.end - 1:
if gap.start < gap.end - 1:
new_gaps.append(Gap(gap.start, gap.end - 1, gap.first_detected))
else:
new_gaps.append(Gap(gap.start, filled_seq, gap.first_detected))
new_gaps.append(Gap(filled_seq + 1, gap.end, gap.first_detected))
self.gaps = new_gaps
def reassemble(self) -> Optional[bytes]:
"""Reassemble contiguous packets from next_expected."""
result = bytearray()
while self.next_expected in self.buffer:
result.extend(self.buffer.pop(self.next_expected).data)
self.next_expected += 1
# Clean up gaps below next_expected
self.gaps = [g for g in self.gaps if g.end > self.next_expected]
return bytes(result) if result else None
def get_retransmit_requests(self) -> list[int]:
"""Return timed-out missing sequences needing retransmit."""
now = time.time()
result = []
for gap in self.gaps:
if now - gap.first_detected >= self.timeout_seconds:
result.extend(range(gap.start, gap.end))
return [s for s in result if s >= self.next_expected]{{/fold}}
Question 38 - Bloom Filter
- Difficulty: 8 / 10
- Approximate lines of code: 70 LoC
- Tags: probabilistic, data-structures
Description
A Bloom filter is a space-efficient probabilistic data structure for set membership testing. Instead of storing actual elements, it uses a bit array and multiple hash functions. When you add an element, you hash it with k different functions and set the corresponding k bits to 1. To check membership, you verify all k bits are set. The key insight: false negatives are impossible (if an element was added, its bits are definitely set), but false positives can occur (bits might be set by other elements).
The tradeoff is simple: more bits and more hash functions reduce false positives, but use more memory and CPU. For n expected items and desired false positive rate p, optimal bit array size is m = -n*ln(p)/(ln(2)^2) and optimal hash count is k = (m/n)*ln(2).
Part A: Basic Structure
{{fold}}{Problem: Part A}
Implement a Bloom filter with add(item) and might_contain(item) methods. The filter needs a bit array of fixed size and k hash functions. Use salted hashing (prepend index to item before hashing) to simulate multiple hash functions from one.
bf = BloomFilter(size=1000, num_hashes=3)
bf.add("apple")
# Internal: hash_0("apple") = 142, hash_1("apple") = 567, hash_2("apple") = 891
# bit_array: [..., 1@142, ..., 1@567, ..., 1@891, ...]
bf.add("banana")
# Sets bits at positions 234, 567, 789 (567 overlaps with "apple")
bf.might_contain("apple") # True - bits 142, 567, 891 all set
bf.might_contain("cherry") # Likely False - unless all its bit positions happen to be set
bf.might_contain("grape") # Could be True (false positive) if its bits were set by other items{{/fold}}
Part B: Optimal Sizing
{{fold}}{Problem: Part B}
Add static methods to calculate optimal parameters given expected items and desired false positive rate:
optimal_size(expected_items, fp_rate)returns bit array sizeoptimal_num_hashes(size, expected_items)returns number of hash functions
# For 1000 items at 1% false positive rate:
m = BloomFilter.optimal_size(1000, 0.01) # ~9585 bits
k = BloomFilter.optimal_num_hashes(m, 1000) # ~7 hash functions
bf = BloomFilter(size=m, num_hashes=k){{/fold}}
Part C: Analysis
{{fold}}{Problem: Part C}
Add expected_false_positive_rate() that estimates the current FP probability based on items added. The formula is (1 - e^(-kn/m))^k where k=hash count, n=items added, m=size.
bf = BloomFilter(size=1000, num_hashes=3)
for word in ["apple", "banana", "cherry"]:
bf.add(word)
fp_rate = bf.expected_false_positive_rate() # ~0.00027 for these parameters{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if you add the same element twice? (No effect - bits already set)
- Can you remove elements? (Not from basic Bloom filter - need counting variant)
- What if num_hashes > size? (Bits overlap more, higher FP rate)
- Why not use Python's built-in hash()? (Non-deterministic across runs)
Common mistakes:
- Using a single hash function (defeats purpose - need k independent hashes)
- Using Python's hash() which isn't stable across interpreter sessions
- Forgetting that false positive rate increases as more items are added
- Using list of bools instead of bit manipulation (8x memory waste)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 uses salted hashing with a boolean list for simplicity. Solution 2 upgrades to double hashing (MD5+SHA1) with bytearray bit manipulation for memory efficiency. Solution 3 implements a counting Bloom filter with 4-bit counters and FNV-1a hashing to support deletions. The key difference is the tradeoff between simplicity, memory efficiency, and functionality (deletion support). Core techniques: hash functions, bit manipulation, probabilistic data structures.
Solution 1: Basic Implementation Basic implementation using salted hashing (prepending index to create k hash functions) with a simple boolean list for the bit array. Straightforward but not memory-optimized.
"""
Bloom Filter - Solution 1: Basic Implementation
Uses built-in hash with salt values for multiple hash functions.
"""
from dataclasses import dataclass, field
import math
@dataclass
class BloomFilter:
"""Probabilistic set membership data structure."""
size: int # Number of bits in the filter
num_hashes: int # Number of hash functions to use
bit_array: list[bool] = field(default_factory=list, repr=False)
_count: int = field(default=0, repr=False)
def __post_init__(self) -> None:
if self.size <= 0:
raise ValueError("Size must be positive")
if self.num_hashes <= 0:
raise ValueError("Number of hash functions must be positive")
self.bit_array = [False] * self.size
def _get_hash_indices(self, item: str) -> list[int]:
"""Generate k hash indices for an item using salted hashing."""
indices = []
for i in range(self.num_hashes):
# Use salt to create different hash functions
salted = f"{i}:{item}"
hash_value = hash(salted) % self.size
indices.append(hash_value)
return indices
def add(self, item: str) -> None:
"""Add an element to the Bloom filter."""
for index in self._get_hash_indices(item):
self.bit_array[index] = True
self._count += 1
def might_contain(self, item: str) -> bool:
"""Check if element might be in the set. May have false positives."""
return all(self.bit_array[i] for i in self._get_hash_indices(item))
def expected_false_positive_rate(self) -> float:
"""Calculate expected false positive probability."""
# Formula: (1 - e^(-k*n/m))^k
# k = num_hashes, n = items added, m = size
if self._count == 0:
return 0.0
exponent = -self.num_hashes * self._count / self.size
return (1 - math.exp(exponent)) ** self.num_hashes
@staticmethod
def optimal_size(expected_items: int, fp_rate: float) -> int:
"""Calculate optimal bit array size for given items and FP rate."""
# m = -n * ln(p) / (ln(2)^2)
return int(-expected_items * math.log(fp_rate) / (math.log(2) ** 2))
@staticmethod
def optimal_num_hashes(size: int, expected_items: int) -> int:
"""Calculate optimal number of hash functions."""
# k = (m/n) * ln(2)
return max(1, int((size / expected_items) * math.log(2)))Solution 2: Double Hashing with Bytearray Production-quality implementation using double hashing technique (h(i) = h1 + i*h2) with MD5 and SHA1. Uses bytearray for memory efficiency with bit manipulation for get/set operations.
"""
Bloom Filter - Solution 2: Using mmh3 (MurmurHash3)
Production-quality implementation with double hashing technique.
"""
from dataclasses import dataclass, field
import math
import hashlib
@dataclass
class BloomFilter:
"""Bloom filter using double hashing for hash function generation."""
size: int
num_hashes: int
_bits: bytearray = field(default_factory=bytearray, repr=False)
_count: int = field(default=0, repr=False)
def __post_init__(self) -> None:
if self.size <= 0 or self.num_hashes <= 0:
raise ValueError("Size and num_hashes must be positive")
# Use bytearray for memory efficiency
self._bits = bytearray((self.size + 7) // 8)
def _hash_pair(self, item: str) -> tuple[int, int]:
"""Generate two independent hash values using MD5 and SHA1."""
encoded = item.encode("utf-8")
h1 = int(hashlib.md5(encoded).hexdigest(), 16)
h2 = int(hashlib.sha1(encoded).hexdigest(), 16)
return h1, h2
def _get_indices(self, item: str) -> list[int]:
"""Double hashing: h(i) = h1 + i*h2 mod m."""
h1, h2 = self._hash_pair(item)
return [(h1 + i * h2) % self.size for i in range(self.num_hashes)]
def _set_bit(self, index: int) -> None:
"""Set a bit in the bytearray."""
self._bits[index // 8] |= 1 << (index % 8)
def _get_bit(self, index: int) -> bool:
"""Get a bit from the bytearray."""
return bool(self._bits[index // 8] & (1 << (index % 8)))
def add(self, item: str) -> None:
"""Add an element to the filter."""
for idx in self._get_indices(item):
self._set_bit(idx)
self._count += 1
def might_contain(self, item: str) -> bool:
"""Check if element might exist (may have false positives)."""
return all(self._get_bit(idx) for idx in self._get_indices(item))
def expected_fp_rate(self) -> float:
"""Expected false positive rate: (1 - e^(-kn/m))^k."""
if self._count == 0:
return 0.0
p = 1 - math.exp(-self.num_hashes * self._count / self.size)
return p ** self.num_hashes
def fill_ratio(self) -> float:
"""Ratio of bits set to total bits."""
set_bits = sum(bin(byte).count("1") for byte in self._bits)
return set_bits / self.size
@classmethod
def create_optimal(cls, expected_items: int, fp_rate: float) -> "BloomFilter":
"""Factory method to create optimally-sized Bloom filter."""
size = int(-expected_items * math.log(fp_rate) / (math.log(2) ** 2))
num_hashes = max(1, int((size / expected_items) * math.log(2)))
return cls(size=size, num_hashes=num_hashes)Solution 3: Counting Bloom Filter Counting Bloom filter variant that supports deletions by using 4-bit counters instead of single bits. Uses FNV-1a hash algorithm. Increment counters on add, decrement on remove.
"""
Bloom Filter - Solution 3: Counting Bloom Filter
Supports deletions by using counters instead of bits.
"""
from dataclasses import dataclass, field
from typing import Any
import math
import struct
@dataclass
class CountingBloomFilter:
"""Bloom filter variant that supports deletions using 4-bit counters."""
size: int
num_hashes: int
_counters: list[int] = field(default_factory=list, repr=False)
_count: int = field(default=0, repr=False)
MAX_COUNT: int = field(default=15, repr=False) # 4-bit counter max
def __post_init__(self) -> None:
if self.size <= 0 or self.num_hashes <= 0:
raise ValueError("Size and num_hashes must be positive")
self._counters = [0] * self.size
def _hash(self, item: Any, seed: int) -> int:
"""Generate hash using FNV-1a algorithm with seed."""
data = f"{seed}:{item}".encode("utf-8")
h = 2166136261 # FNV offset basis
for byte in data:
h ^= byte
h = (h * 16777619) & 0xFFFFFFFF # FNV prime, 32-bit
return h % self.size
def _get_indices(self, item: Any) -> list[int]:
"""Get all hash indices for an item."""
return [self._hash(item, i) for i in range(self.num_hashes)]
def add(self, item: Any) -> None:
"""Add element to filter. Increments counters."""
for idx in self._get_indices(item):
if self._counters[idx] < self.MAX_COUNT:
self._counters[idx] += 1
self._count += 1
def remove(self, item: Any) -> bool:
"""Remove element. Returns True if element was possibly present."""
if not self.might_contain(item):
return False
for idx in self._get_indices(item):
if self._counters[idx] > 0:
self._counters[idx] -= 1
self._count = max(0, self._count - 1)
return True
def might_contain(self, item: Any) -> bool:
"""Check membership. False positives possible, no false negatives."""
return all(self._counters[idx] > 0 for idx in self._get_indices(item))
def expected_fp_rate(self) -> float:
"""Calculate expected false positive probability."""
if self._count == 0:
return 0.0
exp = -self.num_hashes * self._count / self.size
return (1 - math.exp(exp)) ** self.num_hashes
def memory_usage_bytes(self) -> int:
"""Estimate memory usage in bytes."""
# Python int overhead is significant; real impl would pack counters
return self.size * 4 # Assuming packed 4-bit counters = 0.5 bytes each
@classmethod
def optimal(cls, n: int, fp: float) -> "CountingBloomFilter":
"""Create optimally-sized counting Bloom filter."""
m = int(-n * math.log(fp) / (math.log(2) ** 2))
k = max(1, int((m / n) * math.log(2)))
return cls(size=m, num_hashes=k){{/fold}}
Question 39 - Cron Parser
- Difficulty: 6 / 10
- Approximate lines of code: 80 LoC
- Tags: scheduling
Description
Cron is a time-based job scheduler in Unix-like systems. A cron expression consists of 5 fields: minute (0-59), hour (0-23), day of month (1-31), month (1-12), and day of week (0-6, where 0=Sunday). Each field supports wildcards (*), ranges (1-5), lists (1,3,5), and steps (*/15). The parser must convert these expressions into a set of valid values for each field, then compute when a job should next run.
Key implementation detail: Python's datetime.weekday() returns Monday=0, but cron uses Sunday=0. You must convert: cron_weekday = (python_weekday + 1) % 7.
Note: The
sortedcontainerslibrary (SortedList) is available. UsingSortedListfor field values enables O(log n) lookup of the next valid value viabisect_left.
Part A: Parse Cron Expression
{{fold}}{Problem: Part A}
Parse a 5-field cron expression into sets of valid values for each field.
cron = CronExpression.parse("*/15 9-17 * * 1-5")
# Internal state after parsing:
# minute: {0, 15, 30, 45} - every 15 minutes
# hour: {9, 10, 11, ..., 17} - 9am to 5pm
# day: {1, 2, ..., 31} - every day
# month: {1, 2, ..., 12} - every month
# weekday: {1, 2, 3, 4, 5} - Monday through Friday
cron2 = CronExpression.parse("0 0 1 * *")
# minute: {0}, hour: {0}, day: {1}, month: {1-12}, weekday: {0-6}
# Runs at midnight on the 1st of each monthSyntax rules:
*= all valid values5= specific value1-5= range (inclusive)1,3,5= list*/15= every 15 starting from min1-10/2= every 2 in range 1-10 (i.e., 1,3,5,7,9)
{{/fold}}
Part B: Calculate Next Run Time
{{fold}}{Problem: Part B}
Given a starting datetime, find the next time the cron expression matches.
cron = CronExpression.parse("0 9 * * 1-5") # 9am on weekdays
next_run = cron.next_run(datetime(2024, 1, 12, 10, 0)) # Friday 10am
# Returns: datetime(2024, 1, 15, 9, 0) # Monday 9am
cron2 = CronExpression.parse("0 0 1 * *") # Midnight on 1st of month
next_run = cron2.next_run(datetime(2024, 1, 15, 12, 0))
# Returns: datetime(2024, 2, 1, 0, 0)The naive approach increments by 1 minute until a match is found. A smarter approach jumps forward field by field (month, day, hour, minute) to avoid iterating through 500k+ minutes per year.
{{/fold}}
Part C: Validation and Combination Syntax
{{fold}}{Problem: Part C}
Add robust validation and support combined syntax like 1-10/2 (every 2nd value in range 1-10).
# Valid expressions
cron = CronExpression.parse("0,30 9-17/2 * * *")
# minute: {0, 30}
# hour: {9, 11, 13, 15, 17} - every 2 hours from 9-17
# Invalid expressions should raise clear errors
try:
CronExpression.parse("60 * * * *") # minute out of range
except ValueError as e:
print(e) # "Out of range in minute: [60] (valid: 0-59)"
try:
CronExpression.parse("* * * *") # wrong number of fields
except ValueError as e:
print(e) # "Need 5 fields, got 4"{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens with
0 0 31 2 *(Feb 31st doesn't exist)? - How do you handle weekday mapping (Python Mon=0, cron Sun=0)?
- What if no valid time exists within a year?
- Does
5/10mean "every 10 starting at 5" or something else?
Common mistakes:
- Weekday mapping error: forgetting Python uses Monday=0, cron uses Sunday=0
- Infinite loop in
next_runif expression can never match (e.g., Feb 30th) - Off-by-one in range parsing:
1-5should include 5 - Not handling step on wildcard:
*/15starts at field minimum, not 0 - Mutating datetime during iteration without advancing past current time
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses an object-oriented approach with separate CronField and CronExpression classes, using naive minute-by-minute iteration for next_run. Solution 2 takes a functional approach with smarter field-by-field jumping to avoid iterating through hundreds of thousands of minutes. Solution 3 focuses on validation with comprehensive error messages, regex-based input checking, and immutable frozen dataclasses. These vary in their approach to finding the next run time (brute force vs smart jumping) and how much validation/error reporting they provide.
Core techniques: field parsing with ranges/steps/wildcards, datetime arithmetic, weekday conversion (Python Mon=0 to cron Sun=0).
Solution 1: Object-oriented with field classes Object-oriented approach with CronField and CronExpression classes. Uses naive minute-by-minute iteration for next_run. Clean separation between parsing and matching logic.
"""Cron Parser - Solution 1: Object-oriented with field classes."""
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import Set
def cron_weekday(dt: datetime) -> int:
"""Convert Python weekday (Mon=0) to cron weekday (Sun=0)."""
return (dt.weekday() + 1) % 7
@dataclass
class CronField:
"""Represents a single cron field with its valid values."""
values: Set[int]
@classmethod
def parse(cls, expr: str, min_val: int, max_val: int) -> "CronField":
values: Set[int] = set()
for part in expr.split(","):
if "/" in part:
base, step = part.split("/")
step_val = int(step)
start = min_val if base == "*" else int(base.split("-")[0])
end = max_val if base == "*" or "-" not in base else int(base.split("-")[1])
values.update(range(start, end + 1, step_val))
elif "-" in part:
start, end = map(int, part.split("-"))
values.update(range(start, end + 1))
elif part == "*":
values.update(range(min_val, max_val + 1))
else:
values.add(int(part))
if not all(min_val <= v <= max_val for v in values):
raise ValueError(f"Values must be in range [{min_val}, {max_val}]")
return cls(values)
@dataclass
class CronExpression:
"""Parsed cron expression with five fields."""
minute: CronField
hour: CronField
day: CronField
month: CronField
weekday: CronField
@classmethod
def parse(cls, expr: str) -> "CronExpression":
parts = expr.strip().split()
if len(parts) != 5:
raise ValueError("Cron expression must have exactly 5 fields")
return cls(
CronField.parse(parts[0], 0, 59), CronField.parse(parts[1], 0, 23),
CronField.parse(parts[2], 1, 31), CronField.parse(parts[3], 1, 12),
CronField.parse(parts[4], 0, 6),
)
def matches(self, dt: datetime) -> bool:
return (dt.minute in self.minute.values and dt.hour in self.hour.values
and dt.day in self.day.values and dt.month in self.month.values
and cron_weekday(dt) in self.weekday.values)
def next_run(self, from_time: datetime) -> datetime:
dt = from_time.replace(second=0, microsecond=0)
for _ in range(366 * 24 * 60):
if self.matches(dt):
return dt
dt += timedelta(minutes=1)
raise ValueError("No valid run time found within one year")Solution 2: Functional approach with smart next_run Functional approach with smarter next_run that jumps by field instead of minute-by-minute. Uses sorted lists for efficient "find next valid value" operations.
"""Cron Parser - Solution 2: Functional approach with smart next_run."""
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import List, Tuple
FIELD_RANGES: List[Tuple[int, int]] = [(0, 59), (0, 23), (1, 31), (1, 12), (0, 6)]
def cron_weekday(dt: datetime) -> int:
"""Convert Python weekday (Mon=0) to cron weekday (Sun=0)."""
return (dt.weekday() + 1) % 7
def parse_field(expr: str, min_val: int, max_val: int) -> List[int]:
"""Parse a single cron field into a sorted list of valid values."""
result = set()
for part in expr.split(","):
if "/" in part:
base, step = part.split("/", 1)
step_int = int(step)
if base == "*":
start, end = min_val, max_val
elif "-" in base:
start, end = map(int, base.split("-", 1))
else:
start, end = int(base), max_val
result.update(range(start, end + 1, step_int))
elif "-" in part:
start, end = map(int, part.split("-", 1))
result.update(range(start, end + 1))
elif part == "*":
result.update(range(min_val, max_val + 1))
else:
result.add(int(part))
if any(v < min_val or v > max_val for v in result):
raise ValueError(f"Values out of range [{min_val}, {max_val}]")
return sorted(result)
@dataclass
class Cron:
"""Cron expression with precomputed valid values for each field."""
minutes: List[int]
hours: List[int]
days: List[int]
months: List[int]
weekdays: List[int]
@classmethod
def parse(cls, expr: str) -> "Cron":
parts = expr.strip().split()
if len(parts) != 5:
raise ValueError(f"Expected 5 fields, got {len(parts)}")
fields = [parse_field(p, r[0], r[1]) for p, r in zip(parts, FIELD_RANGES)]
return cls(*fields)
def _find_next(self, vals: List[int], current: int) -> Tuple[int, bool]:
"""Find next valid value >= current. Returns (value, wrapped)."""
for v in vals:
if v >= current:
return v, False
return vals[0], True
def next_run(self, from_time: datetime) -> datetime:
dt = from_time.replace(second=0, microsecond=0) + timedelta(minutes=1)
for _ in range(366 * 24 * 60):
if dt.month not in self.months:
next_month, wrapped = self._find_next(self.months, dt.month)
dt = datetime(dt.year + (1 if wrapped else 0), next_month, 1, 0, 0)
continue
if dt.day not in self.days or cron_weekday(dt) not in self.weekdays:
dt = (dt + timedelta(days=1)).replace(hour=0, minute=0)
continue
if dt.hour not in self.hours:
next_hour, wrapped = self._find_next(self.hours, dt.hour)
if wrapped:
dt = (dt + timedelta(days=1)).replace(hour=0, minute=0)
else:
dt = dt.replace(hour=next_hour, minute=0)
continue
if dt.minute not in self.minutes:
next_min, wrapped = self._find_next(self.minutes, dt.minute)
dt = dt.replace(minute=0, hour=dt.hour + 1) if wrapped else dt.replace(minute=next_min)
continue
return dt
raise ValueError("No valid time found")Solution 3: Validation-focused with comprehensive error handling Validation-focused approach with comprehensive error messages, regex-based input validation, and immutable frozen dataclass. Includes next_n_runs() utility method.
"""Cron Parser - Solution 3: Validation-focused with comprehensive error handling."""
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import FrozenSet, List
import re
FIELD_SPECS = [("minute", 0, 59), ("hour", 0, 23), ("day", 1, 31),
("month", 1, 12), ("weekday", 0, 6)]
def cron_weekday(dt: datetime) -> int:
"""Convert Python weekday (Mon=0) to cron weekday (Sun=0)."""
return (dt.weekday() + 1) % 7
def validate_and_parse(expr: str, name: str, lo: int, hi: int) -> FrozenSet[int]:
"""Parse field with detailed validation errors."""
if not re.match(r'^[\d,\-\*/]+$', expr):
raise ValueError(f"Invalid characters in {name}: {expr}")
values = set()
for token in expr.split(","):
step = 1
if "/" in token:
token, step_str = token.rsplit("/", 1)
if not step_str.isdigit() or int(step_str) == 0:
raise ValueError(f"Invalid step in {name}: {step_str}")
step = int(step_str)
if token == "*":
values.update(range(lo, hi + 1, step))
elif "-" in token:
parts = token.split("-")
if len(parts) != 2 or not all(p.isdigit() for p in parts):
raise ValueError(f"Invalid range in {name}: {token}")
start, end = int(parts[0]), int(parts[1])
if start > end:
raise ValueError(f"Range start > end in {name}: {start}-{end}")
values.update(range(start, end + 1, step))
else:
if not token.isdigit():
raise ValueError(f"Invalid value in {name}: {token}")
values.add(int(token))
out_of_range = [v for v in values if v < lo or v > hi]
if out_of_range:
raise ValueError(f"Out of range in {name}: {out_of_range} (valid: {lo}-{hi})")
return frozenset(values)
@dataclass(frozen=True)
class CronSchedule:
"""Immutable cron schedule with validation."""
minute: FrozenSet[int] = field(default_factory=frozenset)
hour: FrozenSet[int] = field(default_factory=frozenset)
day: FrozenSet[int] = field(default_factory=frozenset)
month: FrozenSet[int] = field(default_factory=frozenset)
weekday: FrozenSet[int] = field(default_factory=frozenset)
raw: str = ""
@classmethod
def from_string(cls, expr: str) -> "CronSchedule":
parts = expr.strip().split()
if len(parts) != 5:
raise ValueError(f"Need 5 fields, got {len(parts)}: '{expr}'")
parsed = {name: validate_and_parse(parts[i], name, lo, hi)
for i, (name, lo, hi) in enumerate(FIELD_SPECS)}
return cls(**parsed, raw=expr)
def is_valid_time(self, dt: datetime) -> bool:
return (dt.minute in self.minute and dt.hour in self.hour
and dt.day in self.day and dt.month in self.month
and cron_weekday(dt) in self.weekday)
def next_run_after(self, start: datetime) -> datetime:
current = start.replace(second=0, microsecond=0) + timedelta(minutes=1)
for _ in range(366 * 24 * 60):
if self.is_valid_time(current):
return current
current += timedelta(minutes=1)
raise RuntimeError(f"No match within year for: {self.raw}")
def next_n_runs(self, start: datetime, n: int) -> List[datetime]:
runs, current = [], start
for _ in range(n):
current = self.next_run_after(current)
runs.append(current)
return runs{{/fold}}
Question 40 - Library System
- Difficulty: 1 / 10
- Approximate lines of code: 100 LoC
- Tags: storage
Description
A library management system tracks books, users, and loans. Core entities are books (with unique IDs, titles, and status), users, and transactions. The key data structures are dictionaries mapping book_id to Book objects, with each Book containing its current status (available/borrowed/reserved), the current borrower, due date, and a waitlist queue.
The interesting complexity comes from the waitlist: when a borrowed book is returned, it should become reserved for the first person on the waitlist rather than generally available. Late fees require tracking due dates and computing days overdue.
Part A: Checkout and Return
{{fold}}{Problem: Part A}
Implement add_book(), checkout(book_id, user_id), and return_book(book_id). A book can only be checked out if it's available. Return should update status and clear the borrower.
lib = Library()
lib.add_book("B001", "The Great Gatsby")
# Internal state after add:
# books = {"B001": Book(book_id="B001", title="The Great Gatsby",
# status=AVAILABLE, borrower_id=None,
# due_date=None, waitlist=[])}
lib.checkout("B001", "U001") # Returns True
# State: status=BORROWED, borrower_id="U001", due_date=<14 days from now>
lib.checkout("B001", "U002") # Returns False - already borrowed
lib.return_book("B001")
# State: status=AVAILABLE, borrower_id=None, due_date=None{{/fold}}
Part B: Reservations and Waitlist
{{fold}}{Problem: Part B}
Add reserve(book_id, user_id) that adds users to a waitlist. When a book is returned, it should be reserved for the first waitlisted user rather than becoming generally available.
lib.checkout("B001", "U001")
lib.reserve("B001", "U002")
lib.reserve("B001", "U003")
# State: waitlist=["U002", "U003"]
lib.reserve("B001", "U001") # Returns False - can't reserve what you have
lib.reserve("B001", "U002") # Returns False - already on waitlist
lib.return_book("B001")
# State: status=RESERVED, waitlist=["U003"]
# Book is now reserved for U002, not available to general public
lib.checkout("B001", "U003") # Returns False - U002 is first in queue
lib.checkout("B001", "U002") # Returns True - reserved user can checkout
# State: status=BORROWED, borrower_id="U002", waitlist=[]{{/fold}}
Part C: Late Fees
{{fold}}{Problem: Part C}
Track due dates and calculate late fees on return. The fee is typically a daily rate times days overdue.
lib = Library(loan_days=14, daily_late_fee=0.25)
lib.add_book("B001", "Clean Code")
# Checkout on Jan 1, due Jan 15
lib.checkout("B001", "U001", now=datetime(2024, 1, 1))
# Return on Jan 21 (6 days late)
fee = lib.return_book("B001", now=datetime(2024, 1, 21))
assert fee == 6 * 0.25 # $1.50
# Return on time returns 0
lib.checkout("B001", "U002", now=datetime(2024, 1, 22))
fee = lib.return_book("B001", now=datetime(2024, 2, 1)) # 10 days, within 14
assert fee == 0.0{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if a user tries to reserve a book they already have checked out?
- What if someone on the waitlist never picks up their reserved book?
- How do you handle a user trying to checkout a book they're first on the waitlist for?
- What happens if return_book is called on a book that's not borrowed?
Common mistakes:
- Allowing a user to reserve a book they already have
- Not removing user from waitlist when they checkout
- Forgetting to change status to RESERVED (not AVAILABLE) when returning a waitlisted book
- Using floating point for money (should use Decimal or cents)
- Not handling the case where checkout is called on a reserved book by the wrong user
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 is a straightforward OOP approach with Book and Library dataclasses, using an enum for book status and dictionaries for storage. Solution 2 adds an event-driven design with transaction history logging, enabling user history queries and auditing, plus injectable timestamps for testing. Solution 3 takes a functional approach with immutable (frozen) dataclasses and pure functions that return new state, enabling easy testing and undo/redo. The key differences are mutability (mutable objects vs immutable state) and whether operations are logged. Core techniques: state machines for book status, queue management for waitlists, datetime arithmetic for late fees.
Solution 1: Simple OOP Simple OOP approach with Book and Library dataclasses. Uses an enum for book status. Stores everything in dictionaries. Straightforward implementation of all rules.
"""Library System - Solution 1: Simple OOP with dictionaries for storage."""
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from enum import Enum
from typing import Optional
class BookStatus(Enum):
AVAILABLE = "available"
BORROWED = "borrowed"
RESERVED = "reserved"
@dataclass
class Book:
book_id: str
title: str
status: BookStatus = BookStatus.AVAILABLE
borrower_id: Optional[str] = None
due_date: Optional[datetime] = None
waitlist: list[str] = field(default_factory=list)
@dataclass
class Library:
books: dict[str, Book] = field(default_factory=dict)
loan_days: int = 14
daily_late_fee: float = 0.25
def add_book(self, book_id: str, title: str) -> Book:
book = Book(book_id=book_id, title=title)
self.books[book_id] = book
return book
def checkout(self, book_id: str, user_id: str) -> bool:
book = self.books.get(book_id)
if not book or book.status == BookStatus.BORROWED:
return False
if book.status == BookStatus.RESERVED and book.waitlist[0] != user_id:
return False
book.status = BookStatus.BORROWED
book.borrower_id = user_id
book.due_date = datetime.now() + timedelta(days=self.loan_days)
if user_id in book.waitlist:
book.waitlist.remove(user_id)
return True
def return_book(self, book_id: str) -> float:
book = self.books.get(book_id)
if not book or book.status != BookStatus.BORROWED:
return 0.0
late_fee = self.calculate_late_fee(book)
book.borrower_id = None
book.due_date = None
if book.waitlist:
book.status = BookStatus.RESERVED
else:
book.status = BookStatus.AVAILABLE
return late_fee
def reserve(self, book_id: str, user_id: str) -> bool:
book = self.books.get(book_id)
if not book or user_id in book.waitlist or book.borrower_id == user_id:
return False
book.waitlist.append(user_id)
if book.status == BookStatus.AVAILABLE:
book.status = BookStatus.RESERVED
return True
def calculate_late_fee(self, book: Book) -> float:
if not book.due_date or datetime.now() <= book.due_date:
return 0.0
days_late = (datetime.now() - book.due_date).days
return days_late * self.daily_late_fee
if __name__ == "__main__":
lib = Library()
lib.add_book("B001", "The Great Gatsby")
lib.add_book("B002", "1984")
assert lib.checkout("B001", "U001") == True
assert lib.books["B001"].status == BookStatus.BORROWED
assert lib.checkout("B001", "U002") == False # Already borrowed
assert lib.reserve("B001", "U002") == True
assert lib.books["B001"].waitlist == ["U002"]
lib.return_book("B001")
assert lib.books["B001"].status == BookStatus.RESERVED
assert lib.checkout("B001", "U002") == True # Reserved user can checkout
print("Solution 1: All tests passed!")Solution 2: Event-driven with Transaction History Event-driven approach with transaction history. Logs all operations as Transaction objects with timestamps. Enables querying user history and auditing. Accepts optional now parameter for testing.
"""Library System - Solution 2: Event-driven with transaction history."""
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from enum import Enum
from typing import Optional
class EventType(Enum):
CHECKOUT = "checkout"
RETURN = "return"
RESERVE = "reserve"
CANCEL_RESERVATION = "cancel_reservation"
@dataclass
class Transaction:
event_type: EventType
book_id: str
user_id: str
timestamp: datetime
late_fee: float = 0.0
@dataclass
class Book:
book_id: str
title: str
borrower_id: Optional[str] = None
due_date: Optional[datetime] = None
waitlist: list[str] = field(default_factory=list)
@property
def is_available(self) -> bool:
return self.borrower_id is None and not self.waitlist
@property
def is_borrowed(self) -> bool:
return self.borrower_id is not None
@dataclass
class LibrarySystem:
books: dict[str, Book] = field(default_factory=dict)
transactions: list[Transaction] = field(default_factory=list)
loan_days: int = 14
daily_fee: float = 0.25
def add_book(self, book_id: str, title: str) -> None:
self.books[book_id] = Book(book_id=book_id, title=title)
def checkout(self, book_id: str, user_id: str, now: Optional[datetime] = None) -> bool:
now = now or datetime.now()
book = self.books.get(book_id)
if not book or book.is_borrowed:
return False
if book.waitlist and book.waitlist[0] != user_id:
return False
book.borrower_id = user_id
book.due_date = now + timedelta(days=self.loan_days)
if user_id in book.waitlist:
book.waitlist.remove(user_id)
self._log(EventType.CHECKOUT, book_id, user_id, now)
return True
def return_book(self, book_id: str, now: Optional[datetime] = None) -> float:
now = now or datetime.now()
book = self.books.get(book_id)
if not book or not book.is_borrowed:
return 0.0
user_id = book.borrower_id
late_fee = max(0, (now - book.due_date).days) * self.daily_fee if book.due_date else 0.0
book.borrower_id = None
book.due_date = None
self._log(EventType.RETURN, book_id, user_id, now, late_fee)
return late_fee
def reserve(self, book_id: str, user_id: str, now: Optional[datetime] = None) -> bool:
now = now or datetime.now()
book = self.books.get(book_id)
if not book or user_id in book.waitlist or book.borrower_id == user_id:
return False
book.waitlist.append(user_id)
self._log(EventType.RESERVE, book_id, user_id, now)
return True
def get_user_history(self, user_id: str) -> list[Transaction]:
return [t for t in self.transactions if t.user_id == user_id]
def _log(self, event: EventType, book_id: str, user_id: str, ts: datetime, fee: float = 0.0) -> None:
self.transactions.append(Transaction(event, book_id, user_id, ts, fee))
if __name__ == "__main__":
lib = LibrarySystem()
lib.add_book("B001", "Clean Code")
now = datetime(2024, 1, 1)
assert lib.checkout("B001", "U001", now) == True
assert lib.books["B001"].is_borrowed == True
lib.reserve("B001", "U002", now)
assert lib.books["B001"].waitlist == ["U002"]
late_return = now + timedelta(days=20)
fee = lib.return_book("B001", late_return)
assert fee == 6 * 0.25 # 6 days late
assert lib.checkout("B001", "U002", late_return) == True
history = lib.get_user_history("U001")
assert len(history) == 2 # checkout + return
print("Solution 2: All tests passed!")Solution 3: Functional Approach with Immutable State Functional approach with immutable state. Uses frozen dataclasses and pure functions that return new state. Enables easy testing and undo/redo functionality. No side effects.
"""Library System - Solution 3: Functional approach with immutable state."""
from dataclasses import dataclass, replace
from datetime import datetime, timedelta
from typing import Optional
@dataclass(frozen=True)
class BookState:
book_id: str
title: str
borrower_id: Optional[str] = None
due_date: Optional[datetime] = None
waitlist: tuple[str, ...] = ()
@dataclass(frozen=True)
class LibraryState:
books: tuple[BookState, ...] = ()
loan_days: int = 14
daily_fee: float = 0.25
def add_book(state: LibraryState, book_id: str, title: str) -> LibraryState:
new_book = BookState(book_id=book_id, title=title)
return replace(state, books=state.books + (new_book,))
def find_book(state: LibraryState, book_id: str) -> Optional[BookState]:
return next((b for b in state.books if b.book_id == book_id), None)
def update_book(state: LibraryState, updated: BookState) -> LibraryState:
books = tuple(updated if b.book_id == updated.book_id else b for b in state.books)
return replace(state, books=books)
def checkout(state: LibraryState, book_id: str, user_id: str, now: datetime) -> tuple[LibraryState, bool]:
book = find_book(state, book_id)
if not book or book.borrower_id is not None:
return state, False
if book.waitlist and book.waitlist[0] != user_id:
return state, False
waitlist = tuple(u for u in book.waitlist if u != user_id)
updated = replace(book, borrower_id=user_id, due_date=now + timedelta(days=state.loan_days), waitlist=waitlist)
return update_book(state, updated), True
def return_book(state: LibraryState, book_id: str, now: datetime) -> tuple[LibraryState, float]:
book = find_book(state, book_id)
if not book or book.borrower_id is None:
return state, 0.0
fee = 0.0
if book.due_date and now > book.due_date:
fee = (now - book.due_date).days * state.daily_fee
updated = replace(book, borrower_id=None, due_date=None)
return update_book(state, updated), fee
def reserve(state: LibraryState, book_id: str, user_id: str) -> tuple[LibraryState, bool]:
book = find_book(state, book_id)
if not book or user_id in book.waitlist or book.borrower_id == user_id:
return state, False
updated = replace(book, waitlist=book.waitlist + (user_id,))
return update_book(state, updated), True
def get_available_books(state: LibraryState) -> list[BookState]:
return [b for b in state.books if b.borrower_id is None and not b.waitlist]
if __name__ == "__main__":
now = datetime(2024, 1, 1)
state = LibraryState()
state = add_book(state, "B001", "Design Patterns")
state = add_book(state, "B002", "Refactoring")
state, ok = checkout(state, "B001", "U001", now)
assert ok == True
assert find_book(state, "B001").borrower_id == "U001"
state, ok = reserve(state, "B001", "U002")
assert ok == True
assert find_book(state, "B001").waitlist == ("U002",)
late = now + timedelta(days=21)
state, fee = return_book(state, "B001", late)
assert fee == 7 * 0.25
state, ok = checkout(state, "B001", "U002", late)
assert ok == True
available = get_available_books(state)
assert len(available) == 1
assert available[0].book_id == "B002"
print("Solution 3: All tests passed!"){{/fold}}
Question 41 - Write-Ahead Log
- Difficulty: 10 / 10
- Approximate lines of code: 100 LoC
- Tags: storage, distributed-systems
Description
A Write-Ahead Log (WAL) provides durability for databases and storage systems. The core principle: before making any change to data, write a description of the change to a sequential log file and ensure it's on disk (fsync). If the system crashes, replay the log to recover. This is faster than writing data directly because sequential writes are cheaper than random writes.
Key components: (1) log entries with sequence numbers for ordering, (2) fsync calls to guarantee durability (not just flush), (3) checksums to detect partial/corrupted writes, and (4) checkpointing to truncate old entries after they're applied to the main data store.
Part A: Append and Replay
{{fold}}{Problem: Part A}
Implement append(entry) that writes to the log with proper durability and replay() that reads back all entries. Each entry needs a sequence number for ordering.
wal = WriteAheadLog("/path/to/log.wal")
# Append entries (each call fsyncs to disk)
wal.append("SET", "x", 10) # LSN 0
wal.append("SET", "y", 20) # LSN 1
wal.append("DELETE", "x", None) # LSN 2
# Internal log file:
# {"sequence_num": 0, "operation": "SET", "key": "x", "value": 10}
# {"sequence_num": 1, "operation": "SET", "key": "y", "value": 20}
# {"sequence_num": 2, "operation": "DELETE", "key": "x", "value": null}
# Replay for recovery
operations = []
wal.replay(lambda entry: operations.append(entry))
# operations = [Entry(0, SET, x, 10), Entry(1, SET, y, 20), Entry(2, DELETE, x, None)]Critical: flush() is NOT enough for durability. You must call os.fsync(fd) to guarantee data reaches disk.
def append(self, op, key, value):
entry = LogEntry(self._sequence, op, key, value)
self._sequence += 1
self._file.write(json.dumps(entry) + "\n")
self._file.flush() # Push to OS buffer
os.fsync(self._file.fileno()) # Force to disk - THIS IS CRITICAL
return entry{{/fold}}
Part B: Crash Recovery
{{fold}}{Problem: Part B}
Handle partial writes from crashes. If the system crashes mid-write, the last entry may be corrupted or incomplete. Use checksums or length-prefixing to detect and skip bad entries during replay.
# Log file after crash mid-write:
# {"sequence_num": 0, "op": "SET", "key": "x", "value": 10, "crc": 12345}
# {"sequence_num": 1, "op": "SET", "key": "y", "value": 20, "crc": 67890}
# {"sequence_num": 2, "op": "SE <- CORRUPTED (partial write)
def replay(self, apply_fn):
for line in self._file:
try:
entry = parse_entry(line)
if entry.crc != compute_crc(entry):
break # Stop at first corrupted entry
apply_fn(entry)
except (JSONDecodeError, ValueError):
break # Stop at first corrupted entryOperations must be idempotent - replaying the same entry twice should have the same effect as once:
# Idempotent: SET x = 10 (replay twice, x is still 10)
# NOT idempotent: INCREMENT x (replay twice, x increases twice!)
# For non-idempotent ops, track which LSNs have been applied{{/fold}}
Part C: Checkpointing
{{fold}}{Problem: Part C}
After entries are applied to the main data store, they're no longer needed for recovery. Implement checkpoint() that marks a point where all previous entries can be safely truncated.
wal = WriteAheadLog("log.wal")
wal.append("SET", "x", 10) # LSN 0
wal.append("SET", "y", 20) # LSN 1
wal.append("SET", "z", 30) # LSN 2
# Apply entries 0-1 to main data store...
# Now entries 0-1 are durable in main store
wal.checkpoint() # Truncates log, entries 0-2 removed
wal.append("SET", "w", 40) # LSN 0 (sequence resets)
# On recovery, only replay from LSN 0 (the new entry)Critical: don't truncate BEFORE checkpointing! If you truncate and then crash before the main data store is synced, you lose data.
def checkpoint(self):
# Main data store MUST be durable before calling this
self._file.close()
self._file = open(self.log_path, "w+") # Truncate
self._sequence = 0{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What's the difference between flush() and fsync()? (flush pushes to OS, fsync guarantees disk write)
- What if power fails mid-fsync? (File system guarantees atomicity of blocks, but entry might be partial)
- When is it safe to truncate the log? (Only after main data store is synced to disk)
- How would you handle concurrent appends? (Single writer, or use file locks)
Common mistakes:
- Using flush() without fsync() (data still in OS buffer, not durable)
- No sequence numbers (replay order becomes ambiguous)
- Blocking on every write when batching could improve throughput
- Truncating before checkpoint (crash loses data)
- Ignoring partial writes (last entry may be corrupted)
- No checksums (silent corruption undetected)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 is a simple JSON-based WAL using a single file with fsync on every write for durability. Solution 2 uses multiple segment files with automatic rotation when size limits are reached, supporting partial replay from a specific LSN. Solution 3 uses a binary format with struct packing and CRC32 checksums, plus transaction markers (BEGIN/COMMIT/ROLLBACK). These differ in storage format (JSON vs binary), file organization (single vs segmented), and corruption detection (parse errors vs checksums). Core techniques: fsync for durability, sequential file I/O, checksums, log compaction.
Solution 1: Simple JSON-based WAL Simple JSON-based WAL with file-based storage. Entries are JSON lines with sequence numbers. Includes fsync on every write for durability. Basic checkpoint truncates the entire log.
"""
Write-Ahead Log - Solution 1: Simple File-Based WAL
Basic implementation using a single log file with JSON entries.
"""
from dataclasses import dataclass, field
from typing import Any, Callable
import json
import os
@dataclass
class LogEntry:
"""A single entry in the write-ahead log."""
sequence_num: int
operation: str
key: str
value: Any
@dataclass
class WriteAheadLog:
"""Simple file-based write-ahead log implementation."""
log_path: str
sync_on_write: bool = True
_sequence: int = field(default=0, init=False)
_file: Any = field(default=None, init=False)
def __post_init__(self) -> None:
self._file = open(self.log_path, "a+")
self._sequence = self._count_existing_entries()
def _count_existing_entries(self) -> int:
"""Count entries to determine next sequence number."""
self._file.seek(0)
count = sum(1 for line in self._file if line.strip())
self._file.seek(0, 2) # Seek to end
return count
def append(self, operation: str, key: str, value: Any) -> LogEntry:
"""Append an entry to the log before applying changes."""
entry = LogEntry(self._sequence, operation, key, value)
self._sequence += 1
line = json.dumps(vars(entry)) + "\n"
self._file.write(line)
if self.sync_on_write:
self._file.flush()
os.fsync(self._file.fileno())
return entry
def replay(self, apply_fn: Callable[[LogEntry], None]) -> int:
"""Replay all log entries for recovery."""
self._file.seek(0)
count = 0
for line in self._file:
if line.strip():
data = json.loads(line)
entry = LogEntry(**data)
apply_fn(entry)
count += 1
self._file.seek(0, 2)
return count
def checkpoint(self) -> None:
"""Truncate log after successful checkpoint."""
self._file.close()
self._file = open(self.log_path, "w+")
self._sequence = 0
def close(self) -> None:
"""Close the log file."""
if self._file:
self._file.close()Solution 2: Segmented WAL with compaction Segmented WAL with multiple files. When a segment reaches max size, rotates to a new file. Supports partial replay from a specific LSN. Compaction removes segments fully before a checkpoint LSN. More realistic for production systems that need to bound log size.
"""
Write-Ahead Log - Solution 2: Segment-Based WAL
Uses multiple segment files with compaction support.
"""
from dataclasses import dataclass, field
from typing import Any, Callable, Iterator
from pathlib import Path
import json
import os
@dataclass
class LogEntry:
"""A single WAL entry with LSN (Log Sequence Number)."""
lsn: int
op: str
key: str
value: Any
checksum: int = 0
def __post_init__(self) -> None:
if self.checksum == 0:
self.checksum = hash((self.lsn, self.op, self.key, str(self.value)))
@dataclass
class SegmentedWAL:
"""Segmented WAL with configurable segment size and compaction."""
directory: Path
max_segment_size: int = 1024 * 1024 # 1MB default
_current_lsn: int = field(default=0, init=False)
_current_segment: int = field(default=0, init=False)
_current_file: Any = field(default=None, init=False)
_segment_size: int = field(default=0, init=False)
def __post_init__(self) -> None:
self.directory = Path(self.directory)
self.directory.mkdir(parents=True, exist_ok=True)
self._recover_state()
def _segment_path(self, seg_num: int) -> Path:
return self.directory / f"segment_{seg_num:08d}.wal"
def _recover_state(self) -> None:
"""Recover LSN and segment info from existing files."""
segments = sorted(self.directory.glob("segment_*.wal"))
if segments:
self._current_segment = int(segments[-1].stem.split("_")[1])
for entry in self._read_segment(segments[-1]):
self._current_lsn = entry.lsn + 1
self._open_segment()
def _open_segment(self) -> None:
if self._current_file:
self._current_file.close()
path = self._segment_path(self._current_segment)
self._current_file = open(path, "a+")
self._segment_size = path.stat().st_size if path.exists() else 0
def _read_segment(self, path: Path) -> Iterator[LogEntry]:
with open(path, "r") as f:
for line in f:
if line.strip():
yield LogEntry(**json.loads(line))
def append(self, op: str, key: str, value: Any, fsync: bool = True) -> LogEntry:
"""Append entry with optional fsync for durability."""
entry = LogEntry(self._current_lsn, op, key, value)
self._current_lsn += 1
data = json.dumps(vars(entry)) + "\n"
if self._segment_size + len(data) > self.max_segment_size:
self._rotate_segment()
self._current_file.write(data)
self._segment_size += len(data)
if fsync:
self._current_file.flush()
os.fsync(self._current_file.fileno())
return entry
def _rotate_segment(self) -> None:
self._current_segment += 1
self._open_segment()
def replay(self, apply_fn: Callable[[LogEntry], None], from_lsn: int = 0) -> int:
"""Replay entries starting from given LSN."""
count = 0
for seg_path in sorted(self.directory.glob("segment_*.wal")):
for entry in self._read_segment(seg_path):
if entry.lsn >= from_lsn:
apply_fn(entry)
count += 1
return count
def compact(self, checkpoint_lsn: int) -> None:
"""Remove segments fully before checkpoint LSN."""
self._current_file.close()
for seg_path in sorted(self.directory.glob("segment_*.wal")):
max_lsn = max((e.lsn for e in self._read_segment(seg_path)), default=-1)
if max_lsn < checkpoint_lsn:
seg_path.unlink()
self._open_segment()
def close(self) -> None:
if self._current_file:
self._current_file.close()Solution 3: Binary format with CRC checksums Binary format WAL with CRC32 checksums for corruption detection. Uses struct packing for efficient storage. Supports transaction markers (BEGIN/COMMIT/ROLLBACK). Low-level file descriptor operations for precise control over durability.
"""
Write-Ahead Log - Solution 3: Binary Format with CRC
Production-style WAL with binary encoding and checksums.
"""
from dataclasses import dataclass, field
from typing import Any, Callable
from enum import IntEnum
import struct
import zlib
import pickle
import os
class OpType(IntEnum):
SET = 1
DELETE = 2
BEGIN_TX = 3
COMMIT = 4
ROLLBACK = 5
@dataclass
class WALEntry:
"""Binary WAL entry with CRC32 checksum."""
lsn: int
op: OpType
key: bytes
value: bytes
crc: int = 0
# Header: LSN(8) + OP(1) + KEY_LEN(4) + VAL_LEN(4) + CRC(4) = 21 bytes
HEADER_FORMAT = "<QBII I"
HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
def serialize(self) -> bytes:
"""Serialize entry to bytes with CRC."""
payload = self.key + self.value
crc = zlib.crc32(payload)
header = struct.pack(
self.HEADER_FORMAT,
self.lsn, self.op, len(self.key), len(self.value), crc
)
return header + payload
@classmethod
def deserialize(cls, data: bytes, offset: int = 0) -> tuple["WALEntry", int]:
"""Deserialize entry from bytes, returns entry and bytes consumed."""
lsn, op, key_len, val_len, crc = struct.unpack_from(cls.HEADER_FORMAT, data, offset)
start = offset + cls.HEADER_SIZE
key = data[start:start + key_len]
value = data[start + key_len:start + key_len + val_len]
if zlib.crc32(key + value) != crc:
raise ValueError(f"CRC mismatch at LSN {lsn}")
entry = cls(lsn, OpType(op), key, value, crc)
return entry, cls.HEADER_SIZE + key_len + val_len
@dataclass
class BinaryWAL:
"""Binary WAL with CRC checksums for corruption detection."""
path: str
_lsn: int = field(default=0, init=False)
_fd: int = field(default=-1, init=False)
def __post_init__(self) -> None:
flags = os.O_RDWR | os.O_CREAT
self._fd = os.open(self.path, flags, 0o644)
self._recover_lsn()
def _recover_lsn(self) -> None:
"""Scan file to find highest LSN."""
data = self._read_all()
offset = 0
while offset < len(data):
try:
entry, consumed = WALEntry.deserialize(data, offset)
self._lsn = entry.lsn + 1
offset += consumed
except (struct.error, ValueError):
break
def _read_all(self) -> bytes:
os.lseek(self._fd, 0, os.SEEK_SET)
chunks = []
while chunk := os.read(self._fd, 8192):
chunks.append(chunk)
return b"".join(chunks)
def append(self, op: OpType, key: Any, value: Any, sync: bool = True) -> WALEntry:
"""Append entry with optional fsync."""
key_bytes = pickle.dumps(key)
val_bytes = pickle.dumps(value) if value is not None else b""
entry = WALEntry(self._lsn, op, key_bytes, val_bytes)
self._lsn += 1
os.lseek(self._fd, 0, os.SEEK_END)
os.write(self._fd, entry.serialize())
if sync:
os.fsync(self._fd)
return entry
def replay(self, apply_fn: Callable[[WALEntry], None]) -> int:
"""Replay all valid entries."""
data = self._read_all()
offset, count = 0, 0
while offset < len(data):
try:
entry, consumed = WALEntry.deserialize(data, offset)
apply_fn(entry)
offset += consumed
count += 1
except (struct.error, ValueError):
break
return count
def truncate(self) -> None:
"""Truncate log (checkpoint)."""
os.ftruncate(self._fd, 0)
self._lsn = 0
def close(self) -> None:
if self._fd >= 0:
os.close(self._fd)
self._fd = -1{{/fold}}
Question 42 - ID Generator
- Difficulty: 2 / 10
- Approximate lines of code: 120 LoC
- Tags: distributed-systems
Description
A Snowflake-style ID generator produces globally unique 64-bit IDs without coordination between machines. Twitter invented this pattern to generate tweet IDs at scale. The key insight is packing three components into 64 bits: a timestamp (for ordering), a machine ID (for uniqueness across nodes), and a sequence number (for uniqueness within the same millisecond). The standard layout uses 41 bits for timestamp, 10 bits for machine ID (1024 machines), and 12 bits for sequence (4096 IDs per millisecond per machine).
Internal state consists of: the last timestamp seen, the current sequence number within that millisecond, and the machine ID. When generating an ID, if the current time equals the last timestamp, increment the sequence; if sequence overflows, wait for the next millisecond. If time has moved forward, reset sequence to 0.
Part A: Basic ID Generation
{{fold}}{Problem: Part A}
Implement a thread-safe ID generator with generate() -> int. Each ID must be unique and roughly time-ordered. Pack timestamp, machine_id, and sequence into a 64-bit integer using bit shifting.
# Example usage and internal state
gen = SnowflakeIDGenerator(machine_id=42)
# State: last_timestamp=-1, sequence=0, machine_id=42
id1 = gen.generate() # timestamp=1704067200000, sequence=0
# State: last_timestamp=1704067200000, sequence=0
# Returns: (1704067200000 << 22) | (42 << 12) | 0
id2 = gen.generate() # Same millisecond
# State: last_timestamp=1704067200000, sequence=1
# Returns: (1704067200000 << 22) | (42 << 12) | 1
assert id1 < id2 # IDs are ordered{{/fold}}
Part B: Sequence Overflow and Clock Skew
{{fold}}{Problem: Part B}
Handle two edge cases:
- Sequence overflow: If 4096 IDs are generated in one millisecond, wait for the next millisecond before continuing.
- Clock skew: If the system clock moves backwards (NTP correction, VM migration), either raise an error or wait for time to catch up.
gen = SnowflakeIDGenerator(machine_id=1)
# Simulate generating 4096 IDs in same millisecond
for i in range(4096):
gen.generate()
# State: sequence=4095
# Next generate() must wait for next millisecond
id_next = gen.generate() # Blocks until timestamp advances
# State: last_timestamp=1704067200001, sequence=0
# Clock moves backwards
# Option 1: Raise RuntimeError("Clock moved backwards by Xms")
# Option 2: Wait until time >= last_timestamp{{/fold}}
Part C: ID Decoding and Coordination
{{fold}}{Problem: Part C}
Add parse_id(id) -> {timestamp_ms, machine_id, sequence} to decode components from an ID. Discuss how machines would coordinate to get unique machine IDs (ZooKeeper, database sequence, configuration).
gen = SnowflakeIDGenerator(machine_id=7)
id1 = gen.generate()
parsed = gen.parse_id(id1)
# Returns: {"timestamp_ms": 1704067200000, "machine_id": 7, "sequence": 0}
# Decoding uses bit masks and shifts:
sequence = id1 & 0xFFF # Low 12 bits
machine_id = (id1 >> 12) & 0x3FF # Next 10 bits
timestamp = (id1 >> 22) + EPOCH # High 41 bits + epoch{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if generate() is called from multiple threads simultaneously?
- What if the machine ID is out of range (negative or > 1023)?
- What if the system clock jumps forward by years (timestamp overflow)?
- How would you handle a datacenter-level ID collision if machine IDs are misconfigured?
Common mistakes:
- Not using a lock (race condition between reading timestamp and incrementing sequence)
- Forgetting to wait when sequence overflows (generates duplicate IDs)
- Using floating point for timestamps (precision loss)
- Allowing negative machine IDs or IDs > max value
- Not handling clock skew at all (silent ID collision)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 provides a basic thread-safe implementation with dataclass configuration and RuntimeError on clock skew. Solution 2 adds clock skew tolerance by waiting instead of failing, plus ID parsing and injectable time functions for testing. Solution 3 introduces batch ID generation for efficiency and an immutable SnowflakeID dataclass with comparison operators. The key differences are in how they handle clock skew (fail vs wait) and whether they support batch operations. Core techniques: bit shifting/masking, thread synchronization with locks, busy-waiting for sequence overflow.
Solution 1: Basic Implementation Basic implementation with all core functionality. Uses a dataclass for config, validates machine ID, and handles sequence overflow by busy-waiting. Raises RuntimeError on clock skew.
"""
Snowflake-style ID Generator - Solution 1: Basic Implementation
64-bit ID structure:
- 1 bit: unused (sign bit)
- 41 bits: timestamp (milliseconds since epoch)
- 10 bits: machine ID (0-1023)
- 12 bits: sequence number (0-4095)
"""
import time
import threading
from dataclasses import dataclass
@dataclass
class SnowflakeConfig:
epoch: int = 1704067200000 # 2024-01-01 00:00:00 UTC in milliseconds
machine_id_bits: int = 10
sequence_bits: int = 12
timestamp_bits: int = 41
class SnowflakeIDGenerator:
def __init__(self, machine_id: int, config: SnowflakeConfig | None = None):
self.config = config or SnowflakeConfig()
self._validate_machine_id(machine_id)
self.machine_id = machine_id
self.sequence = 0
self.last_timestamp = -1
self.lock = threading.Lock()
# Precompute masks and shifts
self.max_sequence = (1 << self.config.sequence_bits) - 1
self.machine_id_shift = self.config.sequence_bits
self.timestamp_shift = self.config.sequence_bits + self.config.machine_id_bits
def _validate_machine_id(self, machine_id: int) -> None:
max_machine_id = (1 << self.config.machine_id_bits) - 1
if not 0 <= machine_id <= max_machine_id:
raise ValueError(f"Machine ID must be between 0 and {max_machine_id}")
def _current_timestamp(self) -> int:
return int(time.time() * 1000)
def _wait_for_next_millisecond(self, last_ts: int) -> int:
ts = self._current_timestamp()
while ts <= last_ts:
ts = self._current_timestamp()
return ts
def generate(self) -> int:
with self.lock:
timestamp = self._current_timestamp()
# Handle clock skew (clock moved backwards)
if timestamp < self.last_timestamp:
raise RuntimeError(
f"Clock moved backwards by {self.last_timestamp - timestamp}ms"
)
if timestamp == self.last_timestamp:
self.sequence = (self.sequence + 1) & self.max_sequence
if self.sequence == 0:
# Sequence overflow, wait for next millisecond
timestamp = self._wait_for_next_millisecond(self.last_timestamp)
else:
self.sequence = 0
self.last_timestamp = timestamp
relative_ts = timestamp - self.config.epoch
return (
(relative_ts << self.timestamp_shift) |
(self.machine_id << self.machine_id_shift) |
self.sequence
)
if __name__ == "__main__":
gen = SnowflakeIDGenerator(machine_id=1)
# Test uniqueness
ids = [gen.generate() for _ in range(1000)]
assert len(ids) == len(set(ids)), "IDs must be unique"
# Test ordering
assert ids == sorted(ids), "IDs must be ordered"
# Test ID structure
sample_id = ids[0]
assert sample_id > 0, "ID must be positive"
assert sample_id.bit_length() <= 64, "ID must fit in 64 bits"
print(f"Generated {len(ids)} unique, ordered IDs")
print(f"Sample ID: {sample_id} (binary length: {sample_id.bit_length()} bits)")
print("All tests passed!")Solution 2: With Clock Skew Tolerance Adds clock skew tolerance by waiting instead of failing (up to a configurable limit). Includes a parse_id method to decode IDs back to components. Accepts an injectable time function for testing.
"""
Snowflake-style ID Generator - Solution 2: With Clock Skew Tolerance
Handles clock skew by waiting or borrowing from the future within tolerance.
"""
import time
import threading
from dataclasses import dataclass, field
from typing import Callable
@dataclass
class IDGeneratorConfig:
epoch_ms: int = 1704067200000 # 2024-01-01 UTC
machine_bits: int = 10
sequence_bits: int = 12
max_clock_skew_ms: int = 5000 # Tolerate up to 5 seconds of clock drift
@dataclass
class GeneratorState:
last_timestamp: int = -1
sequence: int = 0
class RobustIDGenerator:
def __init__(
self,
machine_id: int,
config: IDGeneratorConfig | None = None,
time_fn: Callable[[], int] | None = None,
):
self.config = config or IDGeneratorConfig()
self.machine_id = self._validate_and_get_machine_id(machine_id)
self.state = GeneratorState()
self.lock = threading.Lock()
self._time_fn = time_fn or (lambda: int(time.time() * 1000))
self.max_sequence = (1 << self.config.sequence_bits) - 1
self.max_machine_id = (1 << self.config.machine_bits) - 1
self.machine_shift = self.config.sequence_bits
self.timestamp_shift = self.config.sequence_bits + self.config.machine_bits
def _validate_and_get_machine_id(self, machine_id: int) -> int:
max_id = (1 << self.config.machine_bits) - 1
if not 0 <= machine_id <= max_id:
raise ValueError(f"Machine ID must be 0-{max_id}, got {machine_id}")
return machine_id
def _handle_clock_skew(self, current_ts: int, last_ts: int) -> int:
skew = last_ts - current_ts
if skew > self.config.max_clock_skew_ms:
raise RuntimeError(f"Clock skew {skew}ms exceeds tolerance")
# Wait for clock to catch up
time.sleep(skew / 1000.0)
return self._time_fn()
def generate(self) -> int:
with self.lock:
current_ts = self._time_fn()
if current_ts < self.state.last_timestamp:
current_ts = self._handle_clock_skew(
current_ts, self.state.last_timestamp
)
if current_ts == self.state.last_timestamp:
self.state.sequence = (self.state.sequence + 1) & self.max_sequence
if self.state.sequence == 0:
while current_ts <= self.state.last_timestamp:
current_ts = self._time_fn()
else:
self.state.sequence = 0
self.state.last_timestamp = current_ts
relative_ts = current_ts - self.config.epoch_ms
return (
(relative_ts << self.timestamp_shift) |
(self.machine_id << self.machine_shift) |
self.state.sequence
)
def parse_id(self, id_value: int) -> dict:
"""Decode an ID back into its components."""
sequence = id_value & self.max_sequence
machine = (id_value >> self.machine_shift) & self.max_machine_id
timestamp = (id_value >> self.timestamp_shift) + self.config.epoch_ms
return {"timestamp_ms": timestamp, "machine_id": machine, "sequence": sequence}
if __name__ == "__main__":
gen = RobustIDGenerator(machine_id=42)
ids = [gen.generate() for _ in range(500)]
assert len(ids) == len(set(ids)), "IDs must be unique"
assert all(ids[i] < ids[i + 1] for i in range(len(ids) - 1)), "IDs must be ordered"
parsed = gen.parse_id(ids[0])
assert parsed["machine_id"] == 42, "Machine ID must match"
print(f"Parsed first ID: {parsed}")
# Test with custom time function (simulated clock)
fake_time = [1704067200000]
gen2 = RobustIDGenerator(machine_id=1, time_fn=lambda: fake_time[0])
id1 = gen2.generate()
id2 = gen2.generate()
assert id1 < id2, "Sequence should increment"
print(f"Generated {len(ids)} unique ordered IDs")
print("All tests passed!")Solution 3: Async-Ready with Batch Generation Adds batch ID generation for efficiency (generate multiple IDs while holding the lock once). Includes an immutable SnowflakeID dataclass that supports comparison operations.
"""
Snowflake-style ID Generator - Solution 3: Async-Ready with Batch Generation
Features batch ID generation and async-compatible design.
"""
import time
import threading
from dataclasses import dataclass
from typing import Iterator
@dataclass(frozen=True)
class SnowflakeID:
"""Immutable ID with parsed components."""
value: int
timestamp_ms: int
machine_id: int
sequence: int
def __int__(self) -> int:
return self.value
def __lt__(self, other: "SnowflakeID") -> bool:
return self.value < other.value
class BatchIDGenerator:
EPOCH = 1704067200000 # 2024-01-01 UTC
MACHINE_BITS = 10
SEQUENCE_BITS = 12
MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1
MAX_MACHINE_ID = (1 << MACHINE_BITS) - 1
MACHINE_SHIFT = SEQUENCE_BITS
TIMESTAMP_SHIFT = SEQUENCE_BITS + MACHINE_BITS
def __init__(self, machine_id: int):
if not 0 <= machine_id <= self.MAX_MACHINE_ID:
raise ValueError(f"Machine ID must be 0-{self.MAX_MACHINE_ID}")
self.machine_id = machine_id
self._sequence = 0
self._last_ts = -1
self._lock = threading.Lock()
def _get_time_ms(self) -> int:
return int(time.time() * 1000)
def _next_timestamp(self) -> int:
ts = self._get_time_ms()
while ts <= self._last_ts:
ts = self._get_time_ms()
return ts
def _build_id(self, timestamp: int, sequence: int) -> int:
relative_ts = timestamp - self.EPOCH
return (
(relative_ts << self.TIMESTAMP_SHIFT) |
(self.machine_id << self.MACHINE_SHIFT) |
sequence
)
def generate(self) -> int:
with self._lock:
ts = self._get_time_ms()
if ts < self._last_ts:
raise RuntimeError(f"Clock regression: {self._last_ts - ts}ms")
if ts == self._last_ts:
self._sequence = (self._sequence + 1) & self.MAX_SEQUENCE
if self._sequence == 0:
ts = self._next_timestamp()
else:
self._sequence = 0
self._last_ts = ts
return self._build_id(ts, self._sequence)
def generate_batch(self, count: int) -> list[int]:
"""Generate multiple IDs efficiently."""
if count <= 0:
return []
with self._lock:
ids = []
ts = self._get_time_ms()
for _ in range(count):
if ts < self._last_ts:
raise RuntimeError("Clock regression detected")
if ts == self._last_ts:
self._sequence = (self._sequence + 1) & self.MAX_SEQUENCE
if self._sequence == 0:
ts = self._next_timestamp()
else:
self._sequence = 0
self._last_ts = ts
ids.append(self._build_id(ts, self._sequence))
return ids
def parse(self, id_value: int) -> SnowflakeID:
"""Parse an ID into its components."""
seq = id_value & self.MAX_SEQUENCE
machine = (id_value >> self.MACHINE_SHIFT) & self.MAX_MACHINE_ID
ts = (id_value >> self.TIMESTAMP_SHIFT) + self.EPOCH
return SnowflakeID(value=id_value, timestamp_ms=ts, machine_id=machine, sequence=seq)
if __name__ == "__main__":
gen = BatchIDGenerator(machine_id=7)
# Single generation test
id1 = gen.generate()
id2 = gen.generate()
assert id1 < id2, "IDs must be monotonically increasing"
# Batch generation test
batch = gen.generate_batch(100)
assert len(batch) == 100, "Batch size must match"
assert len(set(batch)) == 100, "All IDs in batch must be unique"
assert batch == sorted(batch), "Batch IDs must be ordered"
assert all(b > id2 for b in batch), "Batch IDs must be greater than previous"
# Parse test
parsed = gen.parse(batch[50])
assert parsed.machine_id == 7, "Machine ID must match"
assert parsed.sequence >= 0, "Sequence must be non-negative"
print(f"Parsed ID: {parsed}")
# SnowflakeID comparison
sf1 = gen.parse(batch[0])
sf2 = gen.parse(batch[1])
assert sf1 < sf2, "SnowflakeID comparison must work"
print(f"Generated {len(batch) + 2} unique ordered IDs")
print("All tests passed!"){{/fold}}
Question 43 - Sudoku Solver
- Difficulty: 4 / 10
- Approximate lines of code: 80 LoC
- Tags: algorithms, game/simulation
Description
A Sudoku solver fills in a 9x9 grid such that each row, column, and 3x3 box contains the digits 1-9 exactly once. This is a classic constraint satisfaction problem solved with backtracking: try a value, check if it violates constraints, recurse or backtrack. The naive approach tries all values 1-9 for each empty cell, but optimizations like MRV (Minimum Remaining Values) and constraint propagation dramatically reduce the search space.
The core data structures are: (1) a 9x9 grid with 0 representing empty cells, and (2) constraint tracking (which values are used in each row, column, and box). The box index for cell (r, c) is computed as 3 * (r // 3) + c // 3.
Part A: Basic Backtracking Solver
{{fold}}{Problem: Part A}
Implement a solver using simple backtracking. Find an empty cell, try values 1-9, check validity, and recurse. Backtrack when no valid value exists.
puzzle = [
[5, 3, 0, 0, 7, 0, 0, 0, 0],
[6, 0, 0, 1, 9, 5, 0, 0, 0],
[0, 9, 8, 0, 0, 0, 0, 6, 0],
[8, 0, 0, 0, 6, 0, 0, 0, 3],
[4, 0, 0, 8, 0, 3, 0, 0, 1],
[7, 0, 0, 0, 2, 0, 0, 0, 6],
[0, 6, 0, 0, 0, 0, 2, 8, 0],
[0, 0, 0, 4, 1, 9, 0, 0, 5],
[0, 0, 0, 0, 8, 0, 0, 7, 9],
]
board = SudokuBoard(puzzle)
solutions = solve(board)
# solutions[0] is the completed grid with all 0s filled in
# Validity check for cell (0, 2) with value 4:
# Row 0: [5, 3, _, _, 7, _, _, _, _] - no 4, OK
# Col 2: [_, _, 8, _, _, _, _, _, _] - no 4, OK
# Box 0: [5, 3, _], [6, _, _], [_, 9, 8] - no 4, OK{{/fold}}
Part B: MRV Heuristic (Minimum Remaining Values)
{{fold}}{Problem: Part B}
Instead of picking the first empty cell, pick the cell with the fewest valid candidates. This prunes the search tree earlier - if a cell has only one valid option, fill it immediately.
# Before MRV: always pick first empty cell (0, 2)
# Candidates for (0, 2): {1, 2, 4} - 3 options
# With MRV: find cell with minimum candidates
# Cell (0, 5): {8} - only 1 option! Fill it immediately.
# Cell (1, 1): {2, 4, 7} - 3 options
# Cell (2, 0): {1, 2} - 2 options
# MRV picks (0, 5) first - fewer branches to explore
solver = SudokuSolver(puzzle)
cell = solver.find_best_cell() # Returns cell with minimum candidates
# If any cell has 0 candidates, puzzle is unsolvable from this state{{/fold}}
Part C: Find All Solutions / Constraint Propagation
{{fold}}{Problem: Part C}
Extend to find all solutions (some puzzles have multiple). Add constraint propagation: when you place a value, immediately eliminate it from candidates in the same row, column, and box. If any cell becomes empty (no candidates), backtrack early.
# Finding all solutions
solver = SudokuSolver(puzzle_with_multiple_solutions)
all_solutions = solver.solve(find_all=True)
print(f"Found {len(all_solutions)} solutions")
# Constraint propagation when placing 5 at (0, 0):
# Before: candidates[0][1] = {5, 7, 8}
# After: candidates[0][1] = {7, 8} # 5 eliminated (same row)
# Early termination: if candidates[r][c] becomes empty set,
# this branch is unsolvable - backtrack immediately{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if the input puzzle is already invalid (duplicate in row/col/box)?
- What if the puzzle has no solution?
- How do you handle a completely empty grid? (Many solutions)
- How do you restore state when backtracking?
Common mistakes:
- Box index calculation:
3 * (row // 3) + col // 3- easy to get wrong - Not restoring grid state when backtracking
- Checking validity after placement instead of before
- Shallow copy vs deep copy when saving state for backtracking
- Off-by-one: checking column with row loop variable
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 implements basic backtracking with validity checking, finding the first empty cell and trying values 1-9. Solution 2 adds constraint propagation and the MRV (Minimum Remaining Values) heuristic, maintaining candidate sets for each cell. Solution 3 uses bitmask-based constraint tracking for O(1) validity checks with bit manipulation. The key difference is how constraints are tracked and checked: iterative validation vs candidate sets vs bitmasks. Core techniques: backtracking with state restoration, box index formula (3*(r//3) + c//3), MRV heuristic, bitwise operations for constraint masks.
Solution 1: Basic backtracking Basic backtracking with validity checking. find_empty() returns first empty cell. is_valid_placement() checks row, column, and 3x3 box constraints. Supports finding all solutions via flag.
"""Sudoku Solver - Solution 1: Basic Backtracking with Constraint Checking"""
from dataclasses import dataclass
from typing import Optional
@dataclass
class SudokuBoard:
grid: list[list[int]] # 0 represents empty cell
def is_valid_placement(self, row: int, col: int, num: int) -> bool:
"""Check if placing num at (row, col) is valid."""
# Check row
if num in self.grid[row]:
return False
# Check column
if num in (self.grid[r][col] for r in range(9)):
return False
# Check 3x3 box
box_row, box_col = 3 * (row // 3), 3 * (col // 3)
for r in range(box_row, box_row + 3):
for c in range(box_col, box_col + 3):
if self.grid[r][c] == num:
return False
return True
def find_empty(self) -> Optional[tuple[int, int]]:
"""Find the next empty cell (contains 0)."""
for r in range(9):
for c in range(9):
if self.grid[r][c] == 0:
return (r, c)
return None
def is_valid_board(self) -> bool:
"""Validate current board state has no conflicts."""
for r in range(9):
for c in range(9):
if self.grid[r][c] != 0:
num = self.grid[r][c]
self.grid[r][c] = 0 # Temporarily remove
valid = self.is_valid_placement(r, c, num)
self.grid[r][c] = num # Restore
if not valid:
return False
return True
def solve(board: SudokuBoard, find_all: bool = False) -> list[list[list[int]]]:
"""Solve sudoku using backtracking. Returns list of solutions."""
solutions: list[list[list[int]]] = []
def backtrack() -> bool:
empty = board.find_empty()
if empty is None:
solutions.append([row[:] for row in board.grid])
return not find_all # Stop if only finding one
row, col = empty
for num in range(1, 10):
if board.is_valid_placement(row, col, num):
board.grid[row][col] = num
if backtrack():
return True
board.grid[row][col] = 0
return False
if not board.is_valid_board():
return []
backtrack()
return solutionsSolution 2: Constraint propagation with MRV Backtracking with constraint propagation and MRV heuristic. Maintains a candidates grid (sets of possible values for each cell). When a value is placed, it's eliminated from all peers. find_best_cell() returns the cell with minimum candidates.
"""Sudoku Solver - Solution 2: Backtracking with Constraint Propagation"""
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class SudokuSolver:
grid: list[list[int]]
candidates: list[list[set[int]]] = field(init=False)
def __post_init__(self) -> None:
self.candidates = [[set(range(1, 10)) for _ in range(9)] for _ in range(9)]
self._initialize_constraints()
def _initialize_constraints(self) -> None:
"""Remove candidates based on initial board state."""
for r in range(9):
for c in range(9):
if self.grid[r][c] != 0:
self.candidates[r][c] = set()
self._eliminate(r, c, self.grid[r][c])
def _eliminate(self, row: int, col: int, num: int) -> None:
"""Remove num from candidates in same row, column, and box."""
for c in range(9):
self.candidates[row][c].discard(num)
for r in range(9):
self.candidates[r][col].discard(num)
box_r, box_c = 3 * (row // 3), 3 * (col // 3)
for r in range(box_r, box_r + 3):
for c in range(box_c, box_c + 3):
self.candidates[r][c].discard(num)
def is_valid(self) -> bool:
"""Check if board is still solvable (no empty cells with no candidates)."""
for r in range(9):
for c in range(9):
if self.grid[r][c] == 0 and len(self.candidates[r][c]) == 0:
return False
return True
def find_best_cell(self) -> Optional[tuple[int, int]]:
"""Find empty cell with minimum remaining candidates (MRV heuristic)."""
best, min_count = None, 10
for r in range(9):
for c in range(9):
if self.grid[r][c] == 0 and len(self.candidates[r][c]) < min_count:
best, min_count = (r, c), len(self.candidates[r][c])
return best
def solve(self, find_all: bool = False) -> list[list[list[int]]]:
"""Solve using backtracking with constraint propagation."""
solutions: list[list[list[int]]] = []
def backtrack() -> bool:
cell = self.find_best_cell()
if cell is None:
solutions.append([row[:] for row in self.grid])
return not find_all
row, col = cell
saved_candidates = [row[:] for row in self.candidates]
for num in list(self.candidates[row][col]):
self.grid[row][col] = num
self.candidates[row][col] = set()
self._eliminate(row, col, num)
if self.is_valid() and backtrack():
return True
self.grid[row][col] = 0
self.candidates = [r[:] for r in saved_candidates]
return False
backtrack()
return solutionsSolution 3: Bitmask-based constraint tracking Bitmask-based constraint tracking for O(1) validity checks. Uses three arrays of 9-bit integers (rows, cols, boxes) where bit N is set if value N is used. get_candidates() computes valid values via bitwise OR and complement. Most efficient for large numbers of solve attempts.
"""Sudoku Solver - Solution 3: Bitmask-based Constraint Tracking"""
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class BitSudoku:
grid: list[list[int]]
rows: list[int] = field(default_factory=list) # Bitmask of used numbers per row
cols: list[int] = field(default_factory=list) # Bitmask of used numbers per column
boxes: list[int] = field(default_factory=list) # Bitmask of used numbers per 3x3 box
_valid: bool = True
@classmethod
def from_grid(cls, grid: list[list[int]]) -> "BitSudoku":
rows, cols, boxes = [0] * 9, [0] * 9, [0] * 9
valid = True
for r in range(9):
for c in range(9):
if grid[r][c] != 0:
bit = 1 << grid[r][c]
box_idx = 3 * (r // 3) + c // 3
# Check for conflicts before adding
if (rows[r] | cols[c] | boxes[box_idx]) & bit:
valid = False
rows[r] |= bit
cols[c] |= bit
boxes[box_idx] |= bit
result = cls([row[:] for row in grid], rows, cols, boxes, valid)
return result
def get_candidates(self, r: int, c: int) -> list[int]:
"""Get valid candidates for cell using bitmasks."""
used = self.rows[r] | self.cols[c] | self.boxes[3 * (r // 3) + c // 3]
return [n for n in range(1, 10) if not (used & (1 << n))]
def find_mrv_cell(self) -> Optional[tuple[int, int, list[int]]]:
"""Find empty cell with minimum remaining values."""
best: Optional[tuple[int, int, list[int]]] = None
for r in range(9):
for c in range(9):
if self.grid[r][c] == 0:
cands = self.get_candidates(r, c)
if not cands:
return (r, c, []) # Early exit: unsolvable
if best is None or len(cands) < len(best[2]):
best = (r, c, cands)
return best
def place(self, r: int, c: int, num: int) -> None:
bit = 1 << num
self.grid[r][c] = num
self.rows[r] |= bit
self.cols[c] |= bit
self.boxes[3 * (r // 3) + c // 3] |= bit
def remove(self, r: int, c: int, num: int) -> None:
bit = 1 << num
self.grid[r][c] = 0
self.rows[r] ^= bit
self.cols[c] ^= bit
self.boxes[3 * (r // 3) + c // 3] ^= bit
def solve(self, find_all: bool = False) -> list[list[list[int]]]:
if not self._valid:
return []
solutions: list[list[list[int]]] = []
def backtrack() -> bool:
cell = self.find_mrv_cell()
if cell is None:
solutions.append([row[:] for row in self.grid])
return not find_all
r, c, candidates = cell
if not candidates:
return False
for num in candidates:
self.place(r, c, num)
if backtrack():
return True
self.remove(r, c, num)
return False
backtrack()
return solutions{{/fold}}
Question 44 - Circuit Breaker
- Difficulty: 9 / 10
- Approximate lines of code: 80 LoC
- Tags: distributed-systems
Description
The circuit breaker pattern prevents cascading failures when calling unreliable external services. Instead of repeatedly hammering a failing service, the circuit breaker "trips" after detecting failures and fails fast for a cooldown period. This protects both your system (avoiding blocked threads waiting for timeouts) and the downstream service (giving it time to recover).
The pattern uses a three-state machine: CLOSED (normal operation, tracking failures), OPEN (failing fast, rejecting all calls), and HALF-OPEN (testing if the service recovered). The key data structures are failure counters/timestamps and the current state. The state transitions lazily on each call attempt rather than via background timers.
Part A: Basic State Machine
{{fold}}{Problem: Part A}
Implement a circuit breaker with three states and count-based tripping. After N consecutive failures in CLOSED state, trip to OPEN. In OPEN, reject calls immediately with a CircuitOpenError. After a timeout period elapses, transition to HALF-OPEN and allow one probe call through. If it succeeds, go to CLOSED. If it fails, go back to OPEN.
cb = CircuitBreaker(failure_threshold=3, recovery_timeout=30.0)
# Normal operation (CLOSED)
result = cb.call(lambda: external_service()) # Works normally
# After 3 consecutive failures, circuit trips to OPEN
for _ in range(3):
try:
cb.call(lambda: raise_error())
except ServiceError:
pass
# Internal state: _state=OPEN, _failure_count=3, _last_failure_time=<now>
# Now calls fail fast without invoking the function
cb.call(lambda: external_service()) # Raises CircuitOpenError immediately
# After recovery_timeout seconds, state becomes HALF_OPEN on next call attempt
# One successful call transitions back to CLOSED{{/fold}}
Part B: Rate-Based Thresholds
{{fold}}{Problem: Part B}
Instead of counting consecutive failures, trip when the failure rate exceeds a threshold within a sliding time window. This is more robust for high-traffic services where a few scattered failures are acceptable. Track calls in a deque with (timestamp, success) tuples. Only evaluate the rate after min_calls have been made to avoid tripping on startup noise.
cb = CircuitBreaker(
failure_rate_threshold=0.5, # 50% failure rate
window_size=60.0, # 60 second sliding window
min_calls=10, # Need at least 10 calls before evaluating
recovery_timeout=30.0
)
# Internal state tracks recent calls:
# _calls = deque([
# (1704067200.0, True), # success
# (1704067201.0, False), # failure
# (1704067202.0, True), # success
# ...
# ])
# _failure_rate() prunes old calls, then computes:
# failures = sum(1 for _, success in _calls if not success)
# rate = failures / len(_calls)
# In HALF_OPEN, require multiple successful calls before closing
# (single success could be a fluke){{/fold}}
Part C: Thread Safety and Metrics
{{fold}}{Problem: Part C}
Make the circuit breaker thread-safe and add state transition callbacks for observability. Use locks around state mutations and the call tracking data structures. Callbacks fire on CLOSED->OPEN, OPEN->HALF_OPEN, and HALF_OPEN->CLOSED transitions.
cb = CircuitBreaker(
failure_threshold=5,
recovery_timeout=30.0,
on_state_change=lambda old, new: metrics.emit(f"circuit.{new}")
)
# Thread-safe usage from multiple concurrent requests
def handle_request():
try:
return cb.call(lambda: downstream_service())
except CircuitOpenError:
return fallback_response(){{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What happens if the test call in HALF_OPEN fails? (Should go back to OPEN, not CLOSED)
- Do you reset failure count on success in CLOSED state? (Yes, otherwise one success after 2 failures doesn't reset)
- What time function do you use? (
time.monotonic()nottime.time()to avoid clock jumps) - How do you handle the exception after recording the failure? (Must re-raise it)
Common mistakes:
- Forgetting to re-raise exceptions after recording failure
- Not resetting failure count on success in CLOSED state
- Using
time.time()instead oftime.monotonic()(system clock can jump backwards) - State transition check only in dedicated method, not lazily on call attempt
- In rate-based: not having a minimum call threshold before evaluating rate
- In HALF_OPEN: transitioning to CLOSED after just one success (should test multiple times)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solution 1 uses a simple count-based approach with consecutive failure tracking. Solution 2 implements sliding window rate-based tripping using a deque of timestamped call results. Solution 3 employs the State pattern with explicit state classes for each circuit state. The key difference is how they detect failures: fixed count vs. failure rate percentage, and how they structure state transitions: implicit property-based vs. explicit state objects.
Core techniques: state machine, sliding window, decorator pattern, lazy evaluation.
Solution 1: Simple count-based implementation Simple count-based implementation using a dataclass. State is checked lazily via a property that transitions OPEN->HALF_OPEN when timeout expires. Uses consecutive failure counting with reset on success.
"""
Circuit Breaker Pattern - Solution 1: Simple Count-Based Implementation
Uses a fixed failure count threshold to trip the circuit.
"""
from dataclasses import dataclass, field
from enum import Enum
from typing import Callable, TypeVar
import time
T = TypeVar("T")
class State(Enum):
CLOSED = "closed" # Normal operation
OPEN = "open" # Failing, reject all calls
HALF_OPEN = "half_open" # Testing if service recovered
@dataclass
class CircuitBreaker:
failure_threshold: int = 5
recovery_timeout: float = 30.0
_state: State = field(default=State.CLOSED, init=False)
_failure_count: int = field(default=0, init=False)
_last_failure_time: float = field(default=0.0, init=False)
@property
def state(self) -> State:
if self._state == State.OPEN:
if time.time() - self._last_failure_time >= self.recovery_timeout:
self._state = State.HALF_OPEN
return self._state
def call(self, func: Callable[[], T]) -> T:
if self.state == State.OPEN:
raise CircuitOpenError("Circuit is open")
try:
result = func()
self._on_success()
return result
except Exception as e:
self._on_failure()
raise e
def _on_success(self) -> None:
self._failure_count = 0
self._state = State.CLOSED
def _on_failure(self) -> None:
self._failure_count += 1
self._last_failure_time = time.time()
if self._failure_count >= self.failure_threshold:
self._state = State.OPEN
class CircuitOpenError(Exception):
passSolution 2: Sliding window rate-based implementation Sliding window rate-based implementation. Stores calls in a deque with timestamps and success flags. Prunes old calls outside the window before calculating failure rate. Requires minimum calls before evaluating and multiple successes in HALF_OPEN.
"""
Circuit Breaker Pattern - Solution 2: Sliding Window Rate-Based
Uses a time-based sliding window to calculate failure rate.
"""
from dataclasses import dataclass, field
from enum import Enum
from typing import Callable, TypeVar
from collections import deque
import time
T = TypeVar("T")
class State(Enum):
CLOSED = "closed"
OPEN = "open"
HALF_OPEN = "half_open"
@dataclass
class CircuitBreaker:
failure_rate_threshold: float = 0.5 # 50% failure rate
window_size: float = 60.0 # 60 second window
min_calls: int = 5 # Minimum calls before tripping
recovery_timeout: float = 30.0
half_open_max_calls: int = 3 # Calls to test in half-open
_state: State = field(default=State.CLOSED, init=False)
_calls: deque = field(default_factory=deque, init=False) # (timestamp, success)
_opened_at: float = field(default=0.0, init=False)
_half_open_successes: int = field(default=0, init=False)
@property
def state(self) -> State:
if self._state == State.OPEN:
if time.time() - self._opened_at >= self.recovery_timeout:
self._state = State.HALF_OPEN
self._half_open_successes = 0
return self._state
def _prune_old_calls(self) -> None:
cutoff = time.time() - self.window_size
while self._calls and self._calls[0][0] < cutoff:
self._calls.popleft()
def _failure_rate(self) -> float:
self._prune_old_calls()
if len(self._calls) < self.min_calls:
return 0.0
failures = sum(1 for _, success in self._calls if not success)
return failures / len(self._calls)
def call(self, func: Callable[[], T]) -> T:
if self.state == State.OPEN:
raise CircuitOpenError("Circuit is open")
try:
result = func()
self._record_success()
return result
except Exception as e:
self._record_failure()
raise e
def _record_success(self) -> None:
now = time.time()
if self._state == State.HALF_OPEN:
self._half_open_successes += 1
if self._half_open_successes >= self.half_open_max_calls:
self._state = State.CLOSED
self._calls.clear()
else:
self._calls.append((now, True))
def _record_failure(self) -> None:
now = time.time()
if self._state == State.HALF_OPEN:
self._state = State.OPEN
self._opened_at = now
else:
self._calls.append((now, False))
if self._failure_rate() >= self.failure_rate_threshold:
self._state = State.OPEN
self._opened_at = now
class CircuitOpenError(Exception):
passSolution 3: State pattern implementation State pattern implementation with explicit state classes. Each state (ClosedState, OpenState, HalfOpenState) handles calls differently. Also provides decorator interfaces for protecting functions.
"""
Circuit Breaker Pattern - Solution 3: State Pattern with Decorators
Uses explicit state classes and provides a decorator interface.
"""
from dataclasses import dataclass
from abc import ABC, abstractmethod
from typing import Callable, TypeVar
from functools import wraps
import time
T = TypeVar("T")
class CircuitOpenError(Exception):
pass
class CircuitState(ABC):
@abstractmethod
def handle_call(self, breaker: "CircuitBreaker", func: Callable[[], T]) -> T:
pass
class ClosedState(CircuitState):
def handle_call(self, breaker: "CircuitBreaker", func: Callable[[], T]) -> T:
try:
result = func()
breaker.failure_count = 0
return result
except Exception as e:
breaker.failure_count += 1
breaker.last_failure_time = time.time()
if breaker.failure_count >= breaker.failure_threshold:
breaker.transition_to(OpenState())
raise e
class OpenState(CircuitState):
def handle_call(self, breaker: "CircuitBreaker", func: Callable[[], T]) -> T:
if time.time() - breaker.last_failure_time >= breaker.recovery_timeout:
breaker.transition_to(HalfOpenState())
return breaker.call(func)
raise CircuitOpenError("Circuit is open")
class HalfOpenState(CircuitState):
def handle_call(self, breaker: "CircuitBreaker", func: Callable[[], T]) -> T:
try:
result = func()
breaker.failure_count = 0
breaker.transition_to(ClosedState())
return result
except Exception as e:
breaker.last_failure_time = time.time()
breaker.transition_to(OpenState())
raise e
@dataclass
class CircuitBreaker:
failure_threshold: int = 5
recovery_timeout: float = 30.0
def __post_init__(self) -> None:
self._state: CircuitState = ClosedState()
self.failure_count: int = 0
self.last_failure_time: float = 0.0
@property
def state_name(self) -> str:
return self._state.__class__.__name__.replace("State", "").lower()
def transition_to(self, state: CircuitState) -> None:
self._state = state
def call(self, func: Callable[[], T]) -> T:
return self._state.handle_call(self, func)
def protect(self, func: Callable[..., T]) -> Callable[..., T]:
"""Decorator to protect a function with this circuit breaker."""
@wraps(func)
def wrapper(*args, **kwargs) -> T:
return self.call(lambda: func(*args, **kwargs))
return wrapper
def circuit_breaker(
failure_threshold: int = 5,
recovery_timeout: float = 30.0
) -> CallableCallable[..., T, Callable[..., T]]:
"""Standalone decorator that creates a circuit breaker per function."""
breaker = CircuitBreaker(failure_threshold, recovery_timeout)
def decorator(func: Callable[..., T]) -> Callable[..., T]:
@wraps(func)
def wrapper(*args, **kwargs) -> T:
return breaker.call(lambda: func(*args, **kwargs))
wrapper.circuit_breaker = breaker # type: ignore
return wrapper
return decorator{{/fold}}
Question 45 - Load Balancer
- Difficulty: 8 / 10
- Approximate lines of code: 90 LoC
- Tags: distributed-systems, scheduling
Description
A load balancer distributes incoming requests across multiple backend servers to improve throughput and availability. Different strategies optimize for different goals: round-robin ensures even distribution, least-connections routes to the server with the lightest current load, and weighted distribution gives more traffic to higher-capacity servers.
Internally, you track a list of servers with their health status and connection counts. The core operation is route_request() which selects a server based on the current strategy, increments its connection count, and returns it. When the request completes, release_connection() decrements the count.
Part A: Round Robin
{{fold}}{Problem: Part A}
Implement round-robin load balancing that cycles through healthy servers in order. Maintain an index that advances on each request. Skip unhealthy servers.
lb = LoadBalancer(strategy=RoundRobin())
lb.add_server(Server("A"))
lb.add_server(Server("B"))
lb.add_server(Server("C"))
# Internal state:
# servers: [A, B, C], all healthy
# rr_index: 0
lb.route_request() # Returns Server A, index -> 1
lb.route_request() # Returns Server B, index -> 2
lb.route_request() # Returns Server C, index -> 0 (wraps)
lb.route_request() # Returns Server A, index -> 1
lb.set_health("B", False)
lb.route_request() # Skips B, returns A or C based on current index{{/fold}}
Part B: Least Connections
{{fold}}{Problem: Part B}
Implement least-connections routing that always selects the healthy server with the fewest active connections. Track connection counts, incrementing on route and decrementing on release.
lb = LoadBalancer(strategy=LeastConnections())
lb.add_server(Server("X", active_connections=5))
lb.add_server(Server("Y", active_connections=2))
lb.add_server(Server("Z", active_connections=8))
# Internal state:
# X: 5 connections, Y: 2 connections, Z: 8 connections
lb.route_request() # Returns Y (fewest: 2), Y now has 3
lb.route_request() # Returns Y again (still fewest: 3), Y now has 4
lb.route_request() # Returns Y (4), Y now has 5
lb.route_request() # Returns X or Y (tied at 5)
lb.release_connection("Y") # Y back to 4{{/fold}}
Part C: Health Checks and Weighted Distribution
{{fold}}{Problem: Part C}
Add health status tracking - unhealthy servers should never receive requests. Implement weighted distribution where servers with higher weights receive proportionally more traffic.
lb = LoadBalancer(strategy=Weighted())
lb.add_server(Server("heavy", weight=3))
lb.add_server(Server("light", weight=1))
# Over 8 requests, "heavy" should get ~6, "light" should get ~2
# (3:1 ratio based on weights)
results = [lb.route_request().id for _ in range(8)]
# Results like: ["heavy", "heavy", "heavy", "light", "heavy", "heavy", "heavy", "light"]
# Health check filtering
lb.set_health("heavy", False)
lb.route_request() # Only "light" available, always returns it{{/fold}}
Interview comments
{{fold}}{Interview comments}
Edge cases to probe:
- What if all servers are unhealthy? (Return None or raise exception)
- What happens to round-robin index when a server is removed? (May skip or wrap incorrectly)
- What if weighted servers have weight 0? (Should never be selected)
- What about negative connection counts from buggy release calls? (Clamp to 0)
Common mistakes:
- Round-robin index overflow or incorrect modulo after server removal
- Not filtering unhealthy servers before selection
- Forgetting to increment connection count on route
- Weighted distribution that doesn't actually respect ratios (often reset logic is wrong)
- Checking health at wrong time (should check at selection time, not add time)
{{/fold}}
Code solutions
{{fold}}{Code solutions}
Solutions Overview
Solution 1 uses the Strategy pattern with separate classes for RoundRobin, LeastConnections, and Weighted routing. Solution 2 takes a functional approach with enums and a dispatch dictionary, using itertools.cycle for round-robin. Solution 3 is a direct implementation with explicit methods per strategy and optional callback support. These vary in their design patterns: OOP polymorphism vs functional dispatch vs simple methods. Core techniques: strategy pattern, modulo cycling, min-heap selection, weighted round-robin.
Solution 1: Strategy Pattern Object-oriented approach with Strategy pattern. Defines a RoutingStrategy protocol with separate classes for RoundRobin, LeastConnections, and Weighted. Clean separation of concerns.
"""Load Balancer - Solution 1: Object-Oriented with Strategy Pattern"""
from dataclasses import dataclass, field
from typing import Protocol, Optional
from abc import abstractmethod
@dataclass
class Server:
id: str
weight: int = 1
is_healthy: bool = True
active_connections: int = 0
class RoutingStrategy(Protocol):
@abstractmethod
def select_server(self, servers: list[Server]) -> Optional[Server]: ...
@dataclass
class RoundRobinStrategy:
_index: int = 0
def select_server(self, servers: list[Server]) -> Optional[Server]:
healthy = [s for s in servers if s.is_healthy]
if not healthy:
return None
server = healthy[self._index % len(healthy)]
self._index = (self._index + 1) % len(healthy)
return server
@dataclass
class LeastConnectionsStrategy:
def select_server(self, servers: list[Server]) -> Optional[Server]:
healthy = [s for s in servers if s.is_healthy]
if not healthy:
return None
return min(healthy, key=lambda s: s.active_connections)
@dataclass
class WeightedStrategy:
_counter: dict[str, int] = field(default_factory=dict)
def select_server(self, servers: list[Server]) -> Optional[Server]:
healthy = [s for s in servers if s.is_healthy]
if not healthy:
return None
for s in healthy:
if s.id not in self._counter:
self._counter[s.id] = 0
selected = max(healthy, key=lambda s: s.weight - self._counter[s.id])
self._counter[selected.id] += 1
total_weight = sum(s.weight for s in healthy)
if all(self._counter.get(s.id, 0) >= s.weight for s in healthy):
self._counter = {s.id: 0 for s in healthy}
return selected
@dataclass
class LoadBalancer:
strategy: RoutingStrategy
servers: list[Server] = field(default_factory=list)
def add_server(self, server: Server) -> None:
self.servers.append(server)
def remove_server(self, server_id: str) -> bool:
for i, s in enumerate(self.servers):
if s.id == server_id:
self.servers.pop(i)
return True
return False
def set_health(self, server_id: str, is_healthy: bool) -> None:
for s in self.servers:
if s.id == server_id:
s.is_healthy = is_healthy
return
def route_request(self) -> Optional[Server]:
server = self.strategy.select_server(self.servers)
if server:
server.active_connections += 1
return server
def release_connection(self, server_id: str) -> None:
for s in self.servers:
if s.id == server_id and s.active_connections > 0:
s.active_connections -= 1
returnSolution 2: Functional with Enum Dispatch Functional approach using an enum for strategy selection and a dispatch dictionary. Uses itertools.cycle for round-robin. All routing logic is methods on the LoadBalancer class.
"""Load Balancer - Solution 2: Functional approach with enums"""
from dataclasses import dataclass, field
from enum import Enum, auto
from typing import Optional, Callable
from itertools import cycle
class Strategy(Enum):
ROUND_ROBIN = auto()
LEAST_CONNECTIONS = auto()
WEIGHTED = auto()
@dataclass
class Server:
id: str
weight: int = 1
is_healthy: bool = True
active_connections: int = 0
@dataclass
class LoadBalancer:
strategy: Strategy
_servers: dict[str, Server] = field(default_factory=dict)
_rr_cycle: Optional[cycle] = field(default=None, repr=False)
_weight_tracker: dict[str, int] = field(default_factory=dict)
def add_server(self, server: Server) -> None:
self._servers[server.id] = server
self._reset_rr_cycle()
def remove_server(self, server_id: str) -> bool:
if server_id in self._servers:
del self._servers[server_id]
self._weight_tracker.pop(server_id, None)
self._reset_rr_cycle()
return True
return False
def set_health(self, server_id: str, is_healthy: bool) -> None:
if server_id in self._servers:
self._servers[server_id].is_healthy = is_healthy
self._reset_rr_cycle()
def _reset_rr_cycle(self) -> None:
healthy = self._get_healthy_servers()
self._rr_cycle = cycle(healthy) if healthy else None
def _get_healthy_servers(self) -> list[Server]:
return [s for s in self._servers.values() if s.is_healthy]
def _select_round_robin(self, healthy: list[Server]) -> Optional[Server]:
if not self._rr_cycle:
return None
for _ in range(len(self._servers)):
server = next(self._rr_cycle)
if server.is_healthy:
return server
return None
def _select_least_connections(self, healthy: list[Server]) -> Optional[Server]:
return min(healthy, key=lambda s: s.active_connections) if healthy else None
def _select_weighted(self, healthy: list[Server]) -> Optional[Server]:
if not healthy:
return None
for s in healthy:
self._weight_tracker.setdefault(s.id, 0)
selected = max(healthy, key=lambda s: s.weight - self._weight_tracker[s.id])
self._weight_tracker[selected.id] += 1
if all(self._weight_tracker[s.id] >= s.weight for s in healthy):
self._weight_tracker = {s.id: 0 for s in healthy}
return selected
def route_request(self) -> Optional[Server]:
healthy = self._get_healthy_servers()
if not healthy:
return None
selectors: dict[Strategy, Callable] = {
Strategy.ROUND_ROBIN: self._select_round_robin,
Strategy.LEAST_CONNECTIONS: self._select_least_connections,
Strategy.WEIGHTED: self._select_weighted,
}
server = selectors[self.strategy](healthy)
if server:
server.active_connections += 1
return server
def release_connection(self, server_id: str) -> None:
if server_id in self._servers:
s = self._servers[server_id]
s.active_connections = max(0, s.active_connections - 1)Solution 3: Direct Methods with Callbacks Simple direct implementation with explicit method for each strategy. Uses heapq.nsmallest for least-connections. Includes optional callback support for routing events.
"""Load Balancer - Solution 3: Simple, direct implementation with callbacks"""
from dataclasses import dataclass, field
from typing import Optional, Callable
import heapq
@dataclass
class Server:
id: str
weight: int = 1
is_healthy: bool = True
active_connections: int = 0
def __lt__(self, other: "Server") -> bool:
return self.active_connections < other.active_connections
@dataclass
class LoadBalancer:
_servers: list[Server] = field(default_factory=list)
_rr_index: int = 0
_weight_remaining: dict[str, int] = field(default_factory=dict)
_on_route: Optional[Callable[[Server], None]] = None
def add_server(self, server: Server) -> None:
self._servers.append(server)
self._weight_remaining[server.id] = server.weight
def remove_server(self, server_id: str) -> bool:
for i, s in enumerate(self._servers):
if s.id == server_id:
self._servers.pop(i)
self._weight_remaining.pop(server_id, None)
return True
return False
def set_health(self, server_id: str, healthy: bool) -> None:
for s in self._servers:
if s.id == server_id:
s.is_healthy = healthy
break
def _healthy(self) -> list[Server]:
return [s for s in self._servers if s.is_healthy]
def round_robin(self) -> Optional[Server]:
healthy = self._healthy()
if not healthy:
return None
self._rr_index %= len(healthy)
server = healthy[self._rr_index]
self._rr_index = (self._rr_index + 1) % len(healthy)
return server
def least_connections(self) -> Optional[Server]:
healthy = self._healthy()
if not healthy:
return None
return heapq.nsmallest(1, healthy)[0]
def weighted(self) -> Optional[Server]:
healthy = self._healthy()
if not healthy:
return None
for s in healthy:
if s.id not in self._weight_remaining or self._weight_remaining[s.id] <= 0:
self._weight_remaining[s.id] = s.weight
if all(self._weight_remaining.get(s.id, 0) <= 0 for s in healthy):
for s in healthy:
self._weight_remaining[s.id] = s.weight
best = max(healthy, key=lambda s: self._weight_remaining.get(s.id, 0))
self._weight_remaining[best.id] -= 1
return best
def route(self, strategy: str) -> Optional[Server]:
strategies = {
"round_robin": self.round_robin,
"least_connections": self.least_connections,
"weighted": self.weighted,
}
server = strategies[strategy]()
if server:
server.active_connections += 1
if self._on_route:
self._on_route(server)
return server
def release(self, server_id: str) -> None:
for s in self._servers:
if s.id == server_id:
s.active_connections = max(0, s.active_connections - 1)
break{{/fold}}