LeetCode 626: Exchange Seats Solution in Python – A Step-by-Step Guide

What Is LeetCode 626: Exchange Seats?

In LeetCode 626: Exchange Seats, you’re given a table seat with columns id (integer, consecutive from 1) and student (string, student name). Your task is to swap students in adjacent seats: for even-numbered rows, each student swaps with the one before (e.g., ID 2 swaps with ID 1), and for odd-numbered rows up to the second-to-last, each swaps with the next. If the total number of seats is odd, the last student (highest odd ID) remains in place. The output is the table sorted by id. For example, with [1, "John"], [2, "Jane"], the result is [1, "Jane"], [2, "John"]. This problem tests your ability to manipulate table data with conditional swapping, typically posed as an SQL query with CASE statements, but we’ll solve it in Python for a coding twist.

Problem Statement

• Input:
• seat: A list of records with [id, student].
• Output: A list of [id, student] with seats swapped, sorted by id.
• Rules:
• Swap adjacent seats: ID 1 ↔ 2, 3 ↔ 4, etc.
• If total seats is odd, last ID (odd) stays unchanged.
• IDs are consecutive integers starting from 1.

Constraints

• Table has at least 1 row.
• 1 ≤ id ≤ 10⁷.
• student is a string ≤ 10 characters.
• Number of rows ≤ 10⁵.

Examples

• Input:
``` id | student 1 | John 2 | Jane 3 | Alice 4 | Bob ```
• Output:
``` [[1, "Jane"], [2, "John"], [3, "Bob"], [4, "Alice"]] ```
• Input:
``` id | student 1 | John 2 | Jane 3 | Alice ```
• Output:
``` [[1, "Jane"], [2, "John"], [3, "Alice"]] ```
• Input:
``` id | student 1 | Eve ```
• Output:
``` [[1, "Eve"]] ```

These examples show the swapping—let’s solve it!

Understanding the Problem: Swapping Seats

To solve LeetCode 626: Exchange Seats in Python, we need to swap student names between adjacent IDs in a list of [id, student] pairs, ensuring that if the total number of seats is odd, the last ID remains unchanged, then sort by ID. A naive approach might manually pair and swap, but we can optimize with direct list manipulation or mapping. We’ll use:

• Best Solution (List-Based Swapping with Conditional Logic): O(n) time, O(n) space—fast and intuitive (n = number of rows).
• Alternative Solution (Dictionary-Based Mapping): O(n) time, O(n) space—explicit but slightly more complex.

Let’s start with the list-based solution, breaking it down for beginners.

Best Solution: List-Based Swapping with Conditional Logic

Why This Is the Best Solution

The list-based swapping approach is the top choice for LeetCode 626 because it’s efficient—O(n) time with O(n) space—and straightforward, directly manipulating the list by swapping adjacent pairs in one pass, handling the odd-case exception cleanly. It fits constraints (≤ 10⁵ rows) and mimics SQL’s conditional logic in a Python-friendly way. It’s like rearranging seats with a quick shuffle!

How It Works

Think of this as a classroom seat swap:

• Step 1: Handle Single Seat:
• If only 1 row, return as is (no swap).
• Step 2: Create Result List:
• Copy input list to modify.
• Step 3: Swap Adjacent Pairs:
• For even n, swap all pairs (0↔1, 2↔3, etc.).
• For odd n, swap up to second-to-last, leave last unchanged.
• Step 4: Sort by ID:
• Ensure output is ordered by id.
• Step 5: Return Result:
• Output the swapped list.

It’s like a seat shuffler—swap and sort!

Step-by-Step Example

Example:

Copy codeid | student
1  | John
2  | Jane
3  | Alice
4  | Bob

• Step 1: n = 4 > 1, proceed.
• Step 2: Result = [[1, "John"], [2, "Jane"], [3, "Alice"], [4, "Bob"]].
• Step 3: Swap (n even):
• ID 1 ↔ 2: [1, "Jane"], [2, "John"].
• ID 3 ↔ 4: [3, "Bob"], [4, "Alice"].
• Result: [[1, "Jane"], [2, "John"], [3, "Bob"], [4, "Alice"]].
• Step 4: Already sorted by ID.
• Output: [[1, "Jane"], [2, "John"], [3, "Bob"], [4, "Alice"]].

Example:

Copy codeid | student
1  | John
2  | Jane
3  | Alice

• Step 1: n = 3 > 1.
• Step 2: Result = [[1, "John"], [2, "Jane"], [3, "Alice"]].
• Step 3: Swap (n odd):
• ID 1 ↔ 2: [1, "Jane"], [2, "John"].
• ID 3: Stays [3, "Alice"].
• Result: [[1, "Jane"], [2, "John"], [3, "Alice"]].
• Step 4: Sorted.
• Output: [[1, "Jane"], [2, "John"], [3, "Alice"]].

