Exam Room

Exam Room - Problem

There is an exam room with n seats in a single row labeled from 0 to n - 1.

When a student enters the room, they must sit in the seat that maximizes the distance to the closest person. If there are multiple such seats, they sit in the seat with the lowest number. If no one is in the room, then the student sits at seat number 0.

Design a class that simulates the mentioned exam room.

Implement the ExamRoom class:

ExamRoom(int n) Initializes the object of the exam room with the number of the seats n.
int seat() Returns the label of the seat at which the next student will sit.
void leave(int p) Indicates that the student sitting at seat p will leave the room. It is guaranteed that there will be a student sitting at seat p.

Input & Output

Example 1 — Basic Operations

$ Input: ExamRoom(10), seat(), seat(), seat(), seat(), leave(4), seat()

› Output: [null,0,9,4,2,null,5]

💡 Note: Initialize room with 10 seats. First student sits at 0. Second at 9 (farthest from 0). Third at 4 (middle of 0-9). Fourth at 2 (middle of 0-4). Remove student at 4. Next student sits at 5 (middle of 2-9).

Example 2 — Small Room

$ Input: ExamRoom(3), seat(), seat(), seat()

› Output: [null,0,2,1]

💡 Note: Room has 3 seats. First at 0, second at 2 (end), third at 1 (middle).

Example 3 — Leave and Reseat

$ Input: ExamRoom(5), seat(), seat(), leave(0), seat()

› Output: [null,0,4,null,0]

💡 Note: First at 0, second at 4. Remove 0. Next student sits at 0 again (farthest from 4).

Constraints

1 ≤ n ≤ 10⁹
It is guaranteed that there will be a student sitting at seat p when leave(p) is called.
At most 10⁴ calls will be made to seat and leave.

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is to track occupied seats and efficiently find the position that maximizes distance to the nearest occupied seat. The brute force approach checks all empty seats (O(n) time), while the optimized approach uses sorted data structures to find gaps between occupied seats. Best approach uses ordered set: Time O(n), Space O(n).

Common Approaches

✓ Brute Force with Set

⏱️ Time: O(n) Space: O(n)

Store occupied seats in a set. For each seat() call, iterate through all positions to find the one that maximizes distance to closest occupied seat. For leave(), simply remove from set.

Ordered Set with Intervals

⏱️ Time: O(n) Space: O(n)

Keep occupied seats in sorted order. For seat(), find the largest gap between consecutive occupied seats or at the ends. Use binary search properties of ordered set for efficiency.

Brute Force with Set — Algorithm Steps

Step 1: Use set to track occupied seats
Step 2: For seat(), check all empty positions
Step 3: Calculate distance to nearest occupied seat for each position
Step 4: Return position with maximum distance (lowest index if tied)

Visualization

Tap to expand

Step-by-Step Walkthrough

Track Occupied

Use set to store occupied seat positions

Check All Empty

For each empty seat, calculate distance to nearest occupied seat

Pick Best

Choose seat with maximum distance (lowest index if tied)

Code -

solution.c — C

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

typedef struct {
    int n;
    bool* occupied;
} ExamRoom;

ExamRoom* examRoomCreate(int n) {
    ExamRoom* obj = (ExamRoom*)malloc(sizeof(ExamRoom));
    obj->n = n;
    obj->occupied = (bool*)calloc(n, sizeof(bool));
    return obj;
}

int examRoomSeat(ExamRoom* obj) {
    bool isEmpty = true;
    for (int i = 0; i < obj->n; i++) {
        if (obj->occupied[i]) {
            isEmpty = false;
            break;
        }
    }
    
    if (isEmpty) {
        obj->occupied[0] = true;
        return 0;
    }
    
    int maxDist = 0;
    int bestSeat = 0;
    
    for (int i = 0; i < obj->n; i++) {
        if (!obj->occupied[i]) {
            int minDist = INT_MAX;
            for (int j = 0; j < obj->n; j++) {
                if (obj->occupied[j]) {
                    int dist = abs(i - j);
                    if (dist < minDist) {
                        minDist = dist;
                    }
                }
            }
            if (minDist > maxDist) {
                maxDist = minDist;
                bestSeat = i;
            }
        }
    }
    
    obj->occupied[bestSeat] = true;
    return bestSeat;
}

void examRoomLeave(ExamRoom* obj, int p) {
    obj->occupied[p] = false;
}

void examRoomFree(ExamRoom* obj) {
    free(obj->occupied);
    free(obj);
}

int* solution(char** commands, int commandsSize, int** inputs, int inputsSize, int* returnSize) {
    int* results = (int*)malloc(commandsSize * sizeof(int));
    *returnSize = commandsSize;
    ExamRoom* examRoom = NULL;
    
    for (int i = 0; i < commandsSize; i++) {
        if (strcmp(commands[i], "ExamRoom") == 0) {
            examRoom = examRoomCreate(inputs[i][0]);
            results[i] = -1; // null equivalent
        } else if (strcmp(commands[i], "seat") == 0) {
            results[i] = examRoomSeat(examRoom);
        } else if (strcmp(commands[i], "leave") == 0) {
            examRoomLeave(examRoom, inputs[i][0]);
            results[i] = -1; // null equivalent
        }
    }
    
    if (examRoom) examRoomFree(examRoom);
    return results;
}

int main() {
    // Parse input and call solution
    // Print result
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each seat() operation checks all n positions

✓ Linear Growth

Space Complexity

O(n)

Set stores up to n occupied seats

⚡ Linearithmic Space

67.0K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force with Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler