Parking Lot System

Introduction

In this comprehensive case study, we’ll design a Parking Lot System from scratch using the systematic 8-step approach. This is one of the most popular LLD interview problems, and mastering it will give you a solid foundation for tackling similar resource management problems.

Why This Problem?

Parking Lot System is perfect for learning LLD because it involves:

• Resource Management - Limited spots, assignment, and release
• Multiple Design Patterns - Singleton, Strategy, Factory
• Real-world Complexity - Concurrency, edge cases, extensibility
• Clear Boundaries - Well-defined scope, easy to understand

---

Problem Statement

Design a Parking Lot System that can:

• Support multiple levels/floors, each with a certain number of parking spots
• Support different types of vehicles (cars, motorcycles, trucks)
• Assign parking spots to vehicles upon entry
• Release spots when vehicles exit
• Track real-time availability of parking spots
• Handle multiple entry and exit points with concurrent access
• Calculate fees based on parking duration

---

Step 1: Clarify Requirements

Before designing, let’s ask the right questions!

Clarifying Questions

Functional Requirements:

1. Vehicle Types: What types of vehicles? → Cars, Motorcycles, Trucks
2. Spot Types: Do spots have different sizes? → Yes, spots are sized (Small, Medium, Large)
3. Spot Assignment: How should spots be assigned? → Based on vehicle size compatibility
4. Multiple Levels: How many floors? → Configurable, multiple floors supported
5. Entry/Exit: Multiple gates? → Yes, multiple entry and exit points
6. Billing: How is billing calculated? → Time-based (per hour)

Non-Functional Requirements:

1. Concurrency: Multiple vehicles can enter/exit simultaneously → Yes, thread safety needed
2. Scalability: How many spots? → Configurable, should handle hundreds
3. Availability: Real-time spot availability → Yes, must be accurate

Edge Cases to Consider:

• What if parking lot is full?
• What if invalid vehicle type?
• What if vehicle tries to park in wrong-sized spot?
• What if ticket is invalid or already used?
• What if multiple vehicles try to park simultaneously?

Requirements Summary

---

Step 2: Identify Actors

Actors are external entities that interact with the system.

Who Uses This System?

Primary Actors:

1. Driver/Customer - Enters parking lot, parks vehicle, exits and pays
2. Parking Attendant - (Future) Manually handles special cases
3. System Administrator - (Future) Configures pricing, manages spots

Secondary Actors:

• Payment System - (Future) External payment gateway
• Notification System - (Future) Sends alerts/notifications

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:

• Driver (Actor) uses ParkingLotSystem (Entity)
• Vehicle is an Entity, not an Actor (it’s data, not a user)

---

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. ParkingLotSystem - Main orchestrator
2. ParkingFloor - Represents a level/floor
3. ParkingSpot - Individual parking space
4. Vehicle - Abstract representation of vehicles
5. ParkingTicket - Links vehicle to spot, tracks time
6. VehicleSize - Enum for size types

Entity Relationships

---

Step 4: Assign Responsibilities

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

Responsibility Assignment

ParkingLotSystem:

• Manage parking floors
• Coordinate vehicle parking/unparking
• Track active tickets
• Delegate fee calculation to strategy
• Delegate spot finding to strategy

ParkingFloor:

• Manage spots on a specific level
• Provide spot lookup by ID
• Return list of spots

ParkingSpot:

• Track its own occupancy state
• Validate if vehicle can fit
• Park/unpark vehicle

ParkingTicket:

• Store entry/exit timestamps
• Link vehicle to spot
• Calculate parking duration

Vehicle:

• Store vehicle information (license, size)
• Provide vehicle type information

Responsibility Visualization

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

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

• ParkingSpot changes only when spot logic changes
• ParkingTicket changes only when ticket tracking logic changes
• ParkingLotSystem changes only when orchestration logic changes

---

Step 5: Design Class Diagrams

Class diagrams show structure, relationships, and design patterns.

Complete Class Diagram

