Design Parking System

Design a parking system for a parking lot. The parking lot has three kinds of parking spaces: big, medium, and small, with a fixed number of slots for each size.

Implement the ParkingSystem class:

• ParkingSystem(int big, int medium, int small) Initializes object of the ParkingSystem class. The number of slots for each parking space are given as part of the constructor.
• bool addCar(int carType) Checks whether there is a parking space of carType for the car that wants to get into the parking lot. carType can be of three kinds: big, medium, or small, which are represented by 1, 2, and 3 respectively. A car can only park in a parking space of its carType. If there is no space available, return false, else park the car in that size space and return true.

Example:

Input
["ParkingSystem", "addCar", "addCar", "addCar", "addCar"]
[[1, 1, 0], [1], [2], [3], [1]]
Output
[null, true, true, false, false]

Explanation
ParkingSystem parkingSystem = new ParkingSystem(1, 1, 0);
parkingSystem.addCar(1); // return true because there is 1 available slot for a big car
parkingSystem.addCar(2); // return true because there is 1 available slot for a medium car
parkingSystem.addCar(3); // return false because there is no available slot for a small car
parkingSystem.addCar(1); // return false because there is no available slot for a big car. It is already occupied.

class ParkingSystem:

    def __init__(self, big: int, medium: int, small: int):
        self.spaces = {1: big, 2: medium, 3: small}

    def addCar(self, carType: int) -> bool:
        if self.spaces[carType] > 0:
            self.spaces[carType] -= 1
            return True
        else:
            return False


# Your ParkingSystem object will be instantiated and called as such:
# obj = ParkingSystem(big, medium, small)
# param_1 = obj.addCar(carType)

Naive Approach

The provided code represents the optimal approach directly, as the problem constraints are small enough that a more complex solution is unnecessary. A more naive solution would involve using separate variables for each car type instead of a dictionary, but this doesn't fundamentally change the time or space complexity.

Optimal Approach

The optimal approach uses a dictionary to store the number of available spaces for each car type. The addCar method simply checks if there is an available space for the given car type and, if so, decrements the count and returns true. Otherwise, it returns false.

Big O Runtime Analysis

• __init__: O(1) - Initializes the ParkingSystem object with a fixed number of spaces.
• addCar: O(1) - Accessing a dictionary element by key and decrementing its value are both constant-time operations.

Big O Space Analysis

• __init__: O(1) - The space used is constant, as we only store three integer values in a dictionary, regardless of the input.
• addCar: O(1) - No additional space is used during the execution of the addCar method.

Edge Cases

1. Invalid carType: The problem statement specifies that carType will always be 1, 2, or 3. However, in a real-world scenario, you might want to add validation to handle invalid car types (e.g., raise an exception or return false).
2. Zero Initial Spaces: The problem allows for zero initial spaces for any car type. The code handles this correctly, as it will simply return false if addCar is called for a car type with no available spaces.
3. Concurrent Access: If the parking system is used in a multi-threaded environment, you might need to add synchronization mechanisms (e.g., locks) to prevent race conditions when multiple threads try to add cars simultaneously. This isn't covered in the problem description.