Elevator, Floor, Request classes in LLD - Scalability & System Analysis

Scalability Analysis - Elevator, Floor, Request classes

Growth Table: Elevator System Scaling

Users (People)	Requests per Minute	Elevators Needed	System Complexity	Latency (Wait Time)
100	50	1	Simple: Single elevator, direct request handling	Low (seconds)
10,000	5,000	10-20	Moderate: Multiple elevators, request queueing, scheduling	Moderate (tens of seconds)
1,000,000	500,000	100+	Complex: Distributed control, load balancing, fault tolerance	Variable, optimized by scheduling algorithms
100,000,000	50,000,000	Thousands	Very complex: Multi-building coordination, advanced predictive scheduling	Challenging, requires AI and real-time analytics

First Bottleneck

At small scale (100 users), the bottleneck is the elevator's mechanical speed and door operation time.

At medium scale (10,000 users), the bottleneck is the request processing and scheduling logic in the control system, as many requests compete for limited elevators.

At large scale (1 million+ users), the bottleneck shifts to communication and coordination between multiple elevator controllers and the central system, plus data processing delays.

Scaling Solutions

• Horizontal Scaling: Add more elevators to serve more requests concurrently.
• Load Balancing: Distribute requests evenly among elevators to avoid congestion.
• Caching: Cache frequent floor requests or patterns to optimize scheduling.
• Sharding: Divide floors or buildings into zones, each managed by separate controllers.
• Predictive Scheduling: Use historical data to anticipate demand and pre-position elevators.
• Fault Tolerance: Implement fallback mechanisms if an elevator or controller fails.

Back-of-Envelope Cost Analysis

• Requests per second at 10,000 users: ~83 (5,000 requests/min ÷ 60)
• Each elevator can handle ~5-10 requests per minute depending on speed and stops.
• Storage for request logs: Minimal, a few KB per request, scaling to GBs at large scale.
• Network bandwidth: Low per request, mostly control signals; scales with number of elevators and controllers.
• CPU: Scheduling algorithms run in milliseconds; more elevators increase CPU needs linearly.

Interview Tip

Start by defining the scale and key components: elevators, floors, requests.

Discuss how requests flow from users to elevators and how scheduling works.

Identify bottlenecks at each scale and propose targeted solutions.

Use real-world analogies like traffic lights or taxi dispatch to explain scheduling.

Always mention trade-offs: cost vs. latency vs. complexity.

Self Check Question

Your elevator control system handles 1000 requests per minute. Traffic grows 10x. What do you do first?

Answer: Add more elevators (horizontal scaling) and improve scheduling algorithms to handle increased requests efficiently.

Key Result

Elevator systems scale by adding more elevators and improving scheduling; the first bottleneck shifts from mechanical limits to control logic and communication as user count grows.

Practice

1. What is the primary role of the Request class in an elevator system?

easy

A. To store the floor number and direction of a user's request

B. To move the elevator between floors

C. To open and close the elevator doors

D. To track the number of elevators in the building

Solution

1. Step 1: Understand the purpose of Request class

   The Request class holds information about where a user wants to go and in which direction.

2. Step 2: Compare roles of other classes

   Elevator moves and Floor represents building levels, but Request stores user input details.

3. Final Answer:

   To store the floor number and direction of a user's request -> Option A

4. Quick Check:

   Request = user floor and direction [OK]

Hint: Request class holds user floor and direction info [OK]

Common Mistakes:

• Confusing Request with Elevator movement
• Thinking Request controls doors
• Mixing Request with Floor class responsibilities

2. Which of the following is the correct way to define a Request class constructor in Python to store floor and direction?

easy

A. def Request(floor, direction): self.floor = floor; self.direction = direction

B. def __init__(self, floor, direction): self.floor = floor; self.direction = direction

C. def __init__(floor, direction): self.floor = floor; self.direction = direction

D. def __init__(self): floor = None; direction = None

Solution

1. Step 1: Recall Python constructor syntax

   Python constructors use def __init__(self, ...) and assign attributes with self.attribute = value.

2. Step 2: Check each option

   def __init__(self, floor, direction): self.floor = floor; self.direction = direction correctly uses self and assigns floor and direction. Others miss self or parameters.

3. Final Answer:

   def __init__(self, floor, direction): self.floor = floor; self.direction = direction -> Option B

4. Quick Check:

   Constructor with self and attributes = def __init__(self, floor, direction): self.floor = floor; self.direction = direction [OK]

Hint: Python constructors need self parameter and attribute assignment [OK]

Common Mistakes:

• Omitting self parameter
• Using class name as constructor
• Not assigning attributes to self

3. Given this Python snippet, what will be printed?

class Request:
    def __init__(self, floor, direction):
        self.floor = floor
        self.direction = direction

r = Request(5, 'up')
print(r.floor, r.direction)

medium

A. Error: missing self

B. floor direction

C. 5 up

D. None None

Solution

1. Step 1: Understand object creation and attribute assignment

   The Request object r is created with floor=5 and direction='up'. These are stored in attributes.

2. Step 2: Print attributes

   Printing r.floor and r.direction outputs 5 and 'up' respectively.

3. Final Answer:

   5 up -> Option C

4. Quick Check:

   Attributes print as assigned = 5 up [OK]

Hint: Print object attributes to see stored values [OK]

Common Mistakes:

• Expecting attribute names instead of values
• Confusing class variables with instance variables
• Assuming error without checking code carefully

4. Identify the error in this Elevator class snippet:

class Elevator:
    def __init__(self, current_floor):
        self.current_floor = current_floor

    def move_to(self, floor):
        current_floor = floor

medium

A. Indentation error in move_to method

B. Missing return statement in move_to method

C. Constructor should not have parameters

D. The move_to method updates a local variable, not the elevator's floor

Solution

1. Step 1: Analyze move_to method

   The method assigns current_floor = floor without self., so it changes a local variable only.

2. Step 2: Understand instance variable update

   To update the elevator's floor, it should be self.current_floor = floor.

3. Final Answer:

   The move_to method updates a local variable, not the elevator's floor -> Option D

4. Quick Check:

   Missing self. means local variable used [OK]

Hint: Use self. to update instance variables inside methods [OK]

Common Mistakes:

• Forgetting self. prefix
• Thinking return is needed to update state
• Assuming indentation is wrong without checking

5. In designing an elevator system with Elevator, Floor, and Request classes, which approach best handles multiple simultaneous requests efficiently?

hard

A. Use a priority queue in Elevator to process requests by nearest floor and direction

B. Process requests in the order they arrive without sorting

C. Assign each request to a random elevator immediately

D. Ignore direction and always move elevators to the highest requested floor first

Solution

1. Step 1: Understand multiple request handling

   Efficient elevator systems prioritize requests to minimize travel and wait time.

2. Step 2: Evaluate options for request processing

   Using a priority queue to pick nearest floors and matching direction optimizes movement. Others cause inefficiency or randomness.

3. Final Answer:

   Use a priority queue in Elevator to process requests by nearest floor and direction -> Option A

4. Quick Check:

   Priority queue for nearest requests = Use a priority queue in Elevator to process requests by nearest floor and direction [OK]

Hint: Prioritize nearest requests with direction for efficient elevator movement [OK]

Common Mistakes:

• Ignoring direction leads to inefficient routes
• Random assignment causes delays
• Processing requests strictly by arrival order wastes time