Exchange Seats - Practice Coding Problems

Exchange Seats - Problem

Database Medium

🪑 Exchange Seats

You're managing a classroom where students need to swap seats in pairs! Given a table Seat with student information, you need to swap the seat IDs of every two consecutive students.

Table Schema:

Column Name	Type
id	int
student	varchar

Rules:

Student 1 swaps with Student 2
Student 3 swaps with Student 4
And so on...
If there's an odd number of students, the last student stays in their original seat

Return the result ordered by id in ascending order. This problem tests your SQL skills with conditional logic and row manipulation.

Input & Output

example_1.sql — Basic Even Number of Students

$ Input: Input: Seat table: +----+---------+ | id | student | +----+---------+ | 1 | Abbot | | 2 | Doris | | 3 | Emerson | | 4 | Green | +----+---------+

› Output: Output: +----+---------+ | id | student | +----+---------+ | 1 | Doris | | 2 | Abbot | | 3 | Green | | 4 | Emerson | +----+---------+

💡 Note: With 4 students (even), all pairs swap: (1↔2) and (3↔4). Abbot moves from seat 1 to 2, Doris moves from seat 2 to 1, Emerson moves from seat 3 to 4, Green moves from seat 4 to 3.

example_2.sql — Odd Number of Students

$ Input: Input: Seat table: +----+---------+ | id | student | +----+---------+ | 1 | Abbot | | 2 | Doris | | 3 | Emerson | | 4 | Green | | 5 | Jeames | +----+---------+

› Output: Output: +----+---------+ | id | student | +----+---------+ | 1 | Doris | | 2 | Abbot | | 3 | Green | | 4 | Emerson | | 5 | Jeames | +----+---------+

💡 Note: With 5 students (odd), pairs (1↔2) and (3↔4) swap, but student 5 (Jeames) has no pair and stays in the same seat.

example_3.sql — Single Student Edge Case

$ Input: Input: Seat table: +----+---------+ | id | student | +----+---------+ | 1 | Alice | +----+---------+

› Output: Output: +----+---------+ | id | student | +----+---------+ | 1 | Alice | +----+---------+

💡 Note: With only 1 student, there's no pair to swap with, so Alice remains in seat 1.

Visualization

Tap to expand

Understanding the Visualization

Initial Seating

Students are seated in sequential order by ID

Identify Pairs

Group students into pairs: (1,2), (3,4), etc.

Swap Within Pairs

Each pair exchanges seats with their partner

Handle Odd Case

If odd total, last student stays in original seat

Key Takeaway

🎯 Key Insight: Use modulo arithmetic to determine seat swapping: `id % 2 = 1` means odd (move right), `id % 2 = 0` means even (move left), with special handling for the unpaired last seat.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the table to apply the CASE logic

✓ Linear Growth

Space Complexity

O(1)

No additional space needed beyond the result set

✓ Linear Space

Constraints

1 ≤ Number of students ≤ 1000
id is a continuous sequence starting from 1
student names are unique varchar strings
The table is guaranteed to have sequential IDs with no gaps

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 12 f Meta 8

The optimal solution uses a single CASE statement to swap seat IDs efficiently. For odd-numbered seats (except the last one), add 1. For even-numbered seats, subtract 1. The last seat in an odd-total scenario stays unchanged. This achieves O(n) time complexity with a single table scan.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Multiple Subqueries)	O(n³)	O(n)	Use multiple subqueries to handle each case separately
Single CASE Statement (Optimal)	O(n)	O(1)	Use conditional logic to swap seats in a single query

Brute Force (Multiple Subqueries) — Algorithm Steps

Query to get all students in odd positions (except last if total is odd)
Query to get all students in even positions
Query to get the last student if total count is odd
Union all results with appropriate ID adjustments
Order by ID

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Total Students

First subquery counts all students in the table

Process Odd Positions

Second subquery handles students in odd positions

Process Even Positions

Third subquery handles students in even positions

Union Results

Combine all subquery results and order by ID

Code -

solution.c — C

// Simulating SQL logic in C
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int id;
    char student[50];
} Seat;

int compare(const void *a, const void *b) {
    return ((Seat*)a)->id - ((Seat*)b)->id;
}

int exchangeSeatsBruteForce(Seat seats[], int n, Seat result[]) {
    int resultSize = 0;
    
    // Handle odd positions (except last if total is odd)
    for (int i = 0; i < n; i += 2) {
        if (i + 1 < n) {
            result[resultSize].id = i + 2;
            strcpy(result[resultSize].student, seats[i].student);
            resultSize++;
        }
    }
    
    // Handle even positions
    for (int i = 1; i < n; i += 2) {
        result[resultSize].id = i;
        strcpy(result[resultSize].student, seats[i].student);
        resultSize++;
    }
    
    // Handle last student if odd total
    if (n % 2 == 1) {
        result[resultSize].id = n;
        strcpy(result[resultSize].student, seats[n-1].student);
        resultSize++;
    }
    
    qsort(result, resultSize, sizeof(Seat), compare);
    return resultSize;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Multiple full table scans for counting, odd positions, even positions

⚠ Quadratic Growth

Space Complexity

O(n)

Temporary result sets for each subquery

⚡ Linearithmic Space

Constraints

1 ≤ Number of students ≤ 1000
id is a continuous sequence starting from 1
student names are unique varchar strings
The table is guaranteed to have sequential IDs with no gaps

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

🪑 Exchange Seats

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Multiple Subqueries) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler