Elevator System

Introduction

In this comprehensive case study, we’ll design an Elevator System from scratch using the systematic 8-step approach. This is a classic LLD interview problem that demonstrates state management, concurrent processing, and multiple design patterns working together.

Why This Problem?

Elevator System is perfect for learning LLD because it involves:

• State Management - Elevator behavior changes based on state (idle, moving up, moving down)
• Multiple Design Patterns - State, Observer, Strategy patterns
• Concurrency - Multiple elevators and requests handled simultaneously
• Real-world Complexity - Smart dispatching, request queuing, thread safety

---

Problem Statement

Design an Elevator System for a high-rise building that can:

• Support multiple elevators, each serving all floors
• Enforce capacity constraints (max people per elevator)
• Handle two types of requests: external (from floor buttons) and internal (from inside elevator)
• Intelligently dispatch requests to minimize waiting time
• Process multiple requests per elevator efficiently
• Handle concurrent requests from multiple users safely

---

Step 1: Clarify Requirements

Before designing, let’s ask the right questions!

Clarifying Questions

Functional Requirements:

1. Elevator Count: How many elevators? → Multiple, configurable
2. Floors: How many floors? → All elevators serve all floors
3. Capacity: Maximum people per elevator? → Yes, configurable per elevator
4. Request Types: External (floor buttons) and internal (inside elevator)? → Yes, both
5. Dispatching: How to choose elevator? → Based on direction, distance, load
6. Request Processing: Process requests in order? → Yes, optimize for efficiency

Non-Functional Requirements:

1. Concurrency: Multiple simultaneous requests? → Yes, thread-safe operations needed
2. Performance: Response time expectations? → Fast dispatch, minimal waiting
3. Scalability: How many requests? → Handle hundreds of requests

Edge Cases to Consider:

• What if all elevators are busy?
• What if elevator is at capacity?
• What if request comes while elevator is moving?
• What if multiple elevators are equidistant?
• What if elevator breaks down?

Requirements Summary

---

Step 2: Identify Actors

Actors are external entities that interact with the system.

Who Uses This System?

Primary Actors:

1. User/Passenger - Requests elevator from floor, selects destination inside elevator
2. Maintenance Staff - (Future) Monitors system health, performs maintenance
3. Building Management - (Future) Configures system parameters, sets capacity

Secondary Actors:

• Emergency System - (Future) Triggers emergency stops
• Monitoring System - (Future) Tracks usage, performance metrics

Actor Interactions

Actor vs Entity

Actors are external users/systems that interact with your system. Entities are internal objects managed by the system. In this case:

• Passenger (Actor) uses ElevatorSystem (Entity)
• Elevator is an Entity, not an Actor (it’s part of the system)
• Request is an Entity (represents passenger’s intent)

---

Step 3: Identify Entities

Entities are core objects in your system that have data and behavior.

The Noun Hunt

Looking at the requirements, we identify these core entities:

1. ElevatorSystem - Main orchestrator, dispatches requests
2. Elevator - Individual elevator car with state and requests
3. Request - Represents a floor request (external or internal)
4. ElevatorState - Abstract state (Idle, MovingUp, MovingDown)
5. Display - Shows elevator status to users
6. Direction - Enum for movement direction

Entity Relationships

---

Step 4: Assign Responsibilities

Each class should have a single, well-defined responsibility (SRP).

Responsibility Assignment

ElevatorSystem:

• Manage collection of elevators
• Dispatch requests to appropriate elevator
• Use strategy to select best elevator
• Coordinate elevator operations

Elevator:

• Manage its own state (idle, moving up, moving down)
• Process requests in its queue
• Move between floors
• Notify observers of state changes

ElevatorState:

• Define behavior for specific state
• Handle request addition based on state
• Control movement logic
• Transition to other states when appropriate

Request:

• Store request information (floor, direction, source)
• Provide request details to elevator

Display:

• Observe elevator state changes
• Update display information
• Show current floor and direction

Responsibility Visualization

[Single Responsibility Principle](/design-principles/solid-principles/00-single-responsibility-principle)

Each class should have one reason to change. For example:

• Elevator changes only when elevator logic changes
• ElevatorState changes only when state behavior changes
• Display changes only when display format changes
• ElevatorSystem changes only when dispatching logic changes

---

Step 5: Design Class Diagrams

Class diagrams show structure, relationships, and design patterns.

Complete Class Diagram

classDiagram
    class ElevatorSystem {
        -ElevatorSystem instance
        -Map~Integer,Elevator~ elevators
        -ElevatorSelectionStrategy selectionStrategy
        -ExecutorService executorService
        +getInstance() ElevatorSystem
        +addElevator(Elevator) void
        +requestElevator(int, Direction) void
        +setSelectionStrategy(ElevatorSelectionStrategy) void
    }
    
    class Elevator {
        -int id
        -AtomicInteger currentFloor
        -ElevatorState state
        -TreeSet~Integer~ upRequests
        -TreeSet~Integer~ downRequests
        -List~ElevatorObserver~ observers
        -boolean isRunning
        +addObserver(ElevatorObserver) void
        +addRequest(Request) void
        +move() void
        +run() void
        +notifyObservers() void
        +setState(ElevatorState) void
    }
    
    class ElevatorState {
        <<interface>>
        +addRequest(Elevator, Request) void
        +move(Elevator) void
        +getDirection() Direction
    }
    
    class IdleState {
        +addRequest(Elevator, Request) void
        +move(Elevator) void
        +getDirection() Direction
    }
    
    class MovingUpState {
        +addRequest(Elevator, Request) void
        +move(Elevator) void
        +getDirection() Direction
    }
    
    class MovingDownState {
        +addRequest(Elevator, Request) void
        +move(Elevator) void
        +getDirection() Direction
    }
    
    class Request {
        -int targetFloor
        -RequestSource source
        -Direction direction
        +getTargetFloor() int
        +getDirection() Direction
    }
    
    class ElevatorObserver {
        <<interface>>
        +update(Elevator) void
    }
    
    class Display {
        +update(Elevator) void
    }
    
    class ElevatorSelectionStrategy {
        <<interface>>
        +selectElevator(List~Elevator~, Request) Optional~Elevator~
    }
    
    class NearestElevatorStrategy {
        +selectElevator(List~Elevator~, Request) Optional~Elevator~
    }
    
    class RequestSource {
        <<enumeration>>
        INTERNAL
        EXTERNAL
    }
    
    class Direction {
        <<enumeration>>
        UP
        DOWN
        IDLE
    }
    
    ElevatorSystem "1" *-- "many" Elevator : contains
    ElevatorSystem --> ElevatorSelectionStrategy : uses
    Elevator --> ElevatorState : has-a
    Elevator --> Request : processes
    Elevator --> ElevatorObserver : notifies
    ElevatorState <|.. IdleState
    ElevatorState <|.. MovingUpState
    ElevatorState <|.. MovingDownState
    ElevatorObserver <|.. Display
    ElevatorSelectionStrategy <|.. NearestElevatorStrategy
    Request --> RequestSource : has
    Request --> Direction : has

Design Patterns Used

1. State Pattern - ElevatorState hierarchy

• Encapsulates behavior for each state (idle, moving up, moving down)
• Eliminates complex if-else chains
• Easy to add new states (e.g., EmergencyState)

2. Observer Pattern - ElevatorObserver

• Decouples elevator from display/notification systems
• Multiple observers can track elevator state
• Easy to add new observers (audio, logging, mobile app)

3. Strategy Pattern - ElevatorSelectionStrategy

• Encapsulates elevator selection algorithms
• Allows runtime swapping of strategies
• Easy to add new selection strategies

4. Singleton Pattern - ElevatorSystem

• Single system instance for entire building
• Ensures consistent state across all elevators

---

Step 6: Define Contracts & APIs

Contracts define how classes interact - method signatures, interfaces, and behavior.

Core Interfaces

Python

ElevatorState Interface:

interfaces.py

interface ElevatorState:
    """
    Defines behavior for elevator states.
    Each state implements different logic for movement and request handling.
    """
    def add_request(elevator: Elevator, request: Request) -> None:
        """
        Add a request to elevator based on current state.

        Args:
            elevator: The elevator receiving the request
            request: The floor request to add

        Behavior:
            - IdleState: Determines direction and transitions to MovingUp/MovingDown
            - MovingUpState: Adds to upRequests if above current floor, else downRequests
            - MovingDownState: Adds to downRequests if below current floor, else upRequests
        """
        pass

    def move(elevator: Elevator) -> None:
        """
        Move elevator based on current state.

        Args:
            elevator: The elevator to move

        Behavior:
            - IdleState: No movement
            - MovingUpState: Moves up, processes upRequests
            - MovingDownState: Moves down, processes downRequests
        """
        pass

    def get_direction() -> Direction:
        """
        Get the direction of this state.

        Returns:
            Direction: UP, DOWN, or IDLE
        """
        pass

ElevatorObserver Interface:

interface ElevatorObserver:
    """
    Observer interface for elevator state changes.
    Implementations can display, log, or notify about elevator updates.
    """
    def update(elevator: Elevator) -> None:
        """
        Called when elevator state changes.

        Args:
            elevator: The elevator that changed state

        Use Cases:
            - Display: Update floor/direction display
            - Logger: Log elevator movements
            - Notification: Send alerts to mobile app
        """
        pass

ElevatorSelectionStrategy Interface:

interface ElevatorSelectionStrategy:
    """
    Strategy for selecting which elevator should handle a request.
    Different implementations can use different algorithms.
    """
    def select_elevator(elevators: List[Elevator], request: Request) -> Optional[Elevator]:
        """
        Select the best elevator for a given request.

        Args:
            elevators: List of available elevators
            request: The floor request to handle

        Returns:
            Optional[Elevator]: Best elevator if found, None otherwise

        Considerations:
            - Current direction of elevator
            - Distance from request floor
            - Current load/capacity
            - Request queue length
        """
        pass

Java

ElevatorState Interface:

Interfaces.java

interface ElevatorState {
    /**
     * Add a request to elevator based on current state.
     * @param elevator The elevator receiving the request
     * @param request The floor request to add
     */
    void addRequest(Elevator elevator, Request request);

    /**
     * Move elevator based on current state.
     * @param elevator The elevator to move
     */
    void move(Elevator elevator);

    /**
     * Get the direction of this state.
     * @return UP, DOWN, or IDLE
     */
    Direction getDirection();
}

ElevatorObserver Interface:

interface ElevatorObserver {
    /**
     * Called when elevator state changes.
     * @param elevator The elevator that changed state
     */
    void update(Elevator elevator);
}

ElevatorSelectionStrategy Interface:

interface ElevatorSelectionStrategy {
    /**
     * Select the best elevator for a given request.
     * @param elevators List of available elevators
     * @param request The floor request to handle
     * @return Best elevator if found, empty Optional otherwise
     */
    Optional<Elevator> selectElevator(List<Elevator> elevators, Request request);
}

Core Class Contracts

Python

ElevatorSystem:

elevator_system_contract.py

class ElevatorSystem:
    def get_instance() -> ElevatorSystem:
        """
        Get singleton instance of elevator system.

        Returns:
            ElevatorSystem: The single instance
        """
        pass

    def add_elevator(elevator: Elevator) -> None:
        """
        Add an elevator to the system.

        Args:
            elevator: Elevator to add

        Note:
            Starts elevator thread automatically
        """
        pass

    def request_elevator(floor: int, direction: Direction) -> None:
        """
        Request an elevator from a floor.

        Args:
            floor: Floor number requesting elevator
            direction: Direction passenger wants to go (UP/DOWN)

        Behavior:
            - Creates external request
            - Uses selection strategy to choose elevator
            - Adds request to selected elevator
        """
        pass

    def set_selection_strategy(strategy: ElevatorSelectionStrategy) -> None:
        """Set the elevator selection strategy."""
        pass

Elevator:

class Elevator:
    def add_request(request: Request) -> None:
        """
        Add a request to this elevator.

        Args:
            request: Floor request to add

        Behavior:
            - Delegates to current state
            - State determines how to handle request
            - Notifies observers after adding
        """
        pass

    def move() -> None:
        """
        Move elevator one floor based on current state.

        Behavior:
            - Delegates to current state
            - State controls movement direction
            - Stops at requested floors
            - Transitions states when appropriate
            - Notifies observers after moving
        """
        pass

    def add_observer(observer: ElevatorObserver) -> None:
        """Add an observer to be notified of state changes."""
        pass

    def notify_observers() -> None:
        """Notify all observers of current state."""
        pass

Java

ElevatorSystem:

ElevatorSystemContract.java

class ElevatorSystem {
    /**
     * Get singleton instance of elevator system.
     * @return The single instance
     */
    public static ElevatorSystem getInstance();

    /**
     * Add an elevator to the system.
     * @param elevator Elevator to add
     */
    public void addElevator(Elevator elevator);

    /**
     * Request an elevator from a floor.
     * @param floor Floor number requesting elevator
     * @param direction Direction passenger wants to go (UP/DOWN)
     */
    public void requestElevator(int floor, Direction direction);

    /** Set the elevator selection strategy. */
    public void setSelectionStrategy(ElevatorSelectionStrategy strategy);
}

Elevator:

class Elevator {
    /**
     * Add a request to this elevator.
     * @param request Floor request to add
     */
    public void addRequest(Request request);

    /**
     * Move elevator one floor based on current state.
     */
    public void move();

    /** Add an observer to be notified of state changes. */
    public void addObserver(ElevatorObserver observer);

    /** Notify all observers of current state. */
    public void notifyObservers();
}

Contract Visualization

Contract [Design Principles](/design-principles/00-introduction-to-design-principles)

• Be explicit - Clear parameter types and return types
• Document behavior - What does each method do?
• Think about state - How does state affect behavior?
• Consider concurrency - Thread-safe operations

---

Step 7: Handle Edge Cases

Edge cases are scenarios that might not be obvious but are important to handle.

Critical Edge Cases

1. All Elevators Busy

• Queue request or assign to least busy elevator
• Provide feedback to user
• Consider wait time estimation

2. Elevator at Capacity

• Reject new passengers when full
• Don’t stop at floors if full (unless requested floor)
• Track current load vs max capacity

3. Request While Moving

• Add request to appropriate queue (up/down)
• Process requests in direction of travel first
• Handle direction changes when queue empties

4. Multiple Equidistant Elevators

• Use tie-breaker (least loaded, first available)
• Consider current direction preference
• Load balancing across elevators

5. Concurrent Requests

• Thread-safe request handling
• Atomic operations for state changes
• Prevent race conditions in selection

6. Invalid Floor Requests

• Validate floor exists
• Reject requests for current floor
• Handle edge cases (floor 0, negative floors)

Edge Case Handling Flow

Thread Safety Considerations

Python

thread_safe_elevator.py

# Thread-safe elevator operations
class Elevator:
    def __init__(self, id: int):
        self.id = id
        self.current_floor = AtomicInteger(0)
        self.up_requests = ConcurrentSkipListSet()  # Thread-safe sorted set
        self.down_requests = ConcurrentSkipListSet()
        self.observers = CopyOnWriteArrayList()  # Thread-safe list
        self._lock = ReentrantLock()

    def add_request(self, request: Request) -> None:
        with self._lock:  # Critical section
            self.state.add_request(self, request)
            self.notify_observers()

    def move(self) -> None:
        with self._lock:  # Critical section
            self.state.move(self)
            self.notify_observers()

Java

ThreadSafeElevator.java

// Thread-safe elevator operations
class Elevator {
    private int id;
    private AtomicInteger currentFloor;
    private TreeSet<Integer> upRequests;
    private TreeSet<Integer> downRequests;
    private List<ElevatorObserver> observers;
    private final ReentrantLock lock = new ReentrantLock();

    public Elevator(int id) {
        this.id = id;
        this.currentFloor = new AtomicInteger(0);
        // Note: In real Java, use ConcurrentSkipListSet or synchronize access
        this.upRequests = new TreeSet<>();
        this.downRequests = new TreeSet<>();
        this.observers = new CopyOnWriteArrayList<>();
    }

    public void addRequest(Request request) {
        lock.lock(); // Critical section
        try {
            state.addRequest(this, request);
            notifyObservers();
        } finally {
            lock.unlock();
        }
    }

    public void move() {
        lock.lock(); // Critical section
        try {
            state.move(this);
            notifyObservers();
        } finally {
            lock.unlock();
        }
    }
}

Edge Case Checklist

Always think about:

• What if all elevators are busy?
• What if elevator is full?
• What if request comes while moving?
• What if multiple users request simultaneously?
• What if elevator breaks down?
• What if invalid floor requested?

---

Step 8: Code Implementation

Finally, implement your design following SOLID principles and design patterns.

Complete Implementation

Python

elevator_system_complete.py

from abc import ABC, abstractmethod
from enum import Enum
from typing import Optional, List, Dict, Set
import threading
from collections import deque
import time

# =====================
# ENUMERATIONS
# =====================

class RequestSource(Enum):
    INTERNAL = "INTERNAL"  # Request from inside elevator
    EXTERNAL = "EXTERNAL"   # Request from floor button

class Direction(Enum):
    UP = "UP"
    DOWN = "DOWN"
    IDLE = "IDLE"

# =====================
# REQUEST
# =====================

class Request:
    """Represents a floor request."""

    def __init__(self, target_floor: int, source: RequestSource, direction: Direction):
        self.target_floor = target_floor
        self.source = source
        self.direction = direction

    def get_target_floor(self) -> int:
        return self.target_floor

    def get_direction(self) -> Direction:
        return self.direction

# =====================
# OBSERVER PATTERN
# =====================

class ElevatorObserver(ABC):
    """Observer interface for elevator state changes."""

    @abstractmethod
    def update(self, elevator: 'Elevator') -> None:
        pass

class Display(ElevatorObserver):
    """Display that shows elevator status."""

    def update(self, elevator: 'Elevator') -> None:
        print(f"Display: Elevator {elevator.get_id()} at Floor {elevator.get_current_floor()} "
              f"Direction: {elevator.get_direction().value}")

# =====================
# STATE PATTERN
# =====================

class ElevatorState(ABC):
    """Abstract state interface."""

    @abstractmethod
    def add_request(self, elevator: 'Elevator', request: Request) -> None:
        pass

    @abstractmethod
    def move(self, elevator: 'Elevator') -> None:
        pass

    @abstractmethod
    def get_direction(self) -> Direction:
        pass

class IdleState(ElevatorState):
    """Elevator is idle, waiting for requests."""

    def add_request(self, elevator: 'Elevator', request: Request) -> None:
        target = request.get_target_floor()
        current = elevator.get_current_floor()

        if target > current:
            elevator.set_state(MovingUpState())
            elevator.get_up_requests().add(target)
        elif target < current:
            elevator.set_state(MovingDownState())
            elevator.get_down_requests().add(target)
        # If target == current, do nothing (already there)

    def move(self, elevator: 'Elevator') -> None:
        # Stay idle, no movement
        pass

    def get_direction(self) -> Direction:
        return Direction.IDLE

class MovingUpState(ElevatorState):
    """Elevator is moving up."""

    def add_request(self, elevator: 'Elevator', request: Request) -> None:
        target = request.get_target_floor()
        current = elevator.get_current_floor()

        if target > current:
            # Add to up requests (will be processed while going up)
            elevator.get_up_requests().add(target)
        else:
            # Add to down requests (will be processed after up requests)
            elevator.get_down_requests().add(target)

    def move(self, elevator: 'Elevator') -> None:
        up_requests = elevator.get_up_requests()
        down_requests = elevator.get_down_requests()
        current = elevator.get_current_floor()

        if not up_requests:
            # No more up requests, check down requests
            if down_requests:
                elevator.set_state(MovingDownState())
            else:
                elevator.set_state(IdleState())
            return

        # Get next floor to visit
        next_floor = min(up_requests)

        if current < next_floor:
            # Move up one floor
            elevator.set_current_floor(current + 1)

        # Check if we've reached a requested floor
        if elevator.get_current_floor() in up_requests:
            up_requests.remove(elevator.get_current_floor())
            print(f"Elevator {elevator.get_id()} stopped at floor {elevator.get_current_floor()}")
            # In real system: open doors, wait, close doors

    def get_direction(self) -> Direction:
        return Direction.UP

class MovingDownState(ElevatorState):
    """Elevator is moving down."""

    def add_request(self, elevator: 'Elevator', request: Request) -> None:
        target = request.get_target_floor()
        current = elevator.get_current_floor()

        if target < current:
            # Add to down requests (will be processed while going down)
            elevator.get_down_requests().add(target)
        else:
            # Add to up requests (will be processed after down requests)
            elevator.get_up_requests().add(target)

    def move(self, elevator: 'Elevator') -> None:
        up_requests = elevator.get_up_requests()
        down_requests = elevator.get_down_requests()
        current = elevator.get_current_floor()

        if not down_requests:
            # No more down requests, check up requests
            if up_requests:
                elevator.set_state(MovingUpState())
            else:
                elevator.set_state(IdleState())
            return

        # Get next floor to visit
        next_floor = max(down_requests)

        if current > next_floor:
            # Move down one floor
            elevator.set_current_floor(current - 1)

        # Check if we've reached a requested floor
        if elevator.get_current_floor() in down_requests:
            down_requests.remove(elevator.get_current_floor())
            print(f"Elevator {elevator.get_id()} stopped at floor {elevator.get_current_floor()}")
            # In real system: open doors, wait, close doors

    def get_direction(self) -> Direction:
        return Direction.DOWN

# =====================
# ELEVATOR
# =====================

class Elevator(threading.Thread):
    """Represents an elevator car."""

    def __init__(self, elevator_id: int):
        super().__init__(daemon=True)
        self.elevator_id = elevator_id
        self.current_floor = 0
        self.state: ElevatorState = IdleState()
        self.up_requests: Set[int] = set()
        self.down_requests: Set[int] = set()
        self.observers: List[ElevatorObserver] = []
        self.is_running = True
        self._lock = threading.Lock()

    def add_observer(self, observer: ElevatorObserver) -> None:
        """Add an observer to be notified of state changes."""
        with self._lock:
            self.observers.append(observer)

    def notify_observers(self) -> None:
        """Notify all observers of state change."""
        with self._lock:
            for observer in self.observers:
                observer.update(self)

    def add_request(self, request: Request) -> None:
        """Add a request to this elevator."""
        with self._lock:
            self.state.add_request(self, request)
            self.notify_observers()

    def move(self) -> None:
        """Move elevator based on current state."""
        with self._lock:
            self.state.move(self)
            self.notify_observers()

    def run(self) -> None:
        """Elevator thread main loop."""
        while self.is_running:
            self.move()
            time.sleep(1)  # Simulate movement time

    def stop(self) -> None:
        """Stop the elevator thread."""
        self.is_running = False

    # Getters and setters
    def get_id(self) -> int:
        return self.elevator_id

    def get_current_floor(self) -> int:
        return self.current_floor

    def set_current_floor(self, floor: int) -> None:
        self.current_floor = floor

    def set_state(self, state: ElevatorState) -> None:
        self.state = state

    def get_up_requests(self) -> Set[int]:
        return self.up_requests

    def get_down_requests(self) -> Set[int]:
        return self.down_requests

    def get_direction(self) -> Direction:
        return self.state.get_direction()

# =====================
# STRATEGY PATTERN
# =====================

class ElevatorSelectionStrategy(ABC):
    """Strategy for selecting which elevator handles a request."""

    @abstractmethod
    def select_elevator(self, elevators: List[Elevator], request: Request) -> Optional[Elevator]:
        pass

class NearestElevatorStrategy(ElevatorSelectionStrategy):
    """Selects the nearest available elevator."""

    def select_elevator(self, elevators: List[Elevator], request: Request) -> Optional[Elevator]:
        if not elevators:
            return None

        target_floor = request.get_target_floor()
        best_elevator = None
        min_distance = float('inf')

        for elevator in elevators:
            distance = abs(elevator.get_current_floor() - target_floor)

            # Prefer elevators moving towards request or idle
            direction = elevator.get_direction()
            if direction == request.get_direction() or direction == Direction.IDLE:
                if distance < min_distance:
                    min_distance = distance
                    best_elevator = elevator

        # If no elevator moving in right direction, pick nearest
        if best_elevator is None:
            for elevator in elevators:
                distance = abs(elevator.get_current_floor() - target_floor)
                if distance < min_distance:
                    min_distance = distance
                    best_elevator = elevator

        return best_elevator

# =====================
# SINGLETON PATTERN - MAIN SYSTEM
# =====================

class ElevatorSystem:
    """Main elevator system (Singleton)."""

    _instance: Optional['ElevatorSystem'] = None
    _lock = threading.Lock()

    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        # Prevent re-initialization
        if hasattr(self, '_initialized'):
            return

        self.elevators: Dict[int, Elevator] = {}
        self.selection_strategy: ElevatorSelectionStrategy = NearestElevatorStrategy()
        self._initialized = True

    def add_elevator(self, elevator: Elevator) -> None:
        """Add an elevator to the system and start its thread."""
        self.elevators[elevator.get_id()] = elevator
        elevator.start()

    def set_selection_strategy(self, strategy: ElevatorSelectionStrategy) -> None:
        """Set the elevator selection strategy."""
        self.selection_strategy = strategy

    def request_elevator(self, floor: int, direction: Direction) -> None:
        """
        Request an elevator from a floor.

        Args:
            floor: Floor number requesting elevator
            direction: Direction passenger wants to go
        """
        request = Request(floor, RequestSource.EXTERNAL, direction)
        elevator = self.selection_strategy.select_elevator(
            list(self.elevators.values()),
            request
        )

        if elevator:
            elevator.add_request(request)
            print(f"Request from floor {floor} going {direction.value} assigned to Elevator {elevator.get_id()}")
        else:
            print(f"No elevator available for request from floor {floor}")

# =====================
# DEMO
# =====================

if __name__ == "__main__":
    # Get singleton instance
    system = ElevatorSystem.getInstance()

    # Create elevators
    elevator1 = Elevator(1)
    elevator1.add_observer(Display())
    system.add_elevator(elevator1)

    elevator2 = Elevator(2)
    elevator2.add_observer(Display())
    system.add_elevator(elevator2)

    # Request elevators
    system.request_elevator(5, Direction.UP)
    system.request_elevator(3, Direction.DOWN)

    # Simulate time
    time.sleep(10)

    # Stop elevators
    elevator1.stop()
    elevator2.stop()

Java

ElevatorSystemComplete.java

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

// =====================
// ENUMERATIONS
// =====================
enum RequestSource {
    INTERNAL, EXTERNAL
}

enum Direction {
    UP, DOWN, IDLE
}

// =====================
// REQUEST
// =====================
class Request {
    private int targetFloor;
    private RequestSource source;
    private Direction direction;

    public Request(int targetFloor, RequestSource source, Direction direction) {
        this.targetFloor = targetFloor;
        this.source = source;
        this.direction = direction;
    }

    public int getTargetFloor() { return targetFloor; }
    public Direction getDirection() { return direction; }
}

// =====================
// OBSERVER PATTERN
// =====================
interface ElevatorObserver {
    void update(Elevator elevator);
}

class Display implements ElevatorObserver {
    @Override
    public void update(Elevator elevator) {
        System.out.println("Display: Elevator " + elevator.getId() +
                          " at Floor " + elevator.getCurrentFloor() +
                          " Direction: " + elevator.getDirection());
    }
}

// =====================
// STATE PATTERN
// =====================
interface ElevatorState {
    void addRequest(Elevator elevator, Request request);
    void move(Elevator elevator);
    Direction getDirection();
}

class IdleState implements ElevatorState {
    @Override
    public void addRequest(Elevator elevator, Request request) {
        int target = request.getTargetFloor();
        int current = elevator.getCurrentFloor();

        if (target > current) {
            elevator.setState(new MovingUpState());
            elevator.getUpRequests().add(target);
        } else if (target < current) {
            elevator.setState(new MovingDownState());
            elevator.getDownRequests().add(target);
        }
    }

    @Override
    public void move(Elevator elevator) {
        // Stay idle
    }

    @Override
    public Direction getDirection() {
        return Direction.IDLE;
    }
}

class MovingUpState implements ElevatorState {
    @Override
    public void addRequest(Elevator elevator, Request request) {
        int target = request.getTargetFloor();
        int current = elevator.getCurrentFloor();

        if (target > current) {
            elevator.getUpRequests().add(target);
        } else {
            elevator.getDownRequests().add(target);
        }
    }

    @Override
    public void move(Elevator elevator) {
        TreeSet<Integer> upRequests = elevator.getUpRequests();
        TreeSet<Integer> downRequests = elevator.getDownRequests();

        if (upRequests.isEmpty()) {
            if (!downRequests.isEmpty()) {
                elevator.setState(new MovingDownState());
            } else {
                elevator.setState(new IdleState());
            }
            return;
        }

        int nextFloor = upRequests.first();
        int current = elevator.getCurrentFloor();

        if (current < nextFloor) {
            elevator.setCurrentFloor(current + 1);
        }

        if (elevator.getCurrentFloor() == nextFloor) {
            upRequests.remove(nextFloor);
            System.out.println("Elevator " + elevator.getId() +
                             " stopped at floor " + nextFloor);
        }
    }

    @Override
    public Direction getDirection() {
        return Direction.UP;
    }
}

class MovingDownState implements ElevatorState {
    @Override
    public void addRequest(Elevator elevator, Request request) {
        int target = request.getTargetFloor();
        int current = elevator.getCurrentFloor();

        if (target < current) {
            elevator.getDownRequests().add(target);
        } else {
            elevator.getUpRequests().add(target);
        }
    }

    @Override
    public void move(Elevator elevator) {
        TreeSet<Integer> upRequests = elevator.getUpRequests();
        TreeSet<Integer> downRequests = elevator.getDownRequests();

        if (downRequests.isEmpty()) {
            if (!upRequests.isEmpty()) {
                elevator.setState(new MovingUpState());
            } else {
                elevator.setState(new IdleState());
            }
            return;
        }

        int nextFloor = downRequests.first();
        int current = elevator.getCurrentFloor();

        if (current > nextFloor) {
            elevator.setCurrentFloor(current - 1);
        }

        if (elevator.getCurrentFloor() == nextFloor) {
            downRequests.remove(nextFloor);
            System.out.println("Elevator " + elevator.getId() +
                             " stopped at floor " + nextFloor);
        }
    }

    @Override
    public Direction getDirection() {
        return Direction.DOWN;
    }
}

// =====================
// ELEVATOR
// =====================
class Elevator implements Runnable {
    private int id;
    private AtomicInteger currentFloor;
    private ElevatorState state;
    private TreeSet<Integer> upRequests;
    private TreeSet<Integer> downRequests;
    private List<ElevatorObserver> observers;
    private boolean isRunning;
    private final ReentrantLock lock = new ReentrantLock();

    public Elevator(int id) {
        this.id = id;
        this.currentFloor = new AtomicInteger(0);
        this.state = new IdleState();
        this.upRequests = new TreeSet<>();
        this.downRequests = new TreeSet<>(Collections.reverseOrder());
        this.observers = new CopyOnWriteArrayList<>();
        this.isRunning = true;
    }

    public void addObserver(ElevatorObserver observer) {
        observers.add(observer);
    }

    public void notifyObservers() {
        for (ElevatorObserver observer : observers) {
            observer.update(this);
        }
    }

    public void addRequest(Request request) {
        lock.lock();
        try {
            state.addRequest(this, request);
            notifyObservers();
        } finally {
            lock.unlock();
        }
    }

    public void move() {
        lock.lock();
        try {
            state.move(this);
            notifyObservers();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void run() {
        while (isRunning) {
            move();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }

    public void stop() {
        isRunning = false;
    }

    // Getters and setters
    public int getId() { return id; }
    public int getCurrentFloor() { return currentFloor.get(); }
    public void setCurrentFloor(int floor) { currentFloor.set(floor); }
    public void setState(ElevatorState state) { this.state = state; }
    public TreeSet<Integer> getUpRequests() { return upRequests; }
    public TreeSet<Integer> getDownRequests() { return downRequests; }
    public Direction getDirection() { return state.getDirection(); }
}

// =====================
// STRATEGY PATTERN
// =====================
interface ElevatorSelectionStrategy {
    Optional<Elevator> selectElevator(List<Elevator> elevators, Request request);
}

class NearestElevatorStrategy implements ElevatorSelectionStrategy {
    @Override
    public Optional<Elevator> selectElevator(List<Elevator> elevators, Request request) {
        if (elevators.isEmpty()) {
            return Optional.empty();
        }

        int targetFloor = request.getTargetFloor();
        Elevator bestElevator = null;
        int minDistance = Integer.MAX_VALUE;

        for (Elevator elevator : elevators) {
            int distance = Math.abs(elevator.getCurrentFloor() - targetFloor);
            Direction dir = elevator.getDirection();

            if (dir == request.getDirection() || dir == Direction.IDLE) {
                if (distance < minDistance) {
                    minDistance = distance;
                    bestElevator = elevator;
                }
            }
        }

        if (bestElevator == null) {
            for (Elevator elevator : elevators) {
                int distance = Math.abs(elevator.getCurrentFloor() - targetFloor);
                if (distance < minDistance) {
                    minDistance = distance;
                    bestElevator = elevator;
                }
            }
        }

        return Optional.ofNullable(bestElevator);
    }
}

// =====================
// SINGLETON PATTERN - MAIN SYSTEM
// =====================
class ElevatorSystem {
    private static volatile ElevatorSystem instance;
    private static final Object lock = new Object();

    private Map<Integer, Elevator> elevators;
    private ElevatorSelectionStrategy selectionStrategy;
    private ExecutorService executorService;

    private ElevatorSystem() {
        this.elevators = new ConcurrentHashMap<>();
        this.selectionStrategy = new NearestElevatorStrategy();
        this.executorService = Executors.newCachedThreadPool();
    }

    public static ElevatorSystem getInstance() {
        if (instance == null) {
            synchronized (lock) {
                if (instance == null) {
                    instance = new ElevatorSystem();
                }
            }
        }
        return instance;
    }

    public void addElevator(Elevator elevator) {
        elevators.put(elevator.getId(), elevator);
        executorService.submit(elevator);
    }

    public void setSelectionStrategy(ElevatorSelectionStrategy strategy) {
        this.selectionStrategy = strategy;
    }

    public void requestElevator(int floor, Direction direction) {
        Request request = new Request(floor, RequestSource.EXTERNAL, direction);
        Optional<Elevator> elevatorOpt = selectionStrategy.selectElevator(
            new ArrayList<>(elevators.values()),
            request
        );

        elevatorOpt.ifPresentOrElse(
            elevator -> {
                elevator.addRequest(request);
                System.out.println("Request from floor " + floor +
                                 " going " + direction +
                                 " assigned to Elevator " + elevator.getId());
            },
            () -> System.out.println("No elevator available for request from floor " + floor)
        );
    }
}

// =====================
// DEMO
// =====================
public class ElevatorSystemDemo {
    public static void main(String[] args) {
        ElevatorSystem system = ElevatorSystem.getInstance();

        Elevator e1 = new Elevator(1);
        e1.addObserver(new Display());
        system.addElevator(e1);

        Elevator e2 = new Elevator(2);
        e2.addObserver(new Display());
        system.addElevator(e2);

        system.requestElevator(5, Direction.UP);
        system.requestElevator(3, Direction.DOWN);

        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        e1.stop();
        e2.stop();
    }
}

Key Implementation Highlights

1. State Pattern:

• IdleState, MovingUpState, MovingDownState encapsulate behavior
• Eliminates complex if-else chains
• Easy to add new states (e.g., EmergencyState)

2. Observer Pattern:

• Display observes elevator state changes
• Easy to add more observers (audio, logging, mobile app)
• Decouples elevator from presentation

3. Strategy Pattern:

• NearestElevatorStrategy selects best elevator
• Easy to swap strategies (e.g., LeastLoadedStrategy)

4. Thread Safety:

• Each elevator runs in separate thread
• Locks for critical sections
• Thread-safe collections

5. Request Management:

• TreeSet for sorted request queues
• Separate queues for up and down directions
• Efficient floor processing

---

Design Patterns Deep Dive

Why State Pattern?

Problem: Without State Pattern, Elevator.move() would look like:

Python

state_pattern_bad.py

def move(self):
    if self.direction == UP:
        # 50 lines of up logic
        if self.current_floor < self.next_floor:
            self.current_floor += 1
        # ... more up logic
    elif self.direction == DOWN:
        # 50 lines of down logic
        # ... more down logic
    else:  # IDLE
        # idle logic

Java

StatePatternBad.java

public void move() {
    if (direction == UP) {
        // 50 lines of up logic
        if (currentFloor < nextFloor) {
            currentFloor++;
        }
        // ... more up logic
    } else if (direction == DOWN) {
        // 50 lines of down logic
        // ... more down logic
    } else { // IDLE
        // idle logic
    }
}

Why State Pattern?

• Eliminates if-else chains - Each state encapsulates its behavior
• Open/Closed Principle - Add new states without modifying Elevator
• Single Responsibility - Each state class handles one behavior
• Easier to test - Test each state independently

How it works:

• Elevator delegates move() and addRequest() to current ElevatorState
• States can transition: IdleState → MovingUpState → MovingDownState → IdleState
• State decides how to handle requests based on current direction

Why Observer Pattern?

Problem: If Elevator directly updates Display, what happens when we add:

• Audio announcements?
• Logging system?
• Mobile app notifications?

We’d have to modify Elevator class each time → Violates Open/Closed Principle

Why Observer Pattern?

• Loose Coupling - Elevator doesn’t know about concrete observers
• Extensibility - Add new observers without changing Elevator
• Separation of Concerns - Elevator focuses on movement, observers handle presentation

How it works:

• Elevator maintains list of ElevatorObserver references
• When state changes, calls notifyObservers()
• Each observer’s update() method is called with elevator reference
• Observer pulls needed data (floor, direction) from elevator

Why Strategy Pattern?

Problem: How should ElevatorSystem choose which elevator to assign?

• Nearest elevator?
• Least loaded?
• Zone-based (elevator 1 serves floors 1-10, elevator 2 serves 11-20)?
• SCAN algorithm?

Why Strategy Pattern?

• Algorithm Encapsulation - Each selection algorithm in its own class
• Runtime Flexibility - Can switch strategies without code changes
• Testability - Test each strategy independently
• Future-proof - Easy to add new strategies (e.g., EnergyEfficientStrategy)

How it works:

• ElevatorSystem holds reference to ElevatorSelectionStrategy
• requestElevator() delegates to strategy.selectElevator()
• Strategy analyzes all elevators and request, returns best match
• Can be swapped: system.setSelectionStrategy(new LeastLoadedStrategy())

---

System Flow Diagrams

Request Handling Flow

Elevator Movement Flow

---

Extensibility & Future Enhancements

Easy to Extend

1. Add New State:

Python

new_state.py

class EmergencyState(ElevatorState):
    """Elevator in emergency mode - stops immediately."""

    def add_request(self, elevator, request):
        # Ignore all requests during emergency
        pass

    def move(self, elevator):
        # Stop at nearest floor and open doors
        elevator.stop_at_floor()
        elevator.open_doors()

    def get_direction(self):
        return Direction.IDLE

# Use it
elevator.set_state(EmergencyState())

Java

NewState.java

class EmergencyState implements ElevatorState {
    /** Elevator in emergency mode - stops immediately. */

    @Override
    public void addRequest(Elevator elevator, Request request) {
        // Ignore all requests during emergency
    }

    @Override
    public void move(Elevator elevator) {
        // Stop at nearest floor and open doors
        elevator.stopAtFloor();
        elevator.openDoors();
    }

    @Override
    public Direction getDirection() {
        return Direction.IDLE;
    }
}

// Use it
elevator.setState(new EmergencyState());

2. Add New Observer:

Python

new_observer.py

class AudioAnnouncement(ElevatorObserver):
    """Announces floor numbers audibly."""

    def update(self, elevator):
        print(f"Floor {elevator.get_current_floor()}")
        # In real system: play audio file

# Use it
elevator.add_observer(AudioAnnouncement())

Java

NewObserver.java

class AudioAnnouncement implements ElevatorObserver {
    /** Announces floor numbers audibly. */

    @Override
    public void update(Elevator elevator) {
        System.out.println("Floor " + elevator.getCurrentFloor());
        // In real system: play audio file
    }
}

// Use it
elevator.addObserver(new AudioAnnouncement());

3. Add New Selection Strategy:

Python

new_strategy.py

class LeastLoadedStrategy(ElevatorSelectionStrategy):
    """Selects elevator with fewest pending requests."""

    def select_elevator(self, elevators, request):
        return min(elevators,
                  key=lambda e: len(e.get_up_requests()) + len(e.get_down_requests()))

# Use it
system.set_selection_strategy(LeastLoadedStrategy())

Java

NewStrategy.java

class LeastLoadedStrategy implements ElevatorSelectionStrategy {
    /** Selects elevator with fewest pending requests. */

    @Override
    public Optional<Elevator> selectElevator(List<Elevator> elevators, Request request) {
        return elevators.stream()
            .min(Comparator.comparingInt(e ->
                e.getUpRequests().size() + e.getDownRequests().size()));
    }
}

// Use it
system.setSelectionStrategy(new LeastLoadedStrategy());

Future Enhancements

1. Capacity Management:

• Track current load vs max capacity
• Reject passengers when full
• Don’t stop at floors if full (unless requested floor)

2. Zone-based Strategy:

• Elevators serve specific floor ranges
• ZoneBasedStrategy assigns requests to appropriate zone

3. SCAN Algorithm:

• Elevator goes to top, then bottom, then repeats
• Efficient for high-traffic scenarios

4. Request Prioritization:

• VIP floors get priority
• Emergency requests override normal requests
• Express mode (skip floors)

5. Maintenance Mode:

• Elevator out of service
• MaintenanceState that ignores requests
• Admin can enable/disable elevators

---

Summary

Key Takeaways

• Follow Systematic Approach - Don’t jump to code
• Identify Actors First - Who uses the system?
• Identify Entities - What are the core objects?
• Assign Responsibilities - Single Responsibility Principle
• Design Class Diagrams - Visualize structure and relationships
• Define Contracts - Clear interfaces and APIs
• Handle Edge Cases - Think about errors and concurrency
• Use Design Patterns - State, Observer, Strategy
• Make it Extensible - Easy to add new features

Design Patterns Used

1. State Pattern - Encapsulates behavior for each elevator state
2. Observer Pattern - Decouples elevator from display/notifications
3. Strategy Pattern - Swappable elevator selection algorithms
4. Singleton Pattern - Single system instance

Best Practices Demonstrated

• SOLID principles (SRP, OCP)
• Thread safety considerations
• Clear separation of concerns
• Extensible design
• Error handling
• Clean code structure

---

Next Steps

Now that you’ve mastered the Elevator System:

Practice Similar Problems:

• Traffic Light System
• Vending Machine
• ATM System
• Coffee Machine

Explore More Patterns:

• Command Pattern (for request queuing)
• Chain of Responsibility (for request processing)
• Template Method (for movement algorithms)

Deepen Your Understanding:

• Read about concurrent state machines
• Study distributed elevator systems
• Learn about real-time scheduling algorithms

---

Practice Makes Perfect

Try implementing this system yourself! Start with the basic version, then add:

• Capacity management
• Different selection strategies
• Emergency state
• Request prioritization
• Zone-based dispatching

The more you practice, the better you’ll become at LLD interviews! 🚀