classDiagram
    class ParkingLotSystem {
        -ParkingLotSystem instance
        -List~ParkingFloor~ floors
        -Map~String,ParkingTicket~ activeTickets
        -FeeStrategy feeStrategy
        -ParkingStrategy parkingStrategy
        +getInstance() ParkingLotSystem
        +addFloor(ParkingFloor) void
        +parkVehicle(Vehicle) Optional~ParkingTicket~
        +unparkVehicle(String) Optional~Double~
        +setFeeStrategy(FeeStrategy) void
        +setParkingStrategy(ParkingStrategy) void
    }
    
    class ParkingFloor {
        -int floorNumber
        -Map~String,ParkingSpot~ spots
        +addSpot(ParkingSpot) void
        +getSpots() List~ParkingSpot~
    }
    
    class ParkingSpot {
        -String spotId
        -VehicleSize spotSize
        -boolean isOccupied
        -Vehicle parkedVehicle
        +canFitVehicle(Vehicle) boolean
        +parkVehicle(Vehicle) void
        +unparkVehicle() void
        +isAvailable() boolean
    }
    
    class ParkingTicket {
        -String ticketId
        -Vehicle vehicle
        -ParkingSpot spot
        -long entryTimestamp
        -long exitTimestamp
        +getDurationInHours() long
        +setExitTimestamp(long) void
    }
    
    class Vehicle {
        <<abstract>>
        -String licenseNumber
        -VehicleSize size
        +getSize() VehicleSize
        +getLicenseNumber() String
    }
    
    class Car {
        +Car(String)
    }
    
    class Truck {
        +Truck(String)
    }
    
    class Bike {
        +Bike(String)
    }
    
    class VehicleSize {
        <<enumeration>>
        SMALL
        MEDIUM
        LARGE
    }
    
    class FeeStrategy {
        <<interface>>
        +calculateFee(ParkingTicket) double
    }
    
    class ParkingStrategy {
        <<interface>>
        +findSpot(List~ParkingFloor~, Vehicle) Optional~ParkingSpot~
    }
    
    class FlatRateFeeStrategy {
        -double RATE_PER_HOUR
        +calculateFee(ParkingTicket) double
    }
    
    class NearestFirstStrategy {
        +findSpot(List~ParkingFloor~, Vehicle) Optional~ParkingSpot~
    }
    
    class VehicleFactory {
        +createVehicle(VehicleSize, String) Vehicle
    }
    
    ParkingLotSystem "1" *-- "many" ParkingFloor : contains
    ParkingLotSystem "1" *-- "many" ParkingTicket : manages
    ParkingLotSystem --> FeeStrategy : uses
    ParkingLotSystem --> ParkingStrategy : uses
    ParkingFloor "1" *-- "many" ParkingSpot : contains
    ParkingSpot --> Vehicle : references
    ParkingTicket --> Vehicle : references
    ParkingTicket --> ParkingSpot : references
    Vehicle <|-- Car
    Vehicle <|-- Truck
    Vehicle <|-- Bike
    Vehicle --> VehicleSize : has
    ParkingSpot --> VehicleSize : has
    FeeStrategy <|.. FlatRateFeeStrategy
    ParkingStrategy <|.. NearestFirstStrategy
    VehicleFactory ..> Vehicle : creates

Design Patterns Used

1. Singleton Pattern - ParkingLotSystem

• Ensures single instance across multiple gates
• Prevents data inconsistency

2. Strategy Pattern - FeeStrategy & ParkingStrategy

• Encapsulates algorithms (fee calculation, spot finding)
• Allows runtime swapping of strategies

3. Factory Pattern - VehicleFactory

• Centralizes vehicle creation
• Decouples client from concrete vehicle classes

4. Inheritance - Vehicle hierarchy

• Code reuse for common vehicle attributes
• Polymorphism for different vehicle types

---

Step 6: Define Contracts & APIs

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

Core Interfaces

Python

FeeStrategy Interface:

interfaces.py

interface FeeStrategy:
    """
    Strategy for calculating parking fees.
    Different implementations can use different pricing models.
    """
    def calculate_fee(ticket: ParkingTicket) -> float:
        """
        Calculate parking fee based on ticket information.

        Args:
            ticket: Parking ticket with entry/exit timestamps

        Returns:
            float: Calculated fee amount

        Raises:
            InvalidTicketException: If ticket is invalid
        """
        pass

ParkingStrategy Interface:

interface ParkingStrategy:
    """
    Strategy for finding parking spots.
    Different implementations can use different selection algorithms.
    """
    def find_spot(floors: List[ParkingFloor], vehicle: Vehicle) -> Optional[ParkingSpot]:
        """
        Find an available parking spot for the vehicle.

        Args:
            floors: List of parking floors to search
            vehicle: Vehicle to park

        Returns:
            Optional[ParkingSpot]: Available spot if found, None otherwise
        """
        pass

Java

FeeStrategy Interface:

Interfaces.java

interface FeeStrategy {
    /**
     * Calculate parking fee based on ticket information.
     * @param ticket Parking ticket with entry/exit timestamps
     * @return Calculated fee amount
     * @throws InvalidTicketException If ticket is invalid
     */
    double calculateFee(ParkingTicket ticket);
}

ParkingStrategy Interface:

interface ParkingStrategy {
    /**
     * Find an available parking spot for the vehicle.
     * @param floors List of parking floors to search
     * @param vehicle Vehicle to park
     * @return Available spot if found, empty Optional otherwise
     */
    Optional<ParkingSpot> findSpot(List<ParkingFloor> floors, Vehicle vehicle);
}

Core Class Contracts

Python

ParkingLotSystem:

parking_lot_system.py

class ParkingLotSystem:
    def get_instance() -> ParkingLotSystem:
        """
        Get singleton instance of parking lot system.

        Returns:
            ParkingLotSystem: The single instance
        """
        pass

    def park_vehicle(vehicle: Vehicle) -> Optional[ParkingTicket]:
        """
        Park a vehicle and return a ticket.

        Args:
            vehicle: Vehicle to park

        Returns:
            Optional[ParkingTicket]: Ticket if parking successful, None if no spots available

        Raises:
            InvalidVehicleException: If vehicle is invalid
        """
        pass

    def unpark_vehicle(ticket_id: str) -> Optional[float]:
        """
        Unpark a vehicle and calculate fee.

        Args:
            ticket_id: Ticket ID from parking

        Returns:
            Optional[float]: Fee amount if successful, None if ticket invalid

        Raises:
            InvalidTicketException: If ticket doesn't exist or already used
        """
        pass

    def set_fee_strategy(strategy: FeeStrategy) -> None:
        """Set the fee calculation strategy."""
        pass

    def set_parking_strategy(strategy: ParkingStrategy) -> None:
        """Set the parking spot selection strategy."""
        pass

ParkingSpot:

class ParkingSpot:
    def can_fit_vehicle(vehicle: Vehicle) -> bool:
        """
        Check if vehicle can fit in this spot.

        Args:
            vehicle: Vehicle to check

        Returns:
            bool: True if vehicle fits and spot is available
        """
        pass

    def park_vehicle(vehicle: Vehicle) -> None:
        """
        Park vehicle in this spot.

        Args:
            vehicle: Vehicle to park

        Raises:
            SpotOccupiedException: If spot is already occupied
            VehicleSizeMismatchException: If vehicle doesn't fit
        """
        pass

    def unpark_vehicle() -> None:
        """
        Remove vehicle from spot.

        Raises:
            SpotEmptyException: If spot is not occupied
        """
        pass

Java

ParkingLotSystem:

ParkingLotSystem.java

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

    /**
     * Park a vehicle and return a ticket.
     * @param vehicle Vehicle to park
     * @return Ticket if parking successful, empty Optional if no spots available
     * @throws InvalidVehicleException If vehicle is invalid
     */
    public Optional<ParkingTicket> parkVehicle(Vehicle vehicle);

    /**
     * Unpark a vehicle and calculate fee.
     * @param ticketId Ticket ID from parking
     * @return Fee amount if successful, empty Optional if ticket invalid
     * @throws InvalidTicketException If ticket doesn't exist or already used
     */
    public Optional<Double> unparkVehicle(String ticketId);

    /** Set the fee calculation strategy. */
    public void setFeeStrategy(FeeStrategy strategy);

    /** Set the parking spot selection strategy. */
    public void setParkingStrategy(ParkingStrategy strategy);
}

ParkingSpot:

class ParkingSpot {
    /**
     * Check if vehicle can fit in this spot.
     * @param vehicle Vehicle to check
     * @return True if vehicle fits and spot is available
     */
    public boolean canFitVehicle(Vehicle vehicle);

    /**
     * Park vehicle in this spot.
     * @param vehicle Vehicle to park
     * @throws SpotOccupiedException If spot is already occupied
     * @throws VehicleSizeMismatchException If vehicle doesn't fit
     */
    public void parkVehicle(Vehicle vehicle);

    /**
     * Remove vehicle from spot.
     * @throws SpotEmptyException If spot is not occupied
     */
    public void unparkVehicle();
}

Contract Visualization

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

• Be explicit - Clear parameter types and return types
• Document exceptions - What can go wrong?
• Keep it simple - Don’t over-complicate
• Think about callers - What do they need?

---

Step 7: Handle Edge Cases

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

Critical Edge Cases

1. Parking Lot is Full

• Return None or Optional.empty() instead of crashing
• Provide clear error message
• Consider waitlist for future enhancement

2. Invalid Vehicle Type

• Validate vehicle type before processing
• Return appropriate exception
• Don’t allow parking if vehicle type not supported

3. Size Mismatch

• Check spot size compatibility before parking
• Large vehicle cannot park in small spot
• Small vehicle can park in larger spot (if allowed)

4. Invalid Ticket

• Validate ticket exists in active tickets
• Check ticket hasn’t been used already
• Handle ticket expiration (if applicable)

5. Concurrent Access

• Multiple gates accessing same system simultaneously
• Race condition: Two vehicles assigned same spot
• Solution: Thread-safe operations (synchronization)

6. Payment Failure

• What if payment fails during unpark?
• Don’t release spot if payment fails
• Retry mechanism or manual intervention

Edge Case Handling Flow

Thread Safety Considerations

Python

thread_safe_parking.py

# Simplified thread-safe parking
class ParkingLotSystem:
    def __init__(self):
        self._lock = threading.Lock()
        self.active_tickets = {}
        self.floors = []

    def park_vehicle(self, vehicle: Vehicle) -> Optional[ParkingTicket]:
        with self._lock:  # Critical section
            spot = self._find_available_spot(vehicle)
            if not spot:
                return None

            # Double-check after acquiring lock
            if not spot.can_fit_vehicle(vehicle):
                return None

            spot.park_vehicle(vehicle)
            ticket = ParkingTicket(vehicle, spot)
            self.active_tickets[ticket.ticket_id] = ticket
            return ticket

Java

ThreadSafeParking.java

// Simplified thread-safe parking
class ParkingLotSystem {
    private final ReentrantLock lock = new ReentrantLock();
    private Map<String, ParkingTicket> activeTickets = new HashMap<>();
    private List<ParkingFloor> floors = new ArrayList<>();

    public Optional<ParkingTicket> parkVehicle(Vehicle vehicle) {
        lock.lock(); // Critical section
        try {
            Optional<ParkingSpot> spotOpt = findAvailableSpot(vehicle);
            if (!spotOpt.isPresent()) {
                return Optional.empty();
            }

            ParkingSpot spot = spotOpt.get();
            // Double-check after acquiring lock
            if (!spot.canFitVehicle(vehicle)) {
                return Optional.empty();
            }

            spot.parkVehicle(vehicle);
            ParkingTicket ticket = new ParkingTicket(vehicle, spot);
            activeTickets.put(ticket.getTicketId(), ticket);
            return Optional.of(ticket);
        } finally {
            lock.unlock();
        }
    }
}

Edge Case Checklist

Always think about:

• What if input is null/empty?
• What if system is full?
• What if something fails?
• What if multiple users?
• What if invalid state?
• What if concurrent access?

---

Step 8: Code Implementation

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

Complete Implementation

Python

parking_lot_complete.py

from abc import ABC, abstractmethod
from enum import Enum
from typing import Optional, List, Dict
import threading
import uuid
import time

