Consecutive Available Seats - Practice Coding Problems

Consecutive Available Seats - Problem

Database Easy

You're managing seat reservations for a movie theater! Given a Cinema table with seat information, you need to find all seats that are part of consecutive groups of available seats.

The table structure is:

+-------------+------+
| Column Name | Type |
+-------------+------+
| seat_id     | int  |
| free        | bool |
+-------------+------+

Where:

seat_id is the unique identifier for each seat (auto-increment)
free indicates availability: 1 (true) = available, 0 (false) = occupied

Goal: Find all seat IDs that are part of consecutive available seat groups. A seat qualifies if it has at least one adjacent available seat (either left or right neighbor).

Return: All qualifying seat IDs ordered by seat_id in ascending order.

Note: The problem guarantees that more than two consecutive seats are available somewhere in the cinema.

Input & Output

example_1.sql — Basic consecutive seats

$ Input: Cinema table: +--------+------+ |seat_id | free | +--------+------+ | 1 | 0 | | 2 | 1 | | 3 | 1 | | 4 | 1 | | 5 | 0 | +--------+------+

› Output: +--------+ |seat_id | +--------+ | 2 | | 3 | | 4 | +--------+

💡 Note: Seats 2, 3, and 4 are consecutive available seats. Seat 2 has seat 3 as available neighbor, seat 3 has both seats 2 and 4 as neighbors, and seat 4 has seat 3 as neighbor.

example_2.sql — Multiple consecutive groups

$ Input: Cinema table: +--------+------+ |seat_id | free | +--------+------+ | 1 | 1 | | 2 | 1 | | 3 | 0 | | 4 | 1 | | 5 | 1 | | 6 | 1 | +--------+------+

› Output: +--------+ |seat_id | +--------+ | 1 | | 2 | | 4 | | 5 | | 6 | +--------+

💡 Note: Two groups of consecutive seats: [1,2] and [4,5,6]. All seats in these groups have at least one available adjacent seat.

example_3.sql — Single available seats excluded

$ Input: Cinema table: +--------+------+ |seat_id | free | +--------+------+ | 1 | 0 | | 2 | 1 | | 3 | 0 | | 4 | 1 | | 5 | 1 | | 6 | 0 | +--------+------+

› Output: +--------+ |seat_id | +--------+ | 4 | | 5 | +--------+

💡 Note: Seat 2 is available but isolated (no available neighbors), so it's excluded. Only seats 4 and 5 form a consecutive group.

Visualization

Tap to expand

Understanding the Visualization

Identify Available Seats

Find all seats where free = 1 (green seats in the diagram)

Check for Neighbors

For each available seat, check if adjacent seats (±1 seat_id) are also available

Include Grouped Seats

Only include seats that have at least one available neighbor

Return Sorted Results

Return all qualifying seat_ids in ascending order

Key Takeaway

🎯 Key Insight: Use self-joins to efficiently find seats with available neighbors in a single database query, rather than checking each seat individually with subqueries.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Database can use indexes for efficient joins and sorting

⚡ Linearithmic

Space Complexity

O(n)

Space for join results and final output

⚡ Linearithmic Space

Constraints

1 ≤ seat_id ≤ 1000
free is either 0 or 1
More than two consecutive seats are available in each test case
seat_id is unique and auto-incrementing

Asked in

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

The optimal solution uses a self-join to efficiently find consecutive available seats in one query. By joining the Cinema table with itself on adjacent seat conditions (seat_id ± 1), we can identify all available seats that have at least one available neighbor. The key insight is using SQL's join capabilities rather than subqueries for better performance.

Common Approaches

Approach	Time	Space	Notes
✓ Self-Join with OR Conditions (Optimal SQL)	O(n log n)	O(n)	Use self-joins to efficiently find seats with available neighbors in one query

Self-Join with OR Conditions (Optimal SQL) — Algorithm Steps

Self-join Cinema table on adjacent seat conditions
Filter for available seats (c1.free = 1)
Check if previous seat (seat_id - 1) is available OR next seat (seat_id + 1) is available
Use DISTINCT to avoid duplicate seat_ids
Order results by seat_id ascending

Visualization

Tap to expand

Step-by-Step Walkthrough

Self-Join Setup

Join Cinema table with itself on adjacent seat conditions

Adjacent Check

Match seats where c2.seat_id = c1.seat_id ± 1

Filter Available

Ensure both c1 and c2 seats are available (free = 1)

Collect Results

Return distinct seat_ids that have available neighbors

Code -

solution.c — C

// Optimal SQL solution
char* query = """
SELECT DISTINCT c1.seat_id
FROM Cinema c1 
JOIN Cinema c2 ON (
    (c2.seat_id = c1.seat_id - 1 OR c2.seat_id = c1.seat_id + 1)
    AND c2.free = 1
)
WHERE c1.free = 1
ORDER BY c1.seat_id;
""";

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

// Helper function to find seat status
int getSeatStatus(int seatsData[][2], int size, int targetSeatId) {
    for (int i = 0; i < size; i++) {
        if (seatsData[i][0] == targetSeatId) {
            return seatsData[i][1];
        }
    }
    return 0; // seat not found, consider as occupied
}

// C implementation with optimized lookup
int* findConsecutiveSeatsOptimal(int seatsData[][2], int size, int* returnSize) {
    int* result = malloc(size * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < size; i++) {
        int seatId = seatsData[i][0];
        int free = seatsData[i][1];
        
        if (free == 1) { // seat is available
            int leftAvailable = getSeatStatus(seatsData, size, seatId - 1) == 1;
            int rightAvailable = getSeatStatus(seatsData, size, seatId + 1) == 1;
            
            if (leftAvailable || rightAvailable) {
                result[*returnSize] = seatId;
                (*returnSize)++;
            }
        }
    }
    
    // Sort result
    for (int i = 0; i < *returnSize - 1; i++) {
        for (int j = i + 1; j < *returnSize; j++) {
            if (result[i] > result[j]) {
                int temp = result[i];
                result[i] = result[j];
                result[j] = temp;
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Database can use indexes for efficient joins and sorting

⚡ Linearithmic

Space Complexity

O(n)

Space for join results and final output

⚡ Linearithmic Space

Constraints

1 ≤ seat_id ≤ 1000
free is either 0 or 1
More than two consecutive seats are available in each test case
seat_id is unique and auto-incrementing

26.8K Views

Medium Frequency

~15 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

Self-Join with OR Conditions (Optimal SQL) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler