Seating Arrangement Problems Explained — Formulas, Tricks & Solved Examples

import math

def linear_arrangements(total_people):
    """
    Count arrangements of 'total_people' in a straight row.
    Every position is unique, so full permutation applies.
    """
    return math.factorial(total_people)

def circular_arrangements(total_people):
    """
    Count arrangements around a round table.
    We fix one person to eliminate rotational duplicates,
    then arrange the remaining (total_people - 1) freely.
    """
    if total_people < 1:
        return 0
    return math.factorial(total_people - 1)

def circular_necklace_arrangements(total_people):
    """
    For a necklace / identical chairs where flipping = same arrangement.
    Divide circular count by 2 to eliminate mirror duplicates.
    """
    if total_people < 1:
        return 0
    return math.factorial(total_people - 1) // 2

# --- Demo ---
people = 6

print(f"People: {people}")
print(f"Linear (straight row):          {linear_arrangements(people):>6}")
print(f"Circular (round table):         {circular_arrangements(people):>6}")
print(f"Necklace (flip = same):         {circular_necklace_arrangements(people):>6}")

# Step-by-step breakdown to show the maths
print("\n--- Why the numbers differ ---")
print(f"Linear  = {people}!  = {math.factorial(people)}")
print(f"Circular = ({people}-1)! = {people-1}! = {math.factorial(people-1)}")
print(f"Necklace = ({people}-1)!/2 = {math.factorial(people-1)//2}")
print(f"\nRatio Linear/Circular = {linear_arrangements(people)//circular_arrangements(people)}")
print(f"That ratio equals N ({people}) — exactly the rotational duplicates we removed.")

import math

def circular_with_bundle(total_people, bundle_size):
    """
    Round-table arrangements where 'bundle_size' specific people
    must ALWAYS sit together.

    Step 1: Treat the bundle as one unit.
            Total units = total_people - bundle_size + 1
    Step 2: Circular arrangements of those units = (units - 1)!
    Step 3: Internal arrangements of the bundle = bundle_size!
    Step 4: Multiply Step 2 × Step 3
    """
    units = total_people - bundle_size + 1   # bundle counts as 1 seat
    circular_of_units = math.factorial(units - 1)  # fix one unit, arrange rest
    internal_bundle   = math.factorial(bundle_size) # bundle members swap freely

    total = circular_of_units * internal_bundle
    return total, circular_of_units, internal_bundle, units

# --- Problem: 6 people around a round table; Alice, Bob and Carol MUST sit together ---
total   = 6
bundle  = 3  # Alice, Bob, Carol

total_ways, circ, internal, units = circular_with_bundle(total, bundle)

print(f"Total people : {total}")
print(f"Bundle size  : {bundle} (must sit together)")
print(f"Units to arrange around table : {units}  (bundle + {total - bundle} individuals)")
print(f"\nCircular arrangements of {units} units : ({units}-1)! = {units-1}! = {circ}")
print(f"Internal arrangements of bundle       : {bundle}! = {internal}")
print(f"\nTotal valid arrangements : {circ} × {internal} = {total_ways}")

# --- Compare: no restriction baseline ---
baseline = math.factorial(total - 1)
print(f"\nBaseline (no restriction)              : {baseline}")
print(f"Restriction reduces count by factor    : {baseline / total_ways:.2f}x")

import math

def circular_never_together(total_people, restricted_pair_count=1):
    """
    Round-table arrangements where one specific PAIR must NEVER sit together.

    Complement approach:
      Total circular arrangements
      MINUS arrangements where the pair IS together (bundle trick)
    """
    # Total: fix one person, arrange the rest
    total_circular = math.factorial(total_people - 1)

    # Bad cases: treat the pair as one bundle
    # units = total_people - 2 + 1 = total_people - 1
    units_with_bundle     = total_people - 2 + 1
    bundle_circular       = math.factorial(units_with_bundle - 1)  # circular of units
    bundle_internal       = math.factorial(2)                       # pair can swap: AB or BA
    arrangements_together = bundle_circular * bundle_internal

    valid = total_circular - arrangements_together
    return total_circular, arrangements_together, valid

# --- Problem: 5 people at a round table; Dave and Eve must NEVER be adjacent ---
total = 5

total_circ, together, valid = circular_never_together(total)

print(f"Total people : {total}")
print(f"\nStep 1 — Total circular arrangements : ({total}-1)! = {total-1}! = {total_circ}")
print(f"Step 2 — Arrangements where the pair")
print(f"         IS together (bundle method)  : {together}")
print(f"Step 3 — Valid (pair never adjacent)  : {total_circ} - {together} = {valid}")

# --- Verification by brute force for small N ---
from itertools import permutations

people = ['A', 'B', 'C', 'D', 'E']  # D and E are the restricted pair
restricted = {'D', 'E'}

def are_adjacent_circular(arrangement, p1, p2):
    """Check if p1 and p2 sit next to each other in a circular layout."""
    n   = len(arrangement)
    idx1 = arrangement.index(p1)
    idx2 = arrangement.index(p2)
    # In a circle, neighbours of seat i are (i-1)%n and (i+1)%n
    return abs(idx1 - idx2) == 1 or abs(idx1 - idx2) == n - 1

# Fix 'A' in position 0 to eliminate rotational duplicates
fixed_arrangements = [
    ('A',) + perm
    for perm in permutations(['B', 'C', 'D', 'E'])
]

valid_brute = [
    arr for arr in fixed_arrangements
    if not are_adjacent_circular(list(arr), 'D', 'E')
]

print(f"\nBrute-force verification            : {len(valid_brute)} valid arrangements")
print(f"Formula matches brute force         : {valid == len(valid_brute)}")

import math

print("=" * 55)
print("PROBLEM 1: 7 people, round table, no restrictions")
print("=" * 55)
total_people = 7
arrangements_p1 = math.factorial(total_people - 1)
print(f"Formula : (N-1)! = ({total_people}-1)! = {total_people-1}! = {arrangements_p1}")

print()
print("=" * 55)
print("PROBLEM 2: 7 people, round table")
print("         Tom and Jerry MUST sit together")
print("=" * 55)
total_people  = 7
bundle_size   = 2  # Tom and Jerry

units         = total_people - bundle_size + 1   # treat bundle as 1 unit => 6 units
circ_units    = math.factorial(units - 1)         # circular arrange 6 units => 5!
internal      = math.factorial(bundle_size)        # Tom-Jerry or Jerry-Tom => 2!
arrangements_p2 = circ_units * internal

print(f"Step 1 : Bundle Tom+Jerry => {units} units to place")
print(f"Step 2 : Circular of {units} units = ({units}-1)! = {units-1}! = {circ_units}")
print(f"Step 3 : Internal bundle arrangements = {bundle_size}! = {internal}")
print(f"Answer : {circ_units} × {internal} = {arrangements_p2}")

print()
print("=" * 55)
print("PROBLEM 3: 7 people, round table")
print("         Tom and Jerry must NEVER sit together")
print("=" * 55)
total_people      = 7

# Total unrestricted circular
total_circular    = math.factorial(total_people - 1)

# Bad cases: Tom+Jerry as bundle
bundle_units      = total_people - 2 + 1           # 6 units
bad_circular      = math.factorial(bundle_units - 1) # 5!
bad_internal      = math.factorial(2)               # 2! = 2
bad_together      = bad_circular * bad_internal

arrangements_p3   = total_circular - bad_together

print(f"Step 1 : Total circular = (7-1)! = 720")
print(f"Step 2 : Together count (bundle) = {bad_circular} × {bad_internal} = {bad_together}")
print(f"Answer : {total_circular} - {bad_together} = {arrangements_p3}")

print()
print("=" * 55)
print("SUMMARY")
print("=" * 55)
print(f"No restriction  : {arrangements_p1}")
print(f"Must together   : {arrangements_p2}")
print(f"Never together  : {arrangements_p3}")
print(f"Sanity check    : 'must' + 'never' + rest should relate to total")
print(f"  Never ({arrangements_p3}) + Together ({arrangements_p2}) = {arrangements_p3 + arrangements_p2} (should = {arrangements_p1})")