Parking Lot Simulator - Problem

Design a parking lot management system that can handle multiple floors and parking spots. The system should support basic operations like parking a vehicle, removing a vehicle, and finding where a vehicle is parked.

Your system should handle the following operations:

park(vehicle_id): Park a vehicle and return the assigned spot location
unpark(vehicle_id): Remove a vehicle from its parking spot
find_vehicle(vehicle_id): Find the location of a parked vehicle

The parking lot has a fixed number of floors and spots per floor. Vehicles should be assigned to the first available spot starting from floor 0, spot 0.

Return the results of all operations as a list of strings, where each string represents the result of the corresponding operation.

Input & Output

Example 1 — Basic Parking Operations

$ Input: floors = 2, spots_per_floor = 2, operations = ["park A1", "park B2", "find_vehicle A1", "unpark A1", "park C3"]

› Output: ["Floor 0, Spot 0", "Floor 0, Spot 1", "Floor 0, Spot 0", "Vehicle A1 removed", "Floor 0, Spot 0"]

💡 Note: A1 parks at first spot (0,0), B2 at (0,1), finding A1 returns (0,0), after unparking A1 that spot becomes available for C3

Example 2 — Full Floor Scenario

$ Input: floors = 2, spots_per_floor = 1, operations = ["park X1", "park Y2", "park Z3"]

› Output: ["Floor 0, Spot 0", "Floor 1, Spot 0", "No available spots"]

💡 Note: First two cars fill both floors (each has 1 spot), third car cannot be parked

Example 3 — Vehicle Not Found

$ Input: floors = 1, spots_per_floor = 2, operations = ["find_vehicle X1", "unpark Y2"]

› Output: ["Vehicle not found", "Vehicle not found"]

💡 Note: Both operations fail because no vehicles are parked yet

Constraints

1 ≤ floors ≤ 100
1 ≤ spots_per_floor ≤ 100
1 ≤ operations.length ≤ 1000
Vehicle IDs are unique strings of length 1-10

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 42 M Microsoft 28 🍎 Apple 18

The key insight is to use separate data structures for tracking vehicle locations and available spots rather than searching the entire parking lot each time. The hash map approach provides O(1) lookups for vehicle locations and O(1) parking assignments, making it far more efficient than brute force. Time: O(k), Space: O(n×m + v) where k is operations, n×m is parking lot size, v is parked vehicles.

Common Approaches

✓ Brute Force Search

⏱️ Time: O(n×m×k) Space: O(n×m)

For each operation, scan through all floors and spots to find available spaces or locate vehicles. This approach checks every spot individually without maintaining any smart data structures.

Hash Map Tracking

⏱️ Time: O(k) Space: O(n×m + v)

Maintain separate data structures to quickly find available spots and vehicle locations without scanning the entire parking lot each time.

Brute Force Search — Algorithm Steps

For parking: scan all spots until finding an empty one
For unparking: scan all spots to find the vehicle
For finding: scan all spots to locate the vehicle

Visualization

Tap to expand

Step-by-Step Walkthrough

Park Operation

Scan all floors and spots sequentially until finding empty spot

Find/Unpark

Search through all occupied spots to locate specific vehicle

Result

Return location or status message

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char** solution(int floors, int spotsPerFloor, char operations[][100], int opCount, int* returnSize) {
    char*** parkingLot = (char***)malloc(floors * sizeof(char**));
    for (int i = 0; i < floors; i++) {
        parkingLot[i] = (char**)malloc(spotsPerFloor * sizeof(char*));
        for (int j = 0; j < spotsPerFloor; j++) {
            parkingLot[i][j] = NULL;
        }
    }
    
    char** results = (char**)malloc(opCount * sizeof(char*));
    *returnSize = 0;
    
    for (int op = 0; op < opCount; op++) {
        char cmd[20], vehicleId[20];
        sscanf(operations[op], "%s %s", cmd, vehicleId);
        
        if (strcmp(cmd, "park") == 0) {
            int parked = 0;
            for (int floor = 0; floor < floors && !parked; floor++) {
                for (int spot = 0; spot < spotsPerFloor; spot++) {
                    if (parkingLot[floor][spot] == NULL) {
                        parkingLot[floor][spot] = (char*)malloc(20 * sizeof(char));
                        strcpy(parkingLot[floor][spot], vehicleId);
                        results[*returnSize] = (char*)malloc(50 * sizeof(char));
                        sprintf(results[*returnSize], "Floor %d, Spot %d", floor, spot);
                        (*returnSize)++;
                        parked = 1;
                        break;
                    }
                }
            }
            if (!parked) {
                results[*returnSize] = (char*)malloc(50 * sizeof(char));
                strcpy(results[*returnSize], "No available spots");
                (*returnSize)++;
            }
        }
        else if (strcmp(cmd, "unpark") == 0) {
            int found = 0;
            for (int floor = 0; floor < floors && !found; floor++) {
                for (int spot = 0; spot < spotsPerFloor; spot++) {
                    if (parkingLot[floor][spot] != NULL && strcmp(parkingLot[floor][spot], vehicleId) == 0) {
                        free(parkingLot[floor][spot]);
                        parkingLot[floor][spot] = NULL;
                        results[*returnSize] = (char*)malloc(50 * sizeof(char));
                        sprintf(results[*returnSize], "Vehicle %s removed", vehicleId);
                        (*returnSize)++;
                        found = 1;
                        break;
                    }
                }
            }
            if (!found) {
                results[*returnSize] = (char*)malloc(50 * sizeof(char));
                strcpy(results[*returnSize], "Vehicle not found");
                (*returnSize)++;
            }
        }
        else if (strcmp(cmd, "find_vehicle") == 0) {
            int found = 0;
            for (int floor = 0; floor < floors && !found; floor++) {
                for (int spot = 0; spot < spotsPerFloor; spot++) {
                    if (parkingLot[floor][spot] != NULL && strcmp(parkingLot[floor][spot], vehicleId) == 0) {
                        results[*returnSize] = (char*)malloc(50 * sizeof(char));
                        sprintf(results[*returnSize], "Floor %d, Spot %d", floor, spot);
                        (*returnSize)++;
                        found = 1;
                        break;
                    }
                }
            }
            if (!found) {
                results[*returnSize] = (char*)malloc(50 * sizeof(char));
                strcpy(results[*returnSize], "Vehicle not found");
                (*returnSize)++;
            }
        }
    }
    
    return results;
}

int main() {
    int floors, spotsPerFloor;
    scanf("%d", &floors);
    scanf("%d", &spotsPerFloor);
    
    char line[1000];
    scanf(" %[^\n]", line);
    
    // Parse operations manually
    char operations[100][100];
    int opCount = 0;
    char* token = strtok(line + 1, ","); // skip [
    while (token != NULL && opCount < 100) {
        while (*token == ' ' || *token == '"') token++;
        char* end = token + strlen(token) - 1;
        while (*end == ' ' || *end == '"' || *end == ']') end--;
        *(end + 1) = '\0';
        strcpy(operations[opCount], token);
        opCount++;
        token = strtok(NULL, ",");
    }
    
    int returnSize;
    char** result = solution(floors, spotsPerFloor, operations, opCount, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m×k)

Each operation scans up to n floors × m spots, with k operations total

✓ Linear Growth

Space Complexity

O(n×m)

Only stores the parking lot grid structure

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Parking Lot Simulator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler