My cake shop is so popular, I'm adding some tables and hiring wait staff so folks can have a cute sit-down cake-eating experience.

I have two registers: one for take-out orders, and the other for the other folks eating inside the cafe. All the customer orders get combined into one list for the kitchen, where they should be handled first-come, first-served.

Recently, some customers have been complaining that people who placed orders after them are getting their food first. Yikes—that's not good for business!

To investigate their claims, one afternoon I sat behind the registers with my laptop and recorded:

• The take-out orders as they were entered into the system and given to the kitchen. (take_out_orders)
• The dine-in orders as they were entered into the system and given to the kitchen. (dine_in_orders)
• Each customer order (from either register) as it was finished by the kitchen. (served_orders)

Given all three arrays, write a method to check that my service is first-come, first-served. All food should come out in the same order customers requested it.

We'll represent each customer order as a unique integer.

As an example,

would not be first-come, first-served, since order 3 was requested before order 5 but order 5 was served first.

But,

would be first-come, first-served.

Note: Order numbers are arbitrary. They do not have to be in increasing order.

time and additional space.

1. This assumes each customer order in served_orders is unique. How can we adapt this to handle arrays of customer orders with potential repeats?
2. Our implementation returns true when all the items in dine_in_orders and take_out_orders are first-come first-served in served_orders and false otherwise. That said, it'd be reasonable to raise an exception if some orders that went into the kitchen were never served, or orders were served but not paid for at either register. How could we check for those cases?
3. Our solution iterates through the customer orders from front to back. Would our algorithm work if we iterated from the back towards the front? Which approach is cleaner?