The Number of Passengers in Each Bus I - Practice Coding Problems

The Number of Passengers in Each Bus I - Problem

Database Medium

The Number of Passengers in Each Bus I

Welcome to the LeetCode Transit Authority! 🚌 You're tasked with analyzing passenger boarding data at our busy station.

You have two tables:

Buses Table:

+--------------+------+
| Column Name  | Type |
+--------------+------+
| bus_id       | int  |
| arrival_time | int  |
+--------------+------+

Passengers Table:

+--------------+------+
| Column Name  | Type |
+--------------+------+
| passenger_id | int  |
| arrival_time | int  |
+--------------+------+

Boarding Rules:
• Passengers board the first available bus that arrives at or after their arrival time
• Once a passenger boards a bus, they cannot board another
• No two buses or passengers arrive at the exact same time

Your Mission: Calculate how many passengers board each bus and return results ordered by bus_id ascending.

Think of it like a real transit system - passengers wait at the station and hop on the first bus that can take them to their destination!

Input & Output

Basic Example - Sequential Arrival

$ Input: Buses: [(bus_id=1, arrival_time=2), (bus_id=2, arrival_time=4)]\nPassengers: [(passenger_id=1, arrival_time=1), (passenger_id=2, arrival_time=3)]

› Output: [(bus_id=1, passengers_cnt=1), (bus_id=2, passengers_cnt=1)]

💡 Note: Passenger 1 arrives at t=1 and boards Bus 1 (arrives t=2). Passenger 2 arrives at t=3 and boards Bus 2 (arrives t=4) since Bus 1 already left.

Multiple Passengers Same Bus

$ Input: Buses: [(bus_id=1, arrival_time=5)]\nPassengers: [(passenger_id=1, arrival_time=1), (passenger_id=2, arrival_time=3), (passenger_id=3, arrival_time=5)]

› Output: [(bus_id=1, passengers_cnt=3)]

💡 Note: All three passengers arrive before or at t=5, so they all board Bus 1 which is the first (and only) bus that can take them.

Edge Case - No Passengers Can Board

$ Input: Buses: [(bus_id=1, arrival_time=1)]\nPassengers: [(passenger_id=1, arrival_time=2)]

› Output: [(bus_id=1, passengers_cnt=0)]

💡 Note: Passenger 1 arrives at t=2 but Bus 1 already left at t=1, so no passengers board Bus 1.

Constraints

1 ≤ buses.length, passengers.length ≤ 10³
1 ≤ bus_id, passenger_id ≤ 10⁶
1 ≤ arrival_time ≤ 10⁹
No two buses arrive at the same time
No two passengers arrive at the same time

Visualization

Tap to expand

Sort: Buses [Bus1(t=2), Bus2(t=4), Bus3(t=6)] | Passengers [P1(t=1), P2(t=3), P3(t=5)]2. Two Pointers: Bus pointer starts at Bus1, Passenger pointer starts at P13. Process: For each bus, count passengers who can board (arrived ≤ bus time)4. Assign: P1→Bus1 (1 passenger), P2→Bus2 (1 passenger), P3→Bus3 (1 passenger)5. Result: Bus1: 1 passenger, Bus2: 1 passenger, Bus3: 1 passenger❌ Brute Force: O(n×m)Check every passengeragainst every busVery slow for large datasets✅ Two Pointers: O(n log n)Single pass after sortingEach element processed onceOptimal for large datasets

Understanding the Visualization

Sort Schedules

Organize buses and passengers by arrival times for efficient processing

Two-Pointer Sweep

Use two pointers to traverse sorted arrays and match passengers to buses

First-Come-First-Bus

Ensure each passenger boards the earliest available bus they can catch

Key Takeaway

🎯 Key Insight: Sort both arrays and use two pointers to process them in chronological order, ensuring each passenger boards the earliest available bus in optimal O(n log n) time.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses two pointers with sorting to achieve O(n log n) time complexity. Sort both buses and passengers by arrival time, then use two pointers to efficiently assign passengers to their first available bus in a single pass. This approach ensures each passenger boards the earliest bus they can catch while maintaining optimal performance.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Sorting (Optimal)	O(n log n + m log m)	O(1)	Sort both arrays and use two pointers to efficiently match passengers to buses
Sorting + Binary Search Optimization	O(n log n + m log m)	O(n + m)	Sort data and use binary search to efficiently find passenger-bus assignments
Brute Force SQL with Correlated Subqueries	O(n × m)	O(1)	Check each bus against all passengers individually using nested queries

Two Pointers with Sorting (Optimal) — Algorithm Steps

Sort buses by arrival time (maintaining bus_id for tie-breaking)
Sort passengers by arrival time
Use two pointers: one for buses, one for passengers
For each bus, count all unassigned passengers who can board
Move pointers appropriately and track assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Arrays

Sort buses and passengers by arrival time

Two Pointers

Use one pointer for buses, one for passengers

Process in Order

Assign passengers to earliest available bus

Code -

solution.c — C

// Optimal Two Pointers Solution
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int bus_id;
    int arrival_time;
} Bus;

typedef struct {
    int passenger_id;
    int arrival_time;
} Passenger;

typedef struct {
    int bus_id;
    int passengers_cnt;
} Result;

int compare_buses(const void *a, const void *b) {
    Bus *busA = (Bus*)a, *busB = (Bus*)b;
    if (busA->arrival_time != busB->arrival_time)
        return busA->arrival_time - busB->arrival_time;
    return busA->bus_id - busB->bus_id;
}

int compare_passengers(const void *a, const void *b) {
    return ((Passenger*)a)->arrival_time - ((Passenger*)b)->arrival_time;
}

int compare_results(const void *a, const void *b) {
    return ((Result*)a)->bus_id - ((Result*)b)->bus_id;
}

Result* solution(Bus* buses, int buses_count, Passenger* passengers, int passengers_count) {
    // Sort arrays
    qsort(buses, buses_count, sizeof(Bus), compare_buses);
    qsort(passengers, passengers_count, sizeof(Passenger), compare_passengers);
    
    Result* result = malloc(buses_count * sizeof(Result));
    int passengerIdx = 0;
    
    for (int i = 0; i < buses_count; i++) {
        int count = 0;
        
        // Count passengers who can board this bus
        while (passengerIdx < passengers_count && 
               passengers[passengerIdx].arrival_time <= buses[i].arrival_time) {
            count++;
            passengerIdx++;
        }
        
        result[i].bus_id = buses[i].bus_id;
        result[i].passengers_cnt = count;
    }
    
    // Sort result by bus_id
    qsort(result, buses_count, sizeof(Result), compare_results);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log m)

Dominated by sorting buses and passengers, then single pass with two pointers

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space beyond input arrays (excluding sorting space)

✓ Linear Space

28.6K Views

Medium Frequency

~15 min Avg. Time

842 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

Two Pointers with Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler