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 31000 calls will be made to addCarThe #1603 Design Parking System problem focuses on simulating a simple parking management system. The parking lot supports three types of cars: big, medium, and small. The key idea is to track the remaining available slots for each car type and update them as cars arrive.
A clean approach is to store the capacity for each car type using simple counters. When the system is initialized, these counters represent the total available spaces. Each time the addCar operation is called, check the counter corresponding to the requested car type. If space is available, decrement the counter and return success; otherwise, return failure.
This design works well because it avoids unnecessary data structures and directly models the parking constraints. Since every operation only checks or updates a small fixed set of counters, the solution achieves constant time performance and minimal memory usage.
| Approach | Time Complexity | Space Complexity |
|---|---|---|
| Counter-based Simulation | O(1) per operation | O(1) |
Think Software
Use these hints if you're stuck. Try solving on your own first.
Record number of parking slots still available for each car type.
This approach leverages an array to manage the count of available parking slots for each type of car. The array indices correspond to the car types: index 0 for big cars, index 1 for medium, and index 2 for small. The addCar function decrements the corresponding index if space is available.
Time Complexity: O(1) for each addCar operation as we are directly accessing an array element.
Space Complexity: O(1) as only a fixed-size array is used.
1public class ParkingSystem {
2 private int[] slots;
3
4 public ParkingSystem(int big, int medium, int small) {
5 slots = new int[] {big, medium, small};
6 }
7
8 public bool AddCar(int carType) {
9 if (slots[carType - 1] > 0) {
10 slots[carType - 1]--;
11 return true;
12 }
13 return false;
14 }
}In C#, an array tracks the count of slots. The AddCar method validates the request and adjusts the available count appropriately, leveraging array indexing.
This method uses distinct variables to handle each type of car's parking slots. This approach makes the code very clear for small data sets. While this isn't necessarily more efficient than the array method for this particular problem, it offers an alternative for simple systems where explicit clarity is beneficial.
Time Complexity: O(1) for checking and updating.
Space Complexity: O(1) as three variables track the state.
1
Watch expert explanations and walkthroughs
Practice problems asked by these companies to ace your technical interviews.
Explore More ProblemsJot down your thoughts, approach, and key learnings
Yes, this type of design and simulation problem is common in coding interviews, especially for testing object-oriented thinking and basic system design logic. It is often used as an introductory design question.
Simple integer counters or a small array are sufficient for this problem. Since there are only three parking categories, using direct counters provides fast access and minimal overhead compared to more complex structures.
The optimal approach is to maintain counters for each parking type: big, medium, and small. When a car arrives, check the corresponding counter and decrement it if space is available. This keeps every operation constant time and very efficient.
Each operation only checks and updates a fixed number of counters. There are no loops or growing data structures, so the time required remains constant regardless of how many operations are performed.
This C implementation uses separate integer variables to track each type of parking slot. Each addCar operation checks the respective variable based on car type and decrements it if possible.