Problem

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 itscarType. If there is no space available, return false, else park the car in that size space and return true.

Examples

Example 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

**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.

Constraints

  • 0 <= big, medium, small <= 1000
  • carType is 1, 2, or 3
  • At most 1000 calls will be made to addCar

Solution

Method 1 – Array Counter for Each Car Type

Intuition

We can use an array to store the available slots for each car type (big, medium, small). For each addCar call, we check if there is an available slot for the given type and decrement the counter if possible.

Approach

  1. Store the available slots for each car type in an array of size 3.
  2. For addCar(carType), check if the corresponding slot is available (count > 0).
  3. If available, decrement the count and return true; otherwise, return false.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class ParkingSystem {
    int slots[3];
public:
    ParkingSystem(int big, int medium, int small) {
        slots[0] = big;
        slots[1] = medium;
        slots[2] = small;
    }
    bool addCar(int carType) {
        if (slots[carType-1] > 0) {
            slots[carType-1]--;
            return true;
        }
        return false;
    }
};
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

type ParkingSystem struct {
    slots [3]int
}
func Constructor(big, medium, small int) ParkingSystem {
    return ParkingSystem{[3]int{big, medium, small}}
}
func (p *ParkingSystem) AddCar(carType int) bool {
    if p.slots[carType-1] > 0 {
        p.slots[carType-1]--
        return true
    }
    return false
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class ParkingSystem {
    private int[] slots = new int[3];
    public ParkingSystem(int big, int medium, int small) {
        slots[0] = big;
        slots[1] = medium;
        slots[2] = small;
    }
    public boolean addCar(int carType) {
        if (slots[carType-1] > 0) {
            slots[carType-1]--;
            return true;
        }
        return false;
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class ParkingSystem(big: Int, medium: Int, small: Int) {
    private val slots = intArrayOf(big, medium, small)
    fun addCar(carType: Int): Boolean {
        if (slots[carType-1] > 0) {
            slots[carType-1]--
            return true
        }
        return false
    }
}
1
2
3
4
5
6
7
8

class ParkingSystem:
    def __init__(self, big: int, medium: int, small: int):
        self.slots = [big, medium, small]
    def addCar(self, carType: int) -> bool:
        if self.slots[carType-1] > 0:
            self.slots[carType-1] -= 1
            return True
        return False
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

struct ParkingSystem {
    slots: [i32; 3],
}
impl ParkingSystem {
    fn new(big: i32, medium: i32, small: i32) -> Self {
        Self { slots: [big, medium, small] }
    }
    fn add_car(&mut self, car_type: i32) -> bool {
        let idx = (car_type - 1) as usize;
        if self.slots[idx] > 0 {
            self.slots[idx] -= 1;
            true
        } else {
            false
        }
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class ParkingSystem {
    private slots: number[];
    constructor(big: number, medium: number, small: number) {
        this.slots = [big, medium, small];
    }
    addCar(carType: number): boolean {
        if (this.slots[carType-1] > 0) {
            this.slots[carType-1]--;
            return true;
        }
        return false;
    }
}

Complexity

  • ⏰ Time complexity: O(1) per operation, as all operations are direct array accesses.
  • 🧺 Space complexity: O(1), as only a fixed-size array is used.