problemhardood

Design an elevator system

HardUpdated: Oct 16, 2025

Problem

Model an elevator system using object-oriented design. The system should manage multiple elevators (a bank), accept floor calls, schedule elevators efficiently, handle door/ride lifecycle and emergency signals, and support passenger boarding and unloading.

Solution

1. Requirements Analysis

Functional Requirements:

  • Represent elevators with state (direction, current floor, door status) and handle floor requests.
  • A Bank/ElevatorController that receives floor calls and schedules them to active elevators.
  • Support passenger boarding/unboarding and tracking of onboard passengers and load.
  • Allow alarm and door control signals (open/close), and graceful handling of maintenance mode.

Non-Functional Requirements:

  • Safety: doors must not close on passengers; alarm behavior must be deterministic.
  • Responsiveness: minimize wait time via reasonable scheduling heuristics.
  • Extensibility: support different scheduling strategies and elevator capacities.

2. Use Case Diagram

Actors: Passenger, Operator, System (ElevatorController).

Use Case Summary: Passengers call elevators from floors or select destination floors inside elevators. The ElevatorController assigns requests to appropriate elevators (standing, approaching, or least-loaded). Operators can place elevators into maintenance and query system status. The System executes movement, door operations, and handles alarms.

graph TD
  subgraph ElevatorSystem
    UC_Call(Call Elevator)
    UC_Select(Select Destination)
    UC_Maintenance(Set Maintenance)
    UC_Query(Query Status)
    UC_Alarm(Trigger Alarm)
  end
  Passenger --> UC_Call
  Passenger --> UC_Select
  Operator --> UC_Maintenance
  Operator --> UC_Query
  System --> UC_Alarm

3. Class Diagram

Core classes and responsibilities:

  • Elevator: stateful unit (id, currentFloor, direction, state, requests queue, doors, capacity, passengers). Methods: moveOneFloor(), addRequest(floor), openDoor(), closeDoor(), addPassenger(), removePassenger(), enterMaintenance().
  • ElevatorController (Bank): manages elevators, accepts floor calls, selects elevator with scheduling heuristic (standing on floor, approaching, least-loaded), reassigns requests from failed/maintenance elevators.
  • FloorRequest / Request: encapsulates source floor, destination floor (optional), timestamp, and priority.
  • Passenger: id, destinationFloor; interacts with Elevator to board/unboard.
  • Door: open(), close(), isObstructed(); integrated with Elevator for safety.
  • ElevatorState (enum): MAINTENANCE, STAND, UP, DOWN.
  • SchedulerPolicy (interface/strategy): encapsulates selection logic for which elevator to assign a request.
classDiagram
  class Elevator { +int id +int currentFloor +Direction direction +ElevatorState state +List~int~ requests +List~Passenger~ passengers +moveOneFloor() +addRequest(int) +openDoor() +closeDoor() }
  class ElevatorController { +List~Elevator~ elevators +submitRequest(Request) +assignElevator() +getStatus() }
  class Request { +int sourceFloor +Optional~int~ destFloor +long timestamp }
  class Passenger { +int id +int destinationFloor }
  class Door { +open() +close() +isObstructed(): boolean }
  enum ElevatorState { MAINTENANCE; STAND; UP; DOWN }
  ElevatorController "1" -- "*" Elevator : manages
  Elevator "1" -- "*" Passenger : carries
  Elevator "1" -- "*" Request : accepts

4. Activity Diagrams

Activity: Passenger call -> Assignment -> Pickup

graph TD
  P1[Passenger presses call button] --> P2[Controller receives request]
  P2 --> P3[Controller selects elevator via policy]
  P3 --> P4[Elevator updates requests queue]
  P4 --> P5[Elevator moves to floor and opens door]
  P5 --> P6[Passenger boards -> select destination]
  P6 --> P7[Elevator continues serving requests]

Activity: Alarm Handling

graph TD
  A1[Alarm triggered] --> A2[Elevator stops immediate]
  A2 --> A3[If on floor -> open doors]
  A3 --> A4[Clear request list & notify Controller]
  A4 --> A5[Controller redispatches pending requests to other elevators]

5. High-Level Code Implementation

Java (skeleton)

public enum ElevatorState { MAINTENANCE, STAND, UP, DOWN }

public class Door { public void open(); public void close(); public boolean isObstructed(); }

public class Passenger { int id; int destinationFloor; }

public class Request { int sourceFloor; Integer destFloor; long timestamp; }

public class Elevator {
  int id; int currentFloor; ElevatorState state; java.util.List<Integer> requests; java.util.List<Passenger> passengers; Door door;
  public void moveOneFloor() {}
  public void addRequest(int floor) {}
  public void openDoor() {}
  public void closeDoor() {}
}

public class ElevatorController {
  java.util.List<Elevator> elevators;
  public void submitRequest(Request r) {}
  public void assignElevator() {}
  public String getStatus() { return ""; }
}

Python (skeleton, type-hinted)

from enum import Enum
from typing import List, Optional

class ElevatorState(Enum):
    MAINTENANCE = 1
    STAND = 2
    UP = 3
    DOWN = 4

class Door:
    def open(self) -> None: pass
    def close(self) -> None: pass
    def is_obstructed(self) -> bool: return False

class Passenger:
    def __init__(self, id: int, destination_floor: int) -> None:
        self.id = id
        self.destination_floor = destination_floor

class Request:
    def __init__(self, source_floor: int, dest_floor: Optional[int] = None) -> None:
        self.source_floor = source_floor
        self.dest_floor = dest_floor

class Elevator:
    def __init__(self, id: int, min_floor: int, max_floor: int) -> None:
        self.id = id
        self.current_floor = min_floor
        self.state = ElevatorState.STAND
        self.requests: List[int] = []
        self.passengers: List[Passenger] = []
        self.door = Door()
    def move_one_floor(self) -> None: pass
    def add_request(self, floor: int) -> None: pass
    def open_door(self) -> None: pass
    def close_door(self) -> None: pass

class ElevatorController:
    def __init__(self) -> None:
        self.elevators: List[Elevator] = []
    def submit_request(self, r: Request) -> None: pass
    def assign_elevator(self) -> None: pass

References & Code

Comments