Code with Detailed Line-by-Line Explanation

Here’s the Python code, explained clearly:

Copy codeclass Solution:
    def exchangeSeats(self, seat: List[List]) -> List[List]:
        # Step 1: Handle single seat case
        if len(seat) == 1:
            return seat

        # Step 2: Create result list
        result = seat.copy()
        n = len(seat)

        # Step 3: Swap adjacent pairs
        for i in range(0, n - 1, 2):  # Step by 2 up to second-to-last
            # Swap student names between i and i+1
            result[i][1], result[i + 1][1] = result[i + 1][1], result[i][1]

        # Step 4: Sort by ID (already sorted in input, but ensure)
        result.sort(key=lambda x: x[0])

        # Step 5: Return result
        return result

• Lines 4-5: Single row: no swap needed.
• Lines 8-9: Copy list to modify.
• Lines 12-14: Swap:
• Iterate pairs (0,1), (2,3), etc., swap names.
• If n odd, last element skipped.
• Line 17: Sort by ID (typically unnecessary if input consecutive).
• Time Complexity: O(n)—one pass for swapping.
• Space Complexity: O(n)—result list.

This is like a seat swapper—quick and clean!

Alternative Solution: Dictionary-Based Mapping

Why an Alternative Approach?

The dictionary-based mapping approach uses a dict to map IDs to new student names—O(n) time, O(n) space. It’s more explicit, building a mapping before updating, but adds complexity without much gain here. It’s like reassigning seats with a lookup table!

How It Works

Picture this as a seat reassignment:

• Step 1: Build mapping dict.
• Step 2: Map IDs to swapped students.
• Step 3: Update list with new assignments.
• Step 4: Sort and return.

It’s like a seat planner—map and apply!

Step-by-Step Example

Example:

Copy codeid | student
1  | John
2  | Jane
3  | Alice

• Step 1: Dict = {1: "John", 2: "Jane", 3: "Alice"}.
• Step 2: Swap:
• 1 → "Jane" (from 2).
• 2 → "John" (from 1).
• 3 → "Alice" (no swap, last odd).
• Step 3: Result = [[1, "Jane"], [2, "John"], [3, "Alice"]].
• Step 4: Sorted.
• Output: [[1, "Jane"], [2, "John"], [3, "Alice"]].

Code for Dictionary Approach

Copy codeclass Solution:
    def exchangeSeats(self, seat: List[List]) -> List[List]:
        # Step 1: Handle single seat
        if len(seat) == 1:
            return seat

        # Step 2: Build mapping dictionary
        mapping = {row[0]: row[1] for row in seat}
        n = len(seat)

        # Step 3: Create swapped mapping
        swapped = {}
        for i in range(1, n + 1):
            if i % 2 == 1 and i < n:  # Odd ID, not last
                swapped[i] = mapping[i + 1]
            elif i % 2 == 0:  # Even ID
                swapped[i] = mapping[i - 1]
            else:  # Last odd ID
                swapped[i] = mapping[i]

        # Step 4: Update result list
        result = [[id_val, swapped[id_val]] for id_val in swapped]
        result.sort(key=lambda x: x[0])

        # Step 5: Return result
        return result

• Lines 4-5: Single row case.
• Lines 8-9: Map ID to student.
• Lines 12-18: Swap logic in dict.
• Lines 21-22: Build and sort result.
• Time Complexity: O(n)—mapping and swapping.
• Space Complexity: O(n)—dict and list.

It’s a seat mapper—explicit but heavier!

Comparing the Two Solutions

• List-Based (Best):
• Pros: O(n) time, O(n) space, simple and direct.
• Cons: Less flexible for complex swaps.
• Dictionary (Alternative):
• Pros: O(n) time, O(n) space, explicit mapping.
• Cons: More steps, extra dict.

List-based wins for simplicity.

Additional Examples and Edge Cases

• Input: [[1, "Eve"]]
• Output: [[1, "Eve"]].
• Input: [[1, "A"], [2, "B"], [3, "C"]]
• Output: [[1, "B"], [2, "A"], [3, "C"]].

Both handle these well.

Complexity Breakdown

• List-Based: Time O(n), Space O(n).
• Dictionary: Time O(n), Space O(n).

List-based is optimal in practice.

Key Takeaways

• List-Based: Direct swap—smart!
• Dictionary: Mapped swap—clear!
• Data: Swapping is fun.
• Python Tip: Lists rock—see Python Basics.

Final Thoughts: Swap Those Seats

LeetCode 626: Exchange Seats in Python is a neat data-reordering challenge. List-based swapping offers speed and clarity, while dictionary mapping provides an explicit alternative. Want more? Try LeetCode 175: Combine Two Tables or LeetCode 627: Swap Salary. Ready to rearrange? Head to Solve LeetCode 626 on LeetCode and exchange those seats today!