Description
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 1:
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 <= 1000carType is 1, 2, or 3- At most
1000 calls will be made to addCar
Solutions
Solution 1: Simulation
We use an array cnt of length 4 to represent the number of parking spaces for each type of car, where cnt[1], cnt[2], and cnt[3] represent the number of large, medium, and small parking spaces, respectively.
During initialization, we set cnt[1], cnt[2], and cnt[3] to the number of large, medium, and small parking spaces, respectively.
Each time a car parks, we check if there is a corresponding parking space in the parking lot. If not, we return false; otherwise, we decrement the number of corresponding parking spaces by one and return true.
The time complexity is O(1), and the space complexity is O(1).
PythonJavaC++GoTypeScriptRustC#C
class ParkingSystem:
def __init__(self, big: int, medium: int, small: int):
self.cnt = [0, big, medium, small]
def addCar(self, carType: int) -> bool:
if self.cnt[carType] == 0:
return False
self.cnt[carType] -= 1
return True
# Your ParkingSystem object will be instantiated and called as such:
# obj = ParkingSystem(big, medium, small)
# param_1 = obj.addCar(carType)(code-box)
class ParkingSystem {
private int[] cnt;
public ParkingSystem(int big, int medium, int small) {
cnt = new int[] {0, big, medium, small};
}
public boolean addCar(int carType) {
if (cnt[carType] == 0) {
return false;
}
--cnt[carType];
return true;
}
}
/**
* Your ParkingSystem object will be instantiated and called as such:
* ParkingSystem obj = new ParkingSystem(big, medium, small);
* boolean param_1 = obj.addCar(carType);
*/(code-box)
class ParkingSystem {
public:
ParkingSystem(int big, int medium, int small) {
cnt = {0, big, medium, small};
}
bool addCar(int carType) {
if (cnt[carType] == 0) {
return false;
}
--cnt[carType];
return true;
}
private:
vector<int> cnt;
};
/**
* Your ParkingSystem object will be instantiated and called as such:
* ParkingSystem* obj = new ParkingSystem(big, medium, small);
* bool param_1 = obj->addCar(carType);
*/(code-box)
type ParkingSystem struct {
cnt []int
}
func Constructor(big int, medium int, small int) ParkingSystem {
return ParkingSystem{[]int{0, big, medium, small}}
}
func (this *ParkingSystem) AddCar(carType int) bool {
if this.cnt[carType] == 0 {
return false
}
this.cnt[carType]--
return true
}
/**
* Your ParkingSystem object will be instantiated and called as such:
* obj := Constructor(big, medium, small);
* param_1 := obj.AddCar(carType);
*/(code-box)
class ParkingSystem {
private cnt: [number, number, number, number];
constructor(big: number, medium: number, small: number) {
this.cnt = [0, big, medium, small];
}
addCar(carType: number): boolean {
if (this.cnt[carType] === 0) {
return false;
}
this.cnt[carType]--;
return true;
}
}
/**
* Your ParkingSystem object will be instantiated and called as such:
* var obj = new ParkingSystem(big, medium, small)
* var param_1 = obj.addCar(carType)
*/(code-box)
struct ParkingSystem {
cnt: [i32; 4]
}
impl ParkingSystem {
fn new(big: i32, medium: i32, small: i32) -> Self {
ParkingSystem {
cnt: [0, big, medium, small],
}
}
fn add_car(&mut self, car_type: i32) -> bool {
if self.cnt[car_type as usize] == 0 {
return false;
}
self.cnt[car_type as usize] -= 1;
true
}
}(code-box)
public class ParkingSystem {
private List<int> cnt;
public ParkingSystem(int big, int medium, int small) {
cnt = new List<int>() {0 , big, medium, small};
}
public bool AddCar(int carType) {
if (cnt[carType] == 0) {
return false;
}
--cnt[carType];
return true;
}
}
/**
* Your ParkingSystem object will be instantiated and called as such:
* ParkingSystem obj = new ParkingSystem(big, medium, small);
* bool param_1 = obj.AddCar(carType);
*/(code-box)
typedef struct {
int* count;
} ParkingSystem;
ParkingSystem* parkingSystemCreate(int big, int medium, int small) {
ParkingSystem* res = malloc(sizeof(ParkingSystem));
res->count = malloc(sizeof(int) * 3);
res->count[0] = big;
res->count[1] = medium;
res->count[2] = small;
return res;
}
bool parkingSystemAddCar(ParkingSystem* obj, int carType) {
int i = carType - 1;
if (!obj->count[i]) {
return 0;
}
obj->count[i]--;
return 1;
}
void parkingSystemFree(ParkingSystem* obj) {
free(obj);
}
/**
* Your ParkingSystem struct will be instantiated and called as such:
* ParkingSystem* obj = parkingSystemCreate(big, medium, small);
* bool param_1 = parkingSystemAddCar(obj, carType);
* parkingSystemFree(obj);
*/(code-box)
