System Design: #001 Design Parking Lot

Series of Classic System Design Questions For SDE Interviews.

🚗 Problem Statement

Design a parking lot system with the following features:

1. Multiple parking levels

2. Different types of parking spots (e.g., motorcycle, compact, large)

3. Different vehicle types (motorcycle, car, bus)

4. Ability to park, unpark, and check spot availability

🧱 OOP Approach in Swift:

1. Enums for Spot & Vehicle Types

enum VehicleType {
    case motorcycle
    case car
    case bus
}

enum SpotType {
    case motorcycle
    case compact
    case large
}

2. 🚙 Vehicle Base Class

class Vehicle {
    let type: VehicleType
    let licensePlate: String

    init(type: VehicleType, licensePlate: String) {
        self.type = type
        self.licensePlate = licensePlate
    }
}

3. 🅿️ Parking Spot

class ParkingSpot {
    let type: SpotType
    let spotNumber: Int
    var isOccupied: Bool = false
    var currentVehicle: Vehicle?

    init(type: SpotType, spotNumber: Int) {
        self.type = type
        self.spotNumber = spotNumber
    }

    func canFitVehicle(_ vehicle: Vehicle) -> Bool {
        switch (vehicle.type, type) {
        case (.motorcycle, _):
            return true
        case (.car, .compact), (.car, .large):
            return true
        case (.bus, .large):
            return true
        default:
            return false
        }
    }

    func park(vehicle: Vehicle) -> Bool {
        guard !isOccupied, canFitVehicle(vehicle) else { return false }
        isOccupied = true
        currentVehicle = vehicle
        return true
    }

    func unpark() {
        isOccupied = false
        currentVehicle = nil
    }
}

4. 🏢 Parking Level

class ParkingLevel {
    let levelNumber: Int
    var spots: [ParkingSpot]

    init(levelNumber: Int, spots: [ParkingSpot]) {
        self.levelNumber = levelNumber
        self.spots = spots
    }

    func park(vehicle: Vehicle) -> Bool {
        for spot in spots {
            if spot.park(vehicle: vehicle) {
                print("Parked at level \(levelNumber), spot \(spot.spotNumber)")
                return true
            }
        }
        return false
    }

    func unpark(vehicle: Vehicle) {
        for spot in spots {
            if spot.currentVehicle?.licensePlate == vehicle.licensePlate {
                spot.unpark()
                print("Unparked from level \(levelNumber), spot \(spot.spotNumber)")
                return
            }
        }
    }

    func availableSpots() -> Int {
        return spots.filter { !$0.isOccupied }.count
    }
}

5. 🏙️ Parking Lot

class ParkingLot {
    var levels: [ParkingLevel]

    init(levels: [ParkingLevel]) {
        self.levels = levels
    }

    func park(vehicle: Vehicle) -> Bool {
        for level in levels {
            if level.park(vehicle: vehicle) {
                return true
            }
        }
        print("No available spots for vehicle \(vehicle.licensePlate)")
        return false
    }

    func unpark(vehicle: Vehicle) {
        for level in levels {
            level.unpark(vehicle: vehicle)
        }
    }

    func status() {
        for level in levels {
            print("Level \(level.levelNumber): \(level.availableSpots()) spots available")
        }
    }
}

Example Usage:

let spotsLevel1 = (1...10).map { ParkingSpot(type: .compact, spotNumber: $0) }
let spotsLevel2 = (1...5).map { ParkingSpot(type: .large, spotNumber: $0) }

let level1 = ParkingLevel(levelNumber: 1, spots: spotsLevel1)
let level2 = ParkingLevel(levelNumber: 2, spots: spotsLevel2)

let parkingLot = ParkingLot(levels: [level1, level2])

let car = Vehicle(type: .car, licensePlate: "ABC123")
let bus = Vehicle(type: .bus, licensePlate: "BUS789")

parkingLot.park(vehicle: car)
parkingLot.park(vehicle: bus)

parkingLot.status()

parkingLot.unpark(vehicle: car)
parkingLot.status()

Follow Me

Rahul Goel

for further updates.