Pass the Buck
Every good programmer is lazy, arrogant, and
impatient. In the game “Pass the Buck” you try to do
as little work as possible, by making your neighbor
do most of the work. Your neighbor is nearly as smart
as you, and can do what you can do – almost, so the
problem that you give your name has to be (at least) a
little smaller than the problem that you have to solve.
Example
Suppose that you are asked to sort a list of 10
numbers. Instead of doing all the work, you just take
the first number off the list, and then pass the buck to
your neighbor – you ask your neighbor to sort the
remaining list of 9 numbers. When your neighbor
gives you his or her answer, you just have to insert
that first number back into the right place in the list
and you're done.
Pass the Buck (cont'd)
You pass the buck to your neighbor. Your neighbor is
also lazy, and will try to do as little work as possible
by playing Pass the Buck. So, your neighbor, in this
example, will take the first number from the list and
then pass the buck to his or her neighbor, who does
the same thing. And so on and so on, until...
The Idiot Case
The buck is passed until the problem is so simple,
that any idiot could solve it (the idiot case.) In our
example, this would be the list with just one number.
So, the last person – the idiot – just solves the
problem directly, and returns the answer to the
neighbor who gave it to him or her. That person finds
the solution to their problem, and returns it to their
neighbor who gave them the problem ...
Example
In the problem is to sort a list of five numbers:
7 1 3 6 4.
Person 1 takes 7 from the list and asks Person 2 to
sort the list 1 3 4 6. Person 2 takes 1 from the list and
ask Person 3 to sort 3 4 6. Person 3 takes 3 from the
list and asks Person 4 to sort 4 6. Person 4 takes 6
from the list and asks Person 5 to sort the list 4. This
is the idiot case, so Person 6 returns 4.
Example (cont'd)
Person 4 then adds 6 in the proper place and gives
back the list 4 6. Person 3 adds 3 back to the list,
giving 3 4 6. Person 2 adds 1 to the list giving 1 3 4
6, and Person 1 adds 7 back in, which yields 1 3 4 6
7, the correct answer.
Another Example
Suppose instead of just taking the first number from
the list, Person 1 (and hence everyone else, since they
all should do the same thing except for the idiot),
finds the smallest number from the list and removes
that number. Then, after passing the buck and getting
back the list from Person 2, Person 1 just has to stick
the smallest number to the beginning of the list to
sort the whole list.
Sorting
The first example is actually insertion sort, and then
second example is selection sort. Is this just another
way of writing the sort, or is it more efficient? Each
person does a little bit of work, but how much work
does everyone do put together? In the first example,
each person (except for the idiot), removes the first
number which takes constant time, and then later has
to put the number back in the right place.
Sorting (cont'd)
This takes N-1 comparisons if the list has N numbers.
So, Person 1 does 5 – 1 comparisions, Person 2, does
4 – 1 comparisons, and so on...until the idiot who
does no comparisons. In general, given a list of size
N, Person 1 does N-1 comparisons, Person 2 does N2 comparisons...down to 1, then 0 comparison, for a
total of N*(N-1)/2 comparisons which is the same as
insertion sort.
Other Sorting
In the second example, Person 1 finds the smallest
number first which takes N-1 comparisons. To finish
up the job, Person 1 just sticks the number back at the
beginning of the list which is constant time. So,
again, the total number of comparisons is N * (N-1)/2
which is the same as selection sort.
The Rules of Pass the Buck
Given a problem of size N, you must find a smaller
problem of the same type, and give that problem to
your neighbor. Your neighbor solves his or her
problem and gives you back the solution. You must
then extend that solution to be a solution to the
original problem. Since your neighbor also passes the
back, the problem keeps getting smaller and smaller
until any idiot can do it. The idiot solves his or her
problem directly and returns the answer.
Tower of Hanoi Problem
An example where it's easier to play Pass the Buck
then to solve a problem directly is the Tower of
Hanoi problem. The puzzle has three wooden pegs.
On one peg are place a number of disks of various
sizes, with the biggest disk on the bottom and then
disks getting smaller as you go up. The problem is to
move the stack of disks from the first peg to the third
peg.
Tower of Hanoi (cont'd)
However, you can only move one disk at a time, and
you may not put a larger disk on top of a smaller
disk, i.e., a disk can only be moved to an empty peg,
or onto a larger disk.
Solution
If your problem is to move N disks from peg 1 to peg
3, then you pass the buck by asking your neighbor to
move N-1 disks (the top N-1 disks) from peg 1 to peg
2 (the spare peg). Then you move the bottom disk
from peg 1 to peg 3. Finally you ask your neighbor to
move the stack of N-1 disks from peg 2 to peg 3,
completing the entire task.
The idiot case is when there is just one disk in the
stack – just move the disk directly.
Sorting Redux
Another way to sort is to make the list smaller by
more than one element. Split the list in half – have a
neighbor sort the first half, and then have a neighbor
sort the second half. Then you must merge the two
sorted lists into one sorted list. Merging takes N-1
comparisons (at worst), so it is simpler than sorting.
Mergesort
The idiot case is again, when there is just one number
in the list or the list is empty. In both cases, there's
nothing to do, just return the list.
The first person does N-1 comparisons for the merge
step - the split is constant. The second person has to
sort a list of size N/2, which takes N/2-1
comparisons, but is asked to do that twice. The third
person sorts 4 lists, of size N/4, and so on. The total
number of comparison is N * log2(N).
Another Sort
Another way to split the list of numbers is into a list
of small numbers and a list of large numbers. For this
example, we will use the first number of the list to
decide which numbers are large and which numbers
are small. Numbers less than the first number are
considered small, and numbers greater than the first
number are considered large. We assume no duplicate
numbers in this example.
Another Sort (cont'd)
So, the first person removes the first number from the
list, and then using that number splits the list into two
(not necessarily equal) pieces – the numbers that are
less than the first number and the numbers that are
greater than the first number. The buck is passed
(twice) and both sub-lists are sorted.
The first person just puts the two lists together with
the first number in between them.
How much work is done?
It takes linear time to split the list into the two pieces,
but only constant time to put the lists back together
(assuming that we're working with arrays and
keeping the numbers in place). However, since the
list isn't split in half, we can't assume that the two
lists are size N/2. If we're lucky, and they are, then
the time is the same as mergesort, i.e., N log2(N).
Worst Case
In the worst case, the first number is the smallest
number in the list (or the largest) and then all the rest
of the numbers fall in the list of large numbers with
none in the small number list. So, the buck is passed
twice, once with the empty list (an idiot case) and
once with a list of size N-1. This becomes (if
repeated) the same as insertion sort, i.e., N*(N-1)/2.