Time Taken to Cross the Door - Practice Coding Problems

Time Taken to Cross the Door - Problem

Imagine a busy office building with a single revolving door that everyone must use to enter or exit. You're tasked with managing the flow of n people (numbered 0 to n-1) who arrive at different times.

Each person takes exactly 1 second to cross the door, and you're given:

arrival[i]: The time when person i arrives at the door
state[i]: Whether person i wants to enter (0) or exit (1)

When multiple people want to use the door simultaneously, they follow strict priority rules:

If the door was unused in the previous second → Exiters go first
If the door was used for entering → Enterers continue first
If the door was used for exiting → Exiters continue first
Among people going the same direction → Lowest index wins

Your goal: Return an array where answer[i] is the exact second when person i crosses the door.

Input & Output

example_1.py — Basic Door Usage

$ Input: arrival = [0,1,1,2,4], state = [0,1,0,0,1]

› Output: [0,2,1,4,3]

💡 Note: Person 0 arrives at time 0 and wants to enter (crosses at time 0). At time 1, both person 1 (exit) and person 2 (enter) arrive. Since door was just used for entering, person 2 (enter) has priority and crosses at time 1. Person 1 crosses at time 2. Person 3 arrives at time 2 and crosses at time 4. Person 4 arrives at time 4 but must wait since person 3 is using door, so crosses at time 3.

example_2.py — Exit Priority When Idle

$ Input: arrival = [0,0,0], state = [1,1,0]

› Output: [0,1,2]

💡 Note: All three people arrive at time 0. Since the door hasn't been used, exiters have priority. Person 0 and 1 both want to exit, but person 0 has lower index so goes first at time 0. Person 1 exits at time 1. Person 2 enters at time 2.

example_3.py — Continuation Priority

$ Input: arrival = [0,1,2], state = [1,1,1]

› Output: [0,1,2]

💡 Note: Person 0 exits at time 0. Person 1 arrives at time 1. Since the door was previously used for exiting, person 1 (also exiting) has priority and crosses at time 1. Person 2 arrives at time 2 and crosses immediately since no one else is waiting.

Visualization

Tap to expand

Understanding the Visualization

People Arrive

People arrive at scheduled times and join appropriate queues

Check Door State

Look at how the door was used in the previous second

Apply Priority Rules

If idle → exiters first. If used for entering → enterers continue. If used for exiting → exiters continue

Process Person

The person with lowest index from the priority group crosses the door

Update State

Record the crossing time and update door usage state for next iteration

Key Takeaway

🎯 Key Insight: Use separate queues and track door state to efficiently simulate the crossing process without checking every second individually.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting people by arrival time dominates, then O(n) to process each person once

⚡ Linearithmic

Space Complexity

O(n)

Space for queues, result array, and sorting

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
arrival.length == state.length == n
0 ≤ arrival[i] ≤ 10⁵
arrival is sorted in non-decreasing order
state[i] is either 0 or 1

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 6

The optimal approach uses separate queues for enterers and exiters, combined with efficient time simulation. By sorting people by arrival time and maintaining the door's previous usage state, we can apply priority rules in O(n log n) time. The key insight is avoiding the brute force approach of checking every second individually.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Queue Simulation	O(n log n)	O(n)	Use separate queues for enterers and exiters with efficient time simulation

Optimized Queue Simulation — Algorithm Steps

Create separate queues for enterers and exiters
Sort people by arrival time to process in chronological order
Simulate time by jumping to next relevant time point
When people arrive, add them to appropriate queues
Apply priority rules using door's last usage state
Process one person per second and update door state

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Arrival

Process people in chronological order

Queue Management

Add arriving people to appropriate queues

Priority Decision

Use door state to choose between queues

Process Person

Remove from queue and record crossing time

Update State

Track door usage for next iteration

Code -

solution.c — C

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

typedef struct {
    int arrivalTime;
    int index;
    int state;
} Person;

int comparePeople(const void* a, const void* b) {
    Person* personA = (Person*)a;
    Person* personB = (Person*)b;
    return personA->arrivalTime - personB->arrivalTime;
}

int* timeTakenToCross(int* arrival, int arrivalSize, int* state, int stateSize, int* returnSize) {
    int n = arrivalSize;
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = n;
    
    // Create array of people and sort by arrival time
    Person* people = (Person*)malloc(n * sizeof(Person));
    for (int i = 0; i < n; i++) {
        people[i].arrivalTime = arrival[i];
        people[i].index = i;
        people[i].state = state[i];
    }
    qsort(people, n, sizeof(Person), comparePeople);
    
    int enterQueue[1000], exitQueue[1000];
    int enterFront = 0, enterRear = 0, exitFront = 0, exitRear = 0;
    
    int currentTime = 0;
    int personIdx = 0;
    int lastUsed = -1; // -1: not used, 0: enter, 1: exit
    
    while (personIdx < n || enterFront < enterRear || exitFront < exitRear) {
        // Add all people who arrive at currentTime
        while (personIdx < n && people[personIdx].arrivalTime <= currentTime) {
            if (people[personIdx].state == 0) {
                enterQueue[enterRear++] = people[personIdx].index;
            } else {
                exitQueue[exitRear++] = people[personIdx].index;
            }
            personIdx++;
        }
        
        // If no one is waiting, advance time
        if (enterFront >= enterRear && exitFront >= exitRear) {
            if (personIdx < n) {
                currentTime = people[personIdx].arrivalTime;
                lastUsed = -1;
            }
            continue;
        }
        
        // Determine who goes based on priority rules
        int selectedPerson = -1;
        
        if (lastUsed == -1) { // Door not used previously
            if (exitFront < exitRear) {
                selectedPerson = exitQueue[exitFront++];
                lastUsed = 1;
            } else if (enterFront < enterRear) {
                selectedPerson = enterQueue[enterFront++];
                lastUsed = 0;
            }
        } else if (lastUsed == 0) { // Previously used for entering
            if (enterFront < enterRear) {
                selectedPerson = enterQueue[enterFront++];
                lastUsed = 0;
            } else if (exitFront < exitRear) {
                selectedPerson = exitQueue[exitFront++];
                lastUsed = 1;
            }
        } else { // Previously used for exiting
            if (exitFront < exitRear) {
                selectedPerson = exitQueue[exitFront++];
                lastUsed = 1;
            } else if (enterFront < enterRear) {
                selectedPerson = enterQueue[enterFront++];
                lastUsed = 0;
            }
        }
        
        if (selectedPerson != -1) {
            result[selectedPerson] = currentTime;
        }
        
        currentTime++;
    }
    
    free(people);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting people by arrival time dominates, then O(n) to process each person once

⚡ Linearithmic

Space Complexity

O(n)

Space for queues, result array, and sorting

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
arrival.length == state.length == n
0 ≤ arrival[i] ≤ 10⁵
arrival is sorted in non-decreasing order
state[i] is either 0 or 1

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Queue Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler