Code for the plane boarding simulator. It's a little messy, but it's a hack project.

boarding_sim.py

import random
from copy import deepcopy as dc
import itertools
import numpy as np

################################################################################
### Helper functions & classes
################################################################################

def genLoadTime():
    mu, sigma = 60, 30
    return int(random.gauss(mu, sigma))

def grouper(n, iterable, fillvalue=None):
    args = [iter(iterable)] * n
    return itertools.izip_longest(fillvalue=fillvalue, *args)

titles = ["back2front",
          "front2back",
          "random"]

def createRosters():
    rows = 30
    seats_per_row = 6
    num_groups = 6
    group_size = rows*seats_per_row/num_groups

    # Create passenger roster
    plane = [Passenger(i) for i in range(rows*seats_per_row)]

    # Split into boarding groups and shuffle passengers within groups
    boarding_groups = [p for p in grouper(group_size, plane)]
    boarding_groups = [list(p) for p in boarding_groups]
    
    # shuffle in place
    [random.shuffle(p) for p in boarding_groups]

    # Create a list of passengers organized by group, front to back
    # Had trouble getting this to work other more concise ways
    front2back = []
    for p in dc(boarding_groups):
        front2back.extend(p)

    # Create a list of passengers organized by group, back to front
    boarding_groups.reverse()
    back2front = []
    for p in dc(boarding_groups):
        back2front.extend(p)

    # Randomly order all passengers on the plane
    random_order = dc(plane)
    random.shuffle(random_order)

    rosters = zip(titles, [back2front, front2back, random_order])

    return rosters

################################################################################
### Main functions & classes
################################################################################

class Passenger():
    def __init__(self, assigned_seat):
        self.seat = assigned_seat
        self.time = genLoadTime()
        self.state = "BOARDING" # boarding
        self.cur_row = 0

    def atSeat(self):
        return self.seat == self.cur_row

    def moveTo(self, n):
        if n > self.seat:
            self.cur_row = self.seat
            self.state = "TRANS" # transition

        else:
            self.cur_row = n

    def update(self, next):
        if self.state == "BOARDING":
            if next >= self.cur_row:
                self.moveTo(next)
            
            # boarding, arrives at seat, change to sitting process
            if self.atSeat():
                self.state = "TRANS"
        
        elif self.state == "TRANS":
            if self.time <= 0:
                self.state = "SEATED"

            # decremend time to sitting
            self.time -= 1

        return self.cur_row - 1

def boarding_sim(passengers, rows):
    num_seated = 0
    time = 0

    while num_seated < len(passengers):
        time += 1
        next_avail = rows

        for p in passengers:
            #print "({}) passenger: {}, state: {}".format(time, p.seat, p.state)

            if p.state == "SEATED":
                continue

            next_avail = p.update(next_avail)

            if p.state == "SEATED":
                num_seated += 1

    return time

################################################################################
### Testing functions
################################################################################

def testPassenger():
    p = Passenger(10)

    print "p is {}".format(p.state)
    print "p at seat? {}".format(p.atSeat())
    print "p moves to 5, next avail seat is {}".format(p.moveTo(5))
    print "p moves to 15, next avail seat is {}".format(p.moveTo(15))
    print "p is {} at row {}".format(p.state, p.cur_row)

    count = 0

    while p.state != "SEATED":
        p.update(0)
        count += 1

    print "p took {} steps to sit, in state {}".format(count, p.state)

################################################################################
### Running code
################################################################################

results = {}
for title in titles:
    results[title] = []

num_iters = 20
for c in range(num_iters):
    rosters = createRosters()

    for key, ordering in rosters:
        results[key].append(boarding_sim(ordering, len(ordering)))

# format for csv
sets = zip(results["back2front"], results["front2back"], results["random"])

print "cycle, b2f, f2b, random"
count = 0
for b2f, f2b, randomo in sets:
    print "{}, {}, {}, {}".format(count, b2f, f2b, randomo)
    count += 1