Question

C++

Lists, and a little queuing theory

The MegaMicroMart (a subsidiary of Fly-By-Night Industries) is planning their next Big Small-Box

Store. They want to ensure good customer service, and you've been hired to do some simulations to

advise them on how to set up their checkout lines.

This is a

discrete-time

simulation. This means that for our purposes, time advances in discrete 'ticks'.

Each tick, everyone who's going to arrive arrives all at once, while at the same time everyone who's

finished and ready to leave, does so all at once. Once everything for this tick has happened, we move

on to the next tick.

To simplify the simulation, we'll make some assumptions:

•

Each tick of the simulation is 10 seconds (so there are six 'ticks' per minute)

•

Customers arrive independently. Each tick, zero or more customers will arrive and want to

check out.

•

Unless specified otherwise, customers will go to the checkout line (cash register) with the

fewest customers waiting. Ties can be broken via any convenient method.

•

Customers will not jump lines from one register to the next.

•

Customers will have varying numbers of items in their cart. Checkers can check 3 items per

tick. When determining how many ticks will be needed to check out all the customer's items,

round all fractions up.

•

After all items are checked, the customer will pay. Some customers will have scanned their

credit cards while the order was being checked and need almost no time to finish; others will

wait until all items are checked to start looking for their card. Thus, payment will take 0-3

additional ticks (random, uniform probability).

•

Payment completes the simulation. Once a customer has paid, they leave and the next waiting

customer can begin on the next tick.

•

For this simulation, all registers are open all the time; we will not incorporate real-world rules

such as “if your register is idle for more than a minute, close it and go do something else.” But

the MegaMicroManagers at MegaMicroMart do want to track how much idle time the registers

have, so they know how much their customer-service policy is costing them.

You have 3 input files:

steadystate.txt: The number of customers arriving is about what the system is expected to be able to

handle.

bigcrunch.txt: The number of customers is fairly low, then there is an abrupt rush as a large number of

customers arrive in a short time. The question here is how long the lines can get.

bigtickets.txt: Similar to the steady-state data, but a few customers in this data set have their carts

rounded over, with many more items (and thus more time needed to check out).

In each case, you will process the data in order; once the end of the input is reached you will continue

processing the customers already in line until the last customer has left the system. You will report, for

each data set and each operating condition (discussed below), the following data:

•

The number of customers served

•

The maximum length of any line

•

The average length of time customers spent waiting in line

•

The maximum length of time any customer spent waiting in line

•

The total amount of time registers were idle. (Note that if 3 registers were idle for 2 ticks, that's

a total of 6 idle ticks.)

You will report these statistics for each of these 3 data files under 2 different operating assumptions:

The first is that all registers are functionally identical. The second is that the first register is reserved as

an express line and may only be used by customers with 10 items or fewer. If a customer has 10 items

or fewer, they may go to any empty register; if no register is empty, they will go to the express line.

Customers with more than 10 items must select something other than the express line, even if the

express line is idle. (note: This may lead to some odd behavior, depending on the data. You may want

to experiment with other rules, such as “if the express line has no more than 3 more than the shortest

regular line, use the express line, otherwise use the shortest regular line.” If you try different rules,

discuss them in your final writeup.)

input files "steadystate.txt":

3       11
4       5
5       11

input files "bigcrunch.txt":

0       10
0       8
0       14
1       6
2       16
3       9
3       6

input file "bigtickets.txt":

0       8
1       14
3       9
4       15
4       8