Zoox Software Engineer Phone Screen Questions

## Problem Design a cost estimation engine for a platform that offers multiple services (e.g., compute, storage, network). Each service has its own pricing rules. The engine must support adding new service types without modifying existing code. ```python from abc import ABC, abstractmethod class ServicePricer(ABC): @abstractmethod def estimate(self, usage: dict) -> float: pass class ComputePricer(ServicePricer): # $0.05/hour per vCPU, $0.01/GB-hour RAM def estimate(self, usage: dict) -> float: # usage: {"vcpus": int, "ram_gb": float, "hours": float} pass class StoragePricer(ServicePricer): # $0.023/GB-month def estimate(self, usage: dict) -> float: pass class CostEstimator: def add_service(self, name: str, pricer: ServicePricer) -> None: ... def total_cost(self, usages: dict[str, dict]) -> float: ... ``` ``` ce = CostEstimator() ce.add_service("compute", ComputePricer()) ce.add_service("storage", StoragePricer()) ce.total_cost({"compute": {"vcpus":4,"ram_gb":16,"hours":720}, "storage": {"gb":100}}) -> (4*0.05 + 16*0.01)*720 + 100*0.023 = ... ``` ## Follow-ups 1. Which design pattern does this use, and why is it appropriate here? 2. How would you add tiered pricing (first 100 GB at rate A, next at rate B) cleanly? 3. How do you handle currency conversion if services are priced in different currencies? 4. How would you add a discount system without modifying the `ServicePricer` interface?

## Problem Design a `LaneController` for a highway with `n` lanes. Vehicles enter and exit lanes. Each lane has a capacity. Support queries for the lane with the most available space, merging two adjacent lanes, and reporting congestion alerts when any lane exceeds 80% capacity. ```python class LaneController: def __init__(self, n: int, capacity_per_lane: int): ... def vehicle_enter(self, lane: int) -> bool: """Add vehicle to lane. Return False if at capacity.""" ... def vehicle_exit(self, lane: int) -> bool: """Remove vehicle from lane. Return False if lane is empty.""" ... def most_available_lane(self) -> int: """Return lane index with the most free space.""" ... def merge_lanes(self, lane_a: int, lane_b: int) -> None: """Merge two adjacent lanes into one with combined capacity.""" ... def get_congestion_alerts(self) -> list[int]: """Return list of lane indices exceeding 80% capacity.""" ... ``` ``` lc = LaneController(3, 10) lc.vehicle_enter(0) # 7 times lc.get_congestion_alerts() -> [0] # 7/10 = 70%? No, 8/10=80% triggers. ``` ## Follow-ups 1. How does a priority queue help with `most_available_lane` if lanes update frequently? 2. How do you handle `merge_lanes` when vehicles must be redistributed? 3. How would you make this thread-safe for concurrent highway simulations? 4. Extend to support per-vehicle-type restrictions (e.g., lane 0 for trucks only).

## Problem Design the core class structure for a turn-based RPG battle system. Characters take turns attacking, using abilities, or defending. Each ability has a cooldown. A character is defeated when HP drops to 0. ```python class Character: def __init__(self, name: str, hp: int, attack: int, defense: int): ... def take_damage(self, amount: int) -> int: """Return actual damage after defense.""" def is_alive(self) -> bool: ... def use_ability(self, ability_name: str, target: 'Character') -> str: ... class Ability: def __init__(self, name: str, damage: int, cooldown: int): ... def is_ready(self) -> bool: ... def activate(self) -> None: ... def tick(self) -> None: """Called each turn to reduce cooldown.""" class BattleSystem: def __init__(self, team1: list[Character], team2: list[Character]): ... def next_turn(self) -> str: """Execute one turn, return action log.""" def is_battle_over(self) -> bool: ... def winner(self) -> str | None: ... ``` ``` battle = BattleSystem([warrior], [mage]) while not battle.is_battle_over(): print(battle.next_turn()) print(battle.winner()) ``` ## Follow-ups 1. How would you implement a status effect system (poison, stun) cleanly without modifying the `Character` class? 2. How do you ensure ability cooldowns are tracked correctly across multi-character teams? 3. How would you serialize and restore battle state for a save/load feature? 4. Extend to support items that any character can use on their turn.