# =====================
# ENUMERATION
# =====================

class VehicleSize(Enum):
    SMALL = "SMALL"
    MEDIUM = "MEDIUM"
    LARGE = "LARGE"

# =====================
# INTERFACES (Strategy Pattern)
# =====================

class FeeStrategy(ABC):
    """Strategy interface for fee calculation."""

    @abstractmethod
    def calculate_fee(self, ticket: 'ParkingTicket') -> float:
        pass

class ParkingStrategy(ABC):
    """Strategy interface for spot selection."""

    @abstractmethod
    def find_spot(self, floors: List['ParkingFloor'], vehicle: 'Vehicle') -> Optional['ParkingSpot']:
        pass

# =====================
# CORE ENTITIES
# =====================

class Vehicle(ABC):
    """Abstract base class for vehicles."""

    def __init__(self, license_number: str, size: VehicleSize):
        self.license_number = license_number
        self.size = size

    def get_size(self) -> VehicleSize:
        return self.size

    def get_license_number(self) -> str:
        return self.license_number

class Car(Vehicle):
    def __init__(self, license_number: str):
        super().__init__(license_number, VehicleSize.MEDIUM)

class Truck(Vehicle):
    def __init__(self, license_number: str):
        super().__init__(license_number, VehicleSize.LARGE)

class Bike(Vehicle):
    def __init__(self, license_number: str):
        super().__init__(license_number, VehicleSize.SMALL)

class ParkingSpot:
    """Represents a single parking spot."""

    def __init__(self, spot_id: str, spot_size: VehicleSize):
        self.spot_id = spot_id
        self.spot_size = spot_size
        self.is_occupied = False
        self.parked_vehicle: Optional[Vehicle] = None

    def can_fit_vehicle(self, vehicle: Vehicle) -> bool:
        """Check if vehicle can fit in this spot."""
        return (not self.is_occupied and
                self.spot_size.value >= vehicle.get_size().value)

    def park_vehicle(self, vehicle: Vehicle) -> None:
        """Park vehicle in this spot."""
        if not self.can_fit_vehicle(vehicle):
            raise ValueError(f"Vehicle {vehicle.get_license_number()} cannot fit in spot {self.spot_id}")

        self.parked_vehicle = vehicle
        self.is_occupied = True

    def unpark_vehicle(self) -> None:
        """Remove vehicle from spot."""
        if not self.is_occupied:
            raise ValueError(f"Spot {self.spot_id} is not occupied")

        self.parked_vehicle = None
        self.is_occupied = False

    def is_available(self) -> bool:
        return not self.is_occupied

class ParkingFloor:
    """Represents a parking floor/level."""

    def __init__(self, floor_number: int):
        self.floor_number = floor_number
        self.spots: Dict[str, ParkingSpot] = {}

    def add_spot(self, spot: ParkingSpot) -> None:
        """Add a parking spot to this floor."""
        self.spots[spot.spot_id] = spot

    def get_spots(self) -> List[ParkingSpot]:
        """Get all spots on this floor."""
        return list(self.spots.values())

class ParkingTicket:
    """Represents a parking ticket."""

    def __init__(self, vehicle: Vehicle, spot: ParkingSpot):
        self.ticket_id = str(uuid.uuid4())
        self.vehicle = vehicle
        self.spot = spot
        self.entry_timestamp = time.time()
        self.exit_timestamp: Optional[float] = None

    def set_exit_timestamp(self, timestamp: float) -> None:
        """Set exit timestamp when vehicle leaves."""
        self.exit_timestamp = timestamp

    def get_duration_in_hours(self) -> float:
        """Calculate parking duration in hours."""
        if self.exit_timestamp is None:
            return (time.time() - self.entry_timestamp) / 3600
        return (self.exit_timestamp - self.entry_timestamp) / 3600

# =====================
# STRATEGY IMPLEMENTATIONS
# =====================

class FlatRateFeeStrategy(FeeStrategy):
    """Flat rate fee calculation: $2 per hour."""

    RATE_PER_HOUR = 2.0

    def calculate_fee(self, ticket: ParkingTicket) -> float:
        hours = max(1, ticket.get_duration_in_hours())
        return hours * self.RATE_PER_HOUR

class NearestFirstStrategy(ParkingStrategy):
    """Find nearest available spot (first available)."""

    def find_spot(self, floors: List[ParkingFloor], vehicle: Vehicle) -> Optional[ParkingSpot]:
        for floor in floors:
            for spot in floor.get_spots():
                if spot.can_fit_vehicle(vehicle):
                    return spot
        return None

# =====================
# FACTORY PATTERN
# =====================

class VehicleFactory:
    """Factory for creating vehicles."""

    @staticmethod
    def create_vehicle(size: VehicleSize, license_number: str) -> Vehicle:
        if size == VehicleSize.SMALL:
            return Bike(license_number)
        elif size == VehicleSize.MEDIUM:
            return Car(license_number)
        elif size == VehicleSize.LARGE:
            return Truck(license_number)
        else:
            raise ValueError(f"Unknown vehicle size: {size}")

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

class ParkingLotSystem:
    """Main parking lot system (Singleton)."""

    _instance: Optional['ParkingLotSystem'] = 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.floors: List[ParkingFloor] = []
        self.active_tickets: Dict[str, ParkingTicket] = {}
        self.fee_strategy: FeeStrategy = FlatRateFeeStrategy()
        self.parking_strategy: ParkingStrategy = NearestFirstStrategy()
        self._operation_lock = threading.Lock()
        self._initialized = True

    def add_floor(self, floor: ParkingFloor) -> None:
        """Add a parking floor to the system."""
        self.floors.append(floor)

    def set_fee_strategy(self, strategy: FeeStrategy) -> None:
        """Set the fee calculation strategy."""
        self.fee_strategy = strategy

    def set_parking_strategy(self, strategy: ParkingStrategy) -> None:
        """Set the parking spot selection strategy."""
        self.parking_strategy = strategy

    def park_vehicle(self, vehicle: Vehicle) -> Optional[ParkingTicket]:
        """
        Park a vehicle and return a ticket.
        Thread-safe operation.
        """
        with self._operation_lock:
            spot = self.parking_strategy.find_spot(self.floors, vehicle)

            if not spot:
                print(f"No spot available for vehicle {vehicle.get_license_number()}")
                return None

            # Double-check after acquiring lock
            if not spot.can_fit_vehicle(vehicle):
                print(f"Spot {spot.spot_id} no longer available")
                return None

            spot.park_vehicle(vehicle)
            ticket = ParkingTicket(vehicle, spot)
            self.active_tickets[ticket.ticket_id] = ticket

            print(f"Vehicle {vehicle.get_license_number()} parked at {spot.spot_id}")
            return ticket

    def unpark_vehicle(self, ticket_id: str) -> Optional[float]:
        """
        Unpark a vehicle and calculate fee.
        Thread-safe operation.
        """
        with self._operation_lock:
            if ticket_id not in self.active_tickets:
                print(f"Invalid ticket: {ticket_id}")
                return None

            ticket = self.active_tickets.pop(ticket_id)
            ticket.spot.unpark_vehicle()
            ticket.set_exit_timestamp(time.time())

            fee = self.fee_strategy.calculate_fee(ticket)
            print(f"Vehicle {ticket.vehicle.get_license_number()} unparked. Fee: ${fee:.2f}")
            return fee

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

if __name__ == "__main__":
    # Get singleton instance
    parking_lot = ParkingLotSystem()

    # Setup parking lot
    floor1 = ParkingFloor(1)
    floor1.add_spot(ParkingSpot("1-A", VehicleSize.SMALL))
    floor1.add_spot(ParkingSpot("1-B", VehicleSize.MEDIUM))
    floor1.add_spot(ParkingSpot("1-C", VehicleSize.LARGE))
    parking_lot.add_floor(floor1)

    # Create vehicles using factory
    car = VehicleFactory.create_vehicle(VehicleSize.MEDIUM, "ABC-123")
    truck = VehicleFactory.create_vehicle(VehicleSize.LARGE, "XYZ-999")

    # Park vehicles
    ticket1 = parking_lot.park_vehicle(car)
    ticket2 = parking_lot.park_vehicle(truck)

    # Simulate time passing
    time.sleep(2)  # 2 seconds = minimal charge

    # Unpark vehicles
    if ticket1:
        fee1 = parking_lot.unpark_vehicle(ticket1.ticket_id)
        print(f"Fee charged: ${fee1:.2f}")

Java

ParkingLotComplete.java

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantLock;

// =====================
// ENUMERATION
// =====================
enum VehicleSize {
    SMALL, MEDIUM, LARGE
}

// =====================
// INTERFACES (Strategy Pattern)
// =====================

interface FeeStrategy {
    double calculateFee(ParkingTicket ticket);
}

interface ParkingStrategy {
    Optional<ParkingSpot> findSpot(List<ParkingFloor> floors, Vehicle vehicle);
}

// =====================
// CORE ENTITIES
// =====================

abstract class Vehicle {
    protected String licenseNumber;
    protected VehicleSize size;

    public Vehicle(String licenseNumber, VehicleSize size) {
        this.licenseNumber = licenseNumber;
        this.size = size;
    }

    public VehicleSize getSize() { return size; }
    public String getLicenseNumber() { return licenseNumber; }
}

class Car extends Vehicle {
    public Car(String licenseNumber) {
        super(licenseNumber, VehicleSize.MEDIUM);
    }
}

class Truck extends Vehicle {
    public Truck(String licenseNumber) {
        super(licenseNumber, VehicleSize.LARGE);
    }
}

class Bike extends Vehicle {
    public Bike(String licenseNumber) {
        super(licenseNumber, VehicleSize.SMALL);
    }
}

class ParkingSpot {
    private String spotId;
    private VehicleSize spotSize;
    private boolean isOccupied;
    private Vehicle parkedVehicle;

    public ParkingSpot(String spotId, VehicleSize spotSize) {
        this.spotId = spotId;
        this.spotSize = spotSize;
        this.isOccupied = false;
    }

    public boolean canFitVehicle(Vehicle vehicle) {
        return !isOccupied &&
               spotSize.ordinal() >= vehicle.getSize().ordinal();
    }

    public void parkVehicle(Vehicle vehicle) {
        if (!canFitVehicle(vehicle)) {
            throw new IllegalArgumentException(
                "Vehicle " + vehicle.getLicenseNumber() +
                " cannot fit in spot " + spotId
            );
        }
        this.parkedVehicle = vehicle;
        this.isOccupied = true;
    }

    public void unparkVehicle() {
        if (!isOccupied) {
            throw new IllegalStateException("Spot " + spotId + " is not occupied");
        }
        this.parkedVehicle = null;
        this.isOccupied = false;
    }

    public String getSpotId() { return spotId; }
    public boolean isOccupied() { return isOccupied; }
}

class ParkingFloor {
    private int floorNumber;
    private Map<String, ParkingSpot> spots;

    public ParkingFloor(int floorNumber) {
        this.floorNumber = floorNumber;
        this.spots = new HashMap<>();
    }

    public void addSpot(ParkingSpot spot) {
        spots.put(spot.getSpotId(), spot);
    }

    public List<ParkingSpot> getSpots() {
        return new ArrayList<>(spots.values());
    }
}

class ParkingTicket {
    private String ticketId;
    private Vehicle vehicle;
    private ParkingSpot spot;
    private long entryTimestamp;
    private long exitTimestamp;

    public ParkingTicket(Vehicle vehicle, ParkingSpot spot) {
        this.ticketId = UUID.randomUUID().toString();
        this.vehicle = vehicle;
        this.spot = spot;
        this.entryTimestamp = System.currentTimeMillis();
    }

    public String getTicketId() { return ticketId; }
    public Vehicle getVehicle() { return vehicle; }
    public ParkingSpot getSpot() { return spot; }

    public long getDurationInHours() {
        long exit = exitTimestamp == 0 ? System.currentTimeMillis() : exitTimestamp;
        return (exit - entryTimestamp) / (1000 * 60 * 60);
    }

    public void setExitTimestamp(long timestamp) {
        this.exitTimestamp = timestamp;
    }
}

// =====================
// STRATEGY IMPLEMENTATIONS
// =====================

class FlatRateFeeStrategy implements FeeStrategy {
    private static final double RATE_PER_HOUR = 2.0;

    @Override
    public double calculateFee(ParkingTicket ticket) {
        long hours = Math.max(1, ticket.getDurationInHours());
        return hours * RATE_PER_HOUR;
    }
}

class NearestFirstStrategy implements ParkingStrategy {
    @Override
    public Optional<ParkingSpot> findSpot(List<ParkingFloor> floors, Vehicle vehicle) {
        for (ParkingFloor floor : floors) {
            for (ParkingSpot spot : floor.getSpots()) {
                if (spot.canFitVehicle(vehicle)) {
                    return Optional.of(spot);
                }
            }
        }
        return Optional.empty();
    }
}

// =====================
// FACTORY PATTERN
// =====================

class VehicleFactory {
    public static Vehicle createVehicle(VehicleSize size, String licenseNumber) {
        switch (size) {
            case SMALL: return new Bike(licenseNumber);
            case MEDIUM: return new Car(licenseNumber);
            case LARGE: return new Truck(licenseNumber);
            default: throw new IllegalArgumentException("Unknown vehicle size");
        }
    }
}

// =====================
// SINGLETON PATTERN - MAIN SYSTEM
// =====================

class ParkingLotSystem {
    private static volatile ParkingLotSystem instance;
    private static final Object lock = new Object();

    private List<ParkingFloor> floors;
    private Map<String, ParkingTicket> activeTickets;
    private FeeStrategy feeStrategy;
    private ParkingStrategy parkingStrategy;
    private final ReentrantLock operationLock = new ReentrantLock();

    private ParkingLotSystem() {
        this.floors = new ArrayList<>();
        this.activeTickets = new ConcurrentHashMap<>();
        this.feeStrategy = new FlatRateFeeStrategy();
        this.parkingStrategy = new NearestFirstStrategy();
    }

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

    public void addFloor(ParkingFloor floor) {
        floors.add(floor);
    }

    public void setFeeStrategy(FeeStrategy feeStrategy) {
        this.feeStrategy = feeStrategy;
    }

    public void setParkingStrategy(ParkingStrategy parkingStrategy) {
        this.parkingStrategy = parkingStrategy;
    }

    public Optional<ParkingTicket> parkVehicle(Vehicle vehicle) {
        operationLock.lock();
        try {
            Optional<ParkingSpot> spotOpt = parkingStrategy.findSpot(floors, vehicle);

            if (!spotOpt.isPresent()) {
                System.out.println("No spot available for vehicle " + vehicle.getLicenseNumber());
                return Optional.empty();
            }

            ParkingSpot spot = spotOpt.get();

            // Double-check after acquiring lock
            if (!spot.canFitVehicle(vehicle)) {
                System.out.println("Spot " + spot.getSpotId() + " no longer available");
                return Optional.empty();
            }

            spot.parkVehicle(vehicle);
            ParkingTicket ticket = new ParkingTicket(vehicle, spot);
            activeTickets.put(ticket.getTicketId(), ticket);

            System.out.println("Vehicle " + vehicle.getLicenseNumber() +
                             " parked at " + spot.getSpotId());
            return Optional.of(ticket);
        } finally {
            operationLock.unlock();
        }
    }

    public Optional<Double> unparkVehicle(String ticketId) {
        operationLock.lock();
        try {
            if (!activeTickets.containsKey(ticketId)) {
                System.out.println("Invalid ticket: " + ticketId);
                return Optional.empty();
            }

            ParkingTicket ticket = activeTickets.remove(ticketId);
            ticket.getSpot().unparkVehicle();
            ticket.setExitTimestamp(System.currentTimeMillis());

            double fee = feeStrategy.calculateFee(ticket);
            System.out.println("Vehicle " + ticket.getVehicle().getLicenseNumber() +
                             " unparked. Fee: $" + fee);
            return Optional.of(fee);
        } finally {
            operationLock.unlock();
        }
    }
}

// =====================
// DEMO
// =====================

public class ParkingLotDemo {
    public static void main(String[] args) {
        ParkingLotSystem parkingLot = ParkingLotSystem.getInstance();

        // Setup
        ParkingFloor floor1 = new ParkingFloor(1);
        floor1.addSpot(new ParkingSpot("1-A", VehicleSize.SMALL));
        floor1.addSpot(new ParkingSpot("1-B", VehicleSize.MEDIUM));
        floor1.addSpot(new ParkingSpot("1-C", VehicleSize.LARGE));
        parkingLot.addFloor(floor1);

        // Create vehicles
        Vehicle car = VehicleFactory.createVehicle(VehicleSize.MEDIUM, "ABC-123");
        Vehicle truck = VehicleFactory.createVehicle(VehicleSize.LARGE, "XYZ-999");

        // Park vehicles
        Optional<ParkingTicket> ticket1 = parkingLot.parkVehicle(car);
        Optional<ParkingTicket> ticket2 = parkingLot.parkVehicle(truck);

        // Simulate time passing
        try { Thread.sleep(1000); } catch (InterruptedException e) {}

        // Unpark vehicles
        if (ticket1.isPresent()) {
            parkingLot.unparkVehicle(ticket1.get().getTicketId());
        }
    }
}

Key Implementation Highlights

1. Singleton Pattern:

• Ensures single instance across multiple gates
• Thread-safe double-checked locking

2. Strategy Pattern:

• FeeStrategy - Swappable fee calculation algorithms
• ParkingStrategy - Swappable spot selection algorithms

3. Factory Pattern:

• VehicleFactory - Centralized vehicle creation

4. Thread Safety:

• Locks for critical sections
• Concurrent collections for shared data

5. Size Compatibility:

• Uses enum ordinal for size comparison
• Small vehicles can use larger spots

---

Design Patterns Deep Dive

Why Singleton?

Problem: Multiple gates need to see the same spot availability.

Without Singleton:

Python

singleton_bad.py

# Gate A
lot_a = ParkingLotSystem()  # Empty spots
lot_a.park_vehicle(car1)    # Parks in Spot 1

# Gate B (different instance!)
lot_b = ParkingLotSystem()  # Also empty spots
lot_b.park_vehicle(car2)     # Also tries Spot 1 - COLLISION!

Java

SingletonBad.java

// Gate A
ParkingLotSystem lotA = new ParkingLotSystem(); // Empty spots
lotA.parkVehicle(car1);    // Parks in Spot 1

// Gate B (different instance!)
ParkingLotSystem lotB = new ParkingLotSystem(); // Also empty spots
lotB.parkVehicle(car2);     // Also tries Spot 1 - COLLISION!

With Singleton:

Python

singleton_good.py

# Gate A
lot_a = ParkingLotSystem.get_instance()  # Same instance
lot_a.park_vehicle(car1)                # Parks in Spot 1

# Gate B
lot_b = ParkingLotSystem.get_instance()  # Same instance!
lot_b.park_vehicle(car2)                # Sees Spot 1 occupied, uses Spot 2

Java

SingletonGood.java

// Gate A
ParkingLotSystem lotA = ParkingLotSystem.getInstance(); // Same instance
lotA.parkVehicle(car1);                // Parks in Spot 1

// Gate B
ParkingLotSystem lotB = ParkingLotSystem.getInstance(); // Same instance!
lotB.parkVehicle(car2);                // Sees Spot 1 occupied, uses Spot 2

Why Strategy Pattern?

Problem: Fee calculation and spot selection algorithms might change.

Without Strategy:

Python

strategy_bad.py

class ParkingLotSystem:
    def calculate_fee(self, ticket):
        if is_weekend():
            return ticket.hours * 5.0
        elif is_holiday():
            return ticket.hours * 7.0
        elif ticket.vehicle.size == LARGE:
            return ticket.hours * 3.0
        else:
            return ticket.hours * 2.0
    # Adding new pricing = modifying this class ❌

Java

StrategyBad.java

class ParkingLotSystem {
    public double calculateFee(ParkingTicket ticket) {
        if (isWeekend()) {
            return ticket.getHours() * 5.0;
        } else if (isHoliday()) {
            return ticket.getHours() * 7.0;
        } else if (ticket.getVehicle().getSize() == LARGE) {
            return ticket.getHours() * 3.0;
        } else {
            return ticket.getHours() * 2.0;
        }
    }
    // Adding new pricing = modifying this class ❌
}

With Strategy:

Python

strategy_good.py

class ParkingLotSystem:
    def __init__(self):
        self.fee_strategy = FlatRateFeeStrategy()

    def set_fee_strategy(self, strategy):
        self.fee_strategy = strategy  # Swap at runtime

    def unpark_vehicle(self, ticket_id):
        fee = self.fee_strategy.calculate_fee(ticket)  # Delegates

Java

StrategyGood.java

class ParkingLotSystem {
    private FeeStrategy feeStrategy;

    public ParkingLotSystem() {
        this.feeStrategy = new FlatRateFeeStrategy();
    }

    public void setFeeStrategy(FeeStrategy strategy) {
        this.feeStrategy = strategy;  // Swap at runtime
    }

    public double unparkVehicle(String ticketId) {
        // ... get ticket ...
        double fee = this.feeStrategy.calculateFee(ticket);  // Delegates
        return fee;
    }
}

Benefits:

• Add new strategies without modifying existing code
• Test strategies independently
• Swap strategies at runtime
• Follows Open/Closed Principle

Why Factory Pattern?

Problem: Vehicle creation logic scattered across codebase.

Without Factory:

Python

factory_bad.py

# Client code everywhere
if input == "car":
    vehicle = Car(license)
elif input == "truck":
    vehicle = Truck(license)
elif input == "bike":
    vehicle = Bike(license)
# Duplicated everywhere ❌

Java

FactoryBad.java

// Client code everywhere
if (input.equals("car")) {
    vehicle = new Car(license);
} else if (input.equals("truck")) {
    vehicle = new Truck(license);
} else if (input.equals("bike")) {
    vehicle = new Bike(license);
}
// Duplicated everywhere ❌

With Factory:

Python

factory_good.py

# Centralized creation
vehicle = VehicleFactory.create_vehicle(VehicleSize.MEDIUM, license)
# Client doesn't know about Car/Truck/Bike

Java

FactoryGood.java

// Centralized creation
Vehicle vehicle = VehicleFactory.createVehicle(VehicleSize.MEDIUM, license);
// Client doesn't know about Car/Truck/Bike

---

System Flow Diagrams

Parking Flow

Unparking Flow

---

Extensibility & Future Enhancements

Easy to Extend

1. Add New Vehicle Type:

Python

new_vehicle.py

class Van(Vehicle):
    def __init__(self, license_number: str):
        super().__init__(license_number, VehicleSize.LARGE)

# Update factory
class VehicleFactory:
    @staticmethod
    def create_vehicle(size, license):
        # ... existing code ...
        # No changes needed if size already exists!

Java

NewVehicle.java

class Van extends Vehicle {
    public Van(String licenseNumber) {
        super(licenseNumber, VehicleSize.LARGE);
    }
}

// Update factory
class VehicleFactory {
    public static Vehicle createVehicle(VehicleSize size, String license) {
        // ... existing code ...
        // No changes needed if size already exists!
    }
}

2. Add New Fee Strategy:

Python

new_fee_strategy.py

class ProgressiveFeeStrategy(FeeStrategy):
    """First hour free, then $2/hour."""

    def calculate_fee(self, ticket):
        hours = ticket.get_duration_in_hours()
        if hours <= 1:
            return 0
        return (hours - 1) * 2.0

# Use it
parking_lot.set_fee_strategy(ProgressiveFeeStrategy())

Java

NewFeeStrategy.java

class ProgressiveFeeStrategy implements FeeStrategy {
    /** First hour free, then $2/hour. */

    @Override
    public double calculateFee(ParkingTicket ticket) {
        long hours = ticket.getDurationInHours();
        if (hours <= 1) {
            return 0;
        }
        return (hours - 1) * 2.0;
    }
}

// Use it
parkingLot.setFeeStrategy(new ProgressiveFeeStrategy());

3. Add New Parking Strategy:

Python

new_parking_strategy.py

class BestFitStrategy(ParkingStrategy):
    """Find smallest spot that fits vehicle."""

    def find_spot(self, floors, vehicle):
        best_spot = None
        for floor in floors:
            for spot in floor.get_spots():
                if spot.can_fit_vehicle(vehicle):
                    if best_spot is None or \
                       spot.spot_size.value < best_spot.spot_size.value:
                        best_spot = spot
        return best_spot

# Use it
parking_lot.set_parking_strategy(BestFitStrategy())

Java

NewParkingStrategy.java

class BestFitStrategy implements ParkingStrategy {
    /** Find smallest spot that fits vehicle. */

    @Override
    public Optional<ParkingSpot> findSpot(List<ParkingFloor> floors, Vehicle vehicle) {
        ParkingSpot bestSpot = null;
        for (ParkingFloor floor : floors) {
            for (ParkingSpot spot : floor.getSpots()) {
                if (spot.canFitVehicle(vehicle)) {
                    if (bestSpot == null ||
                        spot.getSpotSize().ordinal() < bestSpot.getSpotSize().ordinal()) {
                        bestSpot = spot;
                    }
                }
            }
        }
        return Optional.ofNullable(bestSpot);
    }
}

// Use it
parkingLot.setParkingStrategy(new BestFitStrategy());

Future Enhancements

1. Reservation System:

• Add Reservation class
• Modify ParkingSpot to track reservations
• Add ReservationStrategy

2. Payment Integration:

• Add PaymentStrategy interface
• Implement CreditCardPayment, CashPayment, MobilePayment

3. Access Control:

• Add AccessCard class
• Implement VIP parking, employee parking

4. Monitoring & Analytics:

• Add ParkingLotObserver (Observer pattern)
• Track occupancy rates, revenue, peak hours

---

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 - Singleton, Strategy, Factory
• Make it Extensible - Easy to add new features

Design Patterns Used

1. Singleton - Single system instance
2. Strategy - Swappable algorithms (fee, parking)
3. Factory - Centralized object creation
4. Inheritance - Vehicle hierarchy

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 Parking Lot System:

Practice Similar Problems:

• Elevator System
• Library Management System
• Restaurant Management System
• ATM System

Explore More Patterns:

• Observer Pattern (for notifications)
• Command Pattern (for operations)
• State Pattern (for spot states)

Deepen Your Understanding:

• Read about concurrency patterns
• Study database design for persistence
• Learn about distributed systems

---

Practice Makes Perfect

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

• Multiple fee strategies
• Different parking strategies
• Reservation system
• Payment integration

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