Exam Room - Practice Coding Problems

Exam Room - Problem

Imagine you're designing a system for a university exam room with n seats arranged in a single row, numbered from 0 to n-1. Students want to maintain maximum social distance while taking their exam!

When a student enters the room, they must sit in the seat that maximizes the distance to the closest occupied seat. If there are multiple seats with the same maximum distance, they choose the seat with the lowest number. If the room is empty, they sit at seat 0.

Your task is to implement an ExamRoom class that simulates this behavior:

ExamRoom(int n): Initialize the exam room with n seats
int seat(): Return the seat number where the next student sits
void leave(int p): Remove the student from seat p

Goal: Efficiently manage seat assignments to maximize distances between students.

Input & Output

basic_operations.py — Basic Seat Assignment

$ Input: ExamRoom(10) seat() → 0 seat() → 9 seat() → 4 leave(4) seat() → 4

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

💡 Note: First student sits at 0 (empty room). Second student maximizes distance by sitting at 9. Third student sits at position 4 (middle of 0-9 gap). After student leaves position 4, next student again chooses position 4 as optimal.

tie_breaking.py — Lowest Index Preference

$ Input: ExamRoom(4) seat() → 0 seat() → 3 seat() → 1 leave(1) seat() → 1

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

💡 Note: When multiple seats have same maximum distance (positions 1 and 2 both have distance 1 from nearest occupied seat), we choose the lower indexed seat (position 1).

single_seat.py — Edge Case

$ Input: ExamRoom(1) seat() → 0 leave(0) seat() → 0

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

💡 Note: With only one seat available, student must always sit at position 0.

Visualization

Tap to expand

Understanding the Visualization

First Student

Empty room → sits at position 0 by default

Second Student

Maximizes distance → sits at far end (position n-1)

Third Student

Finds largest gap → sits in the middle of biggest empty section

Student Leaves

Creates new gap → recalculates optimal positions

Next Student

Chooses position with maximum distance to nearest occupied seat

Key Takeaway

🎯 Key Insight: The optimal seat is always at gap boundaries (positions 0 or n-1) or at the midpoint of the largest gap between consecutive occupied seats. This insight allows us to solve the problem efficiently in O(n) time per operation instead of checking every position.

Time & Space Complexity

Time Complexity

⏱️

O(n)

For each seat() operation, we scan through occupied seats once to find largest gap

✓ Linear Growth

Space Complexity

O(n)

Space for storing occupied seats in sorted order

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁹
At most 10⁴ calls will be made to seat and leave
seat() is guaranteed to return a valid seat number
leave(p) is guaranteed to be called with an occupied seat p

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal approach uses a sorted list to track occupied seats and efficiently finds the largest gap between consecutive occupied seats. The key insight is that the optimal seat is always at a gap boundary (position 0 or n-1) or the midpoint of the largest gap. This reduces the time complexity from O(n²) brute force to O(n) per operation.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Sorted List	O(n)	O(n)	Maintain sorted list of occupied seats for efficient gap calculation
Brute Force (Check All Seats)	O(n²)	O(n)	For each seat operation, check all empty seats and calculate distances

Optimized with Sorted List — Algorithm Steps

Maintain a sorted list of occupied seat positions
For seat(): find the largest gap between consecutive occupied seats
Consider boundary gaps: [0, first_occupied) and (last_occupied, n-1]
Place new student at the position that maximizes minimum distance
Insert new position maintaining sorted order

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Gaps

Find all gaps between consecutive occupied seats

Calculate Midpoints

Find optimal position in each gap

Choose Best Gap

Select gap that maximizes distance to nearest occupied seat

Code -

solution.c — C

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

typedef struct {
    int n;
    int* occupied;
    int size;
    int capacity;
} ExamRoom;

ExamRoom* examRoomCreate(int n) {
    ExamRoom* room = malloc(sizeof(ExamRoom));
    room->n = n;
    room->capacity = n;
    room->occupied = malloc(sizeof(int) * room->capacity);
    room->size = 0;
    return room;
}

int examRoomSeat(ExamRoom* obj) {
    if (obj->size == 0) {
        obj->occupied[0] = 0;
        obj->size = 1;
        return 0;
    }
    
    int maxDist = 0;
    int bestPos = 0;
    
    // Check position 0
    if (obj->occupied[0] > 0) {
        int dist = obj->occupied[0];
        if (dist > maxDist) {
            maxDist = dist;
            bestPos = 0;
        }
    }
    
    // Check gaps between consecutive occupied seats
    for (int i = 0; i < obj->size - 1; i++) {
        int left = obj->occupied[i];
        int right = obj->occupied[i + 1];
        if (right - left > 1) {
            int pos = (left + right) / 2;
            int dist = (pos - left < right - pos) ? pos - left : right - pos;
            if (dist > maxDist) {
                maxDist = dist;
                bestPos = pos;
            }
        }
    }
    
    // Check position n-1
    if (obj->occupied[obj->size - 1] < obj->n - 1) {
        int dist = obj->n - 1 - obj->occupied[obj->size - 1];
        if (dist > maxDist) {
            maxDist = dist;
            bestPos = obj->n - 1;
        }
    }
    
    // Insert in sorted order
    int insertPos = 0;
    while (insertPos < obj->size && obj->occupied[insertPos] < bestPos) {
        insertPos++;
    }
    memmove(&obj->occupied[insertPos + 1], &obj->occupied[insertPos], (obj->size - insertPos) * sizeof(int));
    obj->occupied[insertPos] = bestPos;
    obj->size++;
    return bestPos;
}

void examRoomLeave(ExamRoom* obj, int p) {
    for (int i = 0; i < obj->size; i++) {
        if (obj->occupied[i] == p) {
            memmove(&obj->occupied[i], &obj->occupied[i + 1], (obj->size - i - 1) * sizeof(int));
            obj->size--;
            break;
        }
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

For each seat() operation, we scan through occupied seats once to find largest gap

✓ Linear Growth

Space Complexity

O(n)

Space for storing occupied seats in sorted order

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁹
At most 10⁴ calls will be made to seat and leave
seat() is guaranteed to return a valid seat number
leave(p) is guaranteed to be called with an occupied seat p

52.4K Views

Medium-High Frequency

~25 min Avg. Time

1.7K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized with Sorted List — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler