Codestin Search App

Design Parking System - Problem

Design a Smart Parking System

You're tasked with creating a digital parking management system for a modern parking lot. This lot has three types of parking spaces: big (for trucks and SUVs), medium (for standard cars), and small (for compact cars).

Your system needs to:
• Initialize with a fixed number of slots for each parking space size
• Process incoming cars and determine if they can park
• Track available spaces in real-time

Class Requirements:
ParkingSystem(int big, int medium, int small) - Initialize the system with the number of slots for each size
bool addCar(int carType) - Try to park a car where carType is 1 (big), 2 (medium), or 3 (small)

Return true if the car can park successfully, false if no space is available for that car type.

Input & Output

example_1.py — Basic Usage

$ Input: ["ParkingSystem", "addCar", "addCar", "addCar", "addCar"] [[1, 1, 0], [1], [2], [3], [1]]

› Output: [null, true, true, false, false]

💡 Note: Initialize with 1 big, 1 medium, 0 small spaces. First big car parks (true), medium car parks (true), small car can't park (false), second big car can't park (false).

example_2.py — Full Capacity Test

$ Input: ["ParkingSystem", "addCar", "addCar", "addCar", "addCar", "addCar"] [[2, 2, 1], [1], [1], [2], [2], [3]]

› Output: [null, true, true, true, true, true]

💡 Note: Initialize with 2 big, 2 medium, 1 small space. All cars can park as we have exact capacity: 2 big cars, 2 medium cars, 1 small car.

example_3.py — Edge Case - Zero Spaces

$ Input: ["ParkingSystem", "addCar", "addCar"] [[0, 0, 1], [1], [3]]

› Output: [null, false, true]

💡 Note: No big or medium spaces available. Big car can't park (false), but small car can park in the single small space (true).

Constraints

0 ≤ big, medium, small ≤ 1000
carType is 1, 2, or 3
At most 1000 calls will be made to addCar
Important: Cars can only park in their designated size category

Visualization

Tap to expand

Understanding the Visualization

System Initialization

Set up counters: Big=2, Medium=3, Small=1 spaces available

Car Arrives

Medium car (type 2) requests parking space

Instant Check

System checks medium counter: 3 > 0, so parking is allowed

Update State

Medium counter decrements to 2, return true to car owner

Key Takeaway

🎯 Key Insight: Sometimes the simplest solution is the best! Instead of complex data structures, three integer counters provide instant O(1) access and updates, making this system incredibly efficient and scalable.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses three simple integer counters to track available spaces for each car type. When a car wants to park, we check if the appropriate counter is greater than 0, decrement it if possible, and return the result. This achieves O(1) time complexity and O(1) space complexity, making it extremely efficient regardless of parking lot size.

Common Approaches

Approach	Time	Space	Notes
✓ Array-Based Tracking	O(n)	O(n)	Use arrays to store each parked car and count available spaces by iteration
Counter-Based System (Optimal)	O(1)	O(1)	Use simple integer counters to track available spaces for each car type

Array-Based Tracking — Algorithm Steps

Create three arrays to store parked cars for each type
When adding a car, iterate through the appropriate array to count occupied spots
If available spots exist, add the car to the array
Return true if successful, false if array is full

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Arrays

Create boolean arrays for each parking type with false (available) values

Car Arrival

When a car arrives, iterate through the appropriate array

Find Space

Look for the first false value (available space)

Park Car

Set the found space to true and return success

Code -

solution.c — C

typedef struct {
    bool* bigSpaces;
    bool* mediumSpaces;
    bool* smallSpaces;
    int bigSize;
    int mediumSize;
    int smallSize;
} ParkingSystem;

ParkingSystem* parkingSystemCreate(int big, int medium, int small) {
    ParkingSystem* obj = (ParkingSystem*)malloc(sizeof(ParkingSystem));
    obj->bigSpaces = (bool*)calloc(big, sizeof(bool));
    obj->mediumSpaces = (bool*)calloc(medium, sizeof(bool));
    obj->smallSpaces = (bool*)calloc(small, sizeof(bool));
    obj->bigSize = big;
    obj->mediumSize = medium;
    obj->smallSize = small;
    return obj;
}

bool parkingSystemAddCar(ParkingSystem* obj, int carType) {
    bool* spaces;
    int size;
    
    if (carType == 1) {
        spaces = obj->bigSpaces;
        size = obj->bigSize;
    } else if (carType == 2) {
        spaces = obj->mediumSpaces;
        size = obj->mediumSize;
    } else {
        spaces = obj->smallSpaces;
        size = obj->smallSize;
    }
    
    for (int i = 0; i < size; i++) {
        if (!spaces[i]) {
            spaces[i] = true;
            return true;
        }
    }
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each addCar operation requires iterating through the array to count occupied spots

✓ Linear Growth

Space Complexity

O(n)

Need to store arrays that can hold all possible cars for each type

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~8 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Array-Based Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler