Airline Seat Map: Check-in, Paid Seats and Aircraft Swaps

Seat Map: Check-in, Paid Seats and Aircraft Swaps

You've joined the airport-systems team that owns the seat-assignment service for a regional airline. It holds the seat map of one flight, the bookings on it, and decides who sits where, both when passengers pick seats themselves and when the system auto-assigns them at check-in. Operations has three tickets queued: check-in auto-assignment (Part 1), paid seats and seat changes (Part 2) and re-seating a flight when the aircraft is swapped (Part 3). The seat rules in the existing code were written in a hurry, so expect to read them against the rules below.

Codebase

How your code is run

run(operations: list[list]) -> list executes the operations in order against a fresh service and returns one result per operation. Every operation is [name, *args]. Errors are returned as "error: <code>" strings, never raised. An unknown operation name returns "error: unknown operation"; a wrong number of arguments returns "error: invalid arguments". Every operation except open_flight returns "error: no flight" until a flight has been opened.

Seats

• A seat label is <row><letter>, e.g. "12C". The layout of each aircraft is in catalog.py: seats are grouped in blocks separated by an aisle (A320: ABC | DEF, E175: AB | CD, B77W: ABC | DEFG | HJK).
• Two seats are adjacent when they are in the same row and the same block, with consecutive letters. 5B/5C on an A320 are adjacent; 5C/5D are not (the aisle is between them).
• Each seat is blocked (can never be assigned) or belongs to one of three categories: exit (a row in exit_rows), legroom (a row in legroom_rows; sold for 4 500 cents, see Part 2), or standard.
• Seat kind: window = the outermost seat of the cabin on either side, aisle = a block's end seat that touches an aisle, middle = anything else (A320: A and F are windows, C and D aisles, B and E middles).
• The scan order is how the airline walks the cabin when it has a free choice: rows from the back to the front, letters in layout order within a row (A320: 24A, 24B, 24C, 24D, ..., 23A, ...).

Passengers

• A passenger is [pid, age, flags]. flags is a string of the letters I (an adult travelling with a lap infant), T (accepted the exit-row terms), W (prefers a window) and A (prefers an aisle); each at most once, never W and A together, I only for age 18 or more.
• Adult: age 18 or more. Child: age under 12. 12 to 17 is neither (a "teen" has no seating rules).
• Exit-row eligible: an adult who accepted the terms (T) and is not travelling with an infant (I). Only eligible passengers may sit in exit seats.
• Family rule: a seated child must sit in a seat adjacent to a seat occupied by an adult of the same booking. An unseated child breaks no rule.

book accepts 1 to 6 passengers. It fails with invalid passengers if the list or any entry is malformed (age must be an integer 0-110; flags as above), a passenger id repeats within the booking or is already used anywhere on the flight, or the booking has a child but no adult.

Part 1: Auto-assignment at check-in

Goal: implement checkin and checkin_all so that a booking's unseated passengers are seated together when possible. While you are in there, the existing assign must follow the rules in the table above (the example tests show the symptoms).

assign rules

1. Assigning a passenger to the seat they already hold succeeds and changes nothing. Otherwise the seat is taken by someone else → seat taken.
2. legroom seats cannot be assigned yet (payment required; Part 2 sells them). exit seats need an eligible passenger. A seat label that is not on this aircraft is seat not found.
3. Assigning a child whose new seat would not be adjacent to a seated adult of the booking fails with child not with adult. Nothing else is checked for adults in this Part.
4. A passenger who moves to another seat frees the old one.

checkin rules. Only the booking's *unseated* passengers are placed; seated ones stay. An open seat is free, not blocked, and standard (auto-assignment never uses exit or legroom seats). Let U be the unseated passengers in booking order. Work out a plan; if it fails return error: cannot seat booking and change nothing. Otherwise seat everyone and return [pid, seat] for each newly seated passenger in booking order ([] if everyone was already seated).

1. Step 1, together (only when |U| >= 2). A *run* is |U| consecutive open seats in one block (same row, consecutive letters). Find the arrangement of U for a run: out of all orderings of U, take the first one when orderings are compared position by position using booking positions (smallest first), such that every child in U has an adult from U immediately left or right of them in the run. If no ordering works, skip Step 1. Otherwise take the first run in scan order (rows back to front, blocks left to right, runs left to right) whose seats are all open and seat U in it, left to right, in the arrangement.
2. Step 2, closest possible (when Step 1 does not apply or finds no run). Seat the members of U one at a time: first the adults of U in booking order, then everyone else of U in booking order. For one member, take every open seat not already used in this plan; if the member is a child, keep only seats adjacent to a seated adult of the booking (already seated, or placed earlier in this plan). Pick the seat with the smallest key (a, b, c, d), compared left to right: a = 0 if the seat is adjacent to a seat of any seated member of the booking (including earlier placements in this plan), else 1; b = |row of seat - anchor row|; c = 0 if the seat's kind matches the member's W/A preference, else 1; d = position in scan order. The anchor row is the row of the first member in *booking order* who is already seated before this check-in; if there is none it is the row of the first seat this plan assigns (and b is 0 until then). If some member has no candidate seat the plan fails. This greedy is the specification; it is not an optimal search.

checkin_all runs checkin on every booking in creation order; a booking that cannot be seated is left untouched and listed in failed; seated counts passengers newly seated.

Worked example

[["open_flight", "A320"],
 ["book", "fam", [["mum", 34, "T"], ["kid", 8, ""], ["tot", 5, ""]]],
 ["book", "solo", [["bo", 29, "W"]]],
 ["assign", "mum", "5C"],
 ["assign", "kid", "5D"],
 ["assign", "mum", "5B"],
 ["assign", "kid", "5A"],
 ["checkin", "fam"],
 ["checkin", "solo"],
 ["booking_seats", "fam"]]

returns

[true, true, true, true, "error: child not with adult", true, true,
 [["tot", "5C"]], [["bo", "24A"]],
 [["mum", "5B"], ["kid", "5A"], ["tot", "5C"]]]

(5C and 5D are on opposite sides of the aisle; tot can only sit beside mum, and 5C is the last seat beside 5B; bo wants a window and 24A is the first one in scan order.)

Part 2: Paid seats and seat changes

Goal: sell the extra-legroom seats, allow refunds, and let a booking change seats as a group without ever leaving a child alone. This replaces the weaker family check of Part 1.

Rules

1. moves is a non-empty list of [pid, seat] pairs for members of one booking, applied all or nothing. The optional third argument may only be "pay". invalid moves covers a malformed list or pair, a repeated pid, or any other third argument. A pid that is not a member of that booking (even if it exists elsewhere) is passenger not found; all pids are checked before any seat.
2. A seat may be the seat of a passenger who is moving away in the same change (so two members can swap seats). A move to the seat the passenger already holds is a no-op: it frees nothing, so its seat counts as taken for everyone else. Two moves to the same seat → seat taken.
3. legroom seats are rejected with payment required unless the third argument is "pay". With "pay" every passenger who moves into a legroom seat is charged 4 500 cents.
4. Once every move passes the per-seat checks, the family rule is checked on the booking as it would look after the change: if any child of the booking (moved or not, in booking order) would be seated without an adult of the booking beside them, the change fails with child not with adult.
5. A passenger who moves out of a seat they paid for gets the 4 500 refunded (their next seat is only paid if it is a legroom seat in "pay" mode).
6. assign now means exactly change for that passenger's booking with that one move (the new family check therefore applies to adults too; all Part 1 assign errors keep their order).
7. refund_seat works on a passenger currently in a seat they paid for. It frees the seat, leaves the passenger unseated, refunds 4 500 and returns 4500; if that would leave a child of the booking without an adult beside them it fails with child not with adult and changes nothing.
8. invoice returns the booking's cumulative charged and refunded cents, net = charged - refunded, and paid_seats: [pid, seat] for each member currently in a paid seat, in booking order.

Worked example

[["open_flight", "A320"],
 ["book", "fam", [["mum", 34, ""], ["kid", 8, ""]]],
 ["assign", "mum", "2A"],
 ["change", "fam", [["mum", "2A"], ["kid", "2B"]], "pay"],
 ["invoice", "fam"],
 ["change", "fam", [["mum", "7A"]]],
 ["change", "fam", [["mum", "7A"], ["kid", "7B"]]],
 ["invoice", "fam"]]

returns

[true, true, "error: payment required", true,
 {"charged": 9000, "refunded": 0, "net": 9000, "paid_seats": [["mum", "2A"], ["kid", "2B"]]},
 "error: child not with adult", true,
 {"charged": 9000, "refunded": 9000, "net": 0, "paid_seats": []}]

Part 3: Aircraft swap

Goal: operations swaps the aircraft on the flight. Add ["swap_aircraft", aircraft], which installs the new seat map and re-seats everyone who was seated. This also ends an assumption of the earlier Parts: the cabin of a flight can now change.

Rules

1. unknown aircraft if the type does not exist (nothing changes). Swapping to the type already in service is allowed. Passengers who are not seated stay unseated and are not touched.
2. Keep. A seated passenger keeps their seat label if that label exists on the new aircraft, is not blocked there, and is *compatible*: the new seat is exit and the passenger is exit-row eligible and not holding a paid seat; or the new seat is legroom and the passenger holds a paid seat; or the new seat is standard and the passenger does not hold a paid seat.
3. Stranded children. Using the new layout, a kept child who is not adjacent to a *kept* adult of the same booking is not kept either.
4. Refund. Every passenger who is not kept and holds a paid seat gets 4 500 refunded (booking refunded goes up) and no longer holds a paid seat.
5. Re-seat. For each booking in creation order that has passengers who were seated but not kept, run the check-in plan of Part 1 on exactly those passengers (kept passengers act as the already seated members; members who were never seated are left alone). The plan uses the new cabin. If the plan fails, those passengers end up unseated.
6. Result: {"kept": n, "moved": [[pid, old_seat, new_seat], ...], "unseated": [pid, ...], "refunded": [[pid, old_seat, 4500], ...]}. moved and unseated follow booking creation order, then booking order. refunded is ordered by old seat, front row first, letters in the old layout's order. moved lists every passenger re-seated in step 5, even if the new label equals the old one.
7. Everything else keeps working on the new cabin: assign, change, refund_seat, checkin and invoice (refunds made by the swap count in invoice).

Worked example

[["open_flight", "A320"],
 ["book", "fam", [["mum", 34, ""], ["kid", 8, ""]]],
 ["book", "duo", [["x", 30, "T"], ["y", 31, ""]]],
 ["change", "fam", [["mum", "5B"], ["kid", "5C"]]],
 ["assign", "x", "12A"],
 ["swap_aircraft", "E175"],
 ["booking_seats", "duo"]]

returns

[true, true, true, true, true,
 {"kept": 1, "moved": [["kid", "5C", "5A"], ["x", "12A", "12B"]], "unseated": [], "refunded": []},
 [["x", "12B"], ["y", null]]]

(On the E175 5B and 5C are on opposite sides of the aisle, so kid is stranded; 12A is blocked there.)

Notes

• models.py, catalog.py, config.py, errors.py and loadgen.py are known-good.
• You may use the AI assistant freely; you are expected to verify what it produces.
• Later Parts must not break earlier ones; hidden tests re-check earlier behaviour, including on large generated flights (bulk_book), so keep an eye on how often you rescan the cabin.
• Parts 1-2 is a solid result; Part 3 is the hardest.