Tower of Hanoi

From Wikipedia, the free encyclopedia

A model set of the Towers of Hanoi

Tower of Hanoi, by André Karwath

The Tower of Hanoi or Towers of Hanoi is a mathematical game or puzzle. It consists of three pegs, and a number of disks of different sizes which can slide onto any peg. The puzzle starts with the disks neatly stacked in order of size on one peg, smallest at the top, thus making a conical shape.

The objective of the game is to move the entire stack to another peg, obeying the following rules:

Only one disk may be moved at a time.
Each move consists of taking the upper disk from one of the pegs and sliding it onto another peg, on top of the other disks that may already be present on that peg.
No disk may be placed on top of a smaller disk.

[edit] Origins

Flag Tower of Hanoi

The puzzle was invented by the French mathematician Édouard Lucas in 1883. There is a legend about an Indian temple which contains a large room with three time-worn posts in it surrounded by 64 golden disks. The priests of Brahma, acting out the command of an ancient prophecy, have been moving these disks, in accordance with the rules of the puzzle. According to the legend, when the last move of the puzzle is completed, the world will end. The puzzle is therefore also known as the Tower of Brahma puzzle. It is not clear whether Lucas invented this legend or was inspired by it.

If the legend were true and if the priests were able to move disks at a rate of 1 per second, using the smallest number of moves, it would take them 2⁶⁴ − 1 seconds or roughly 585.442 billion years.^[1] The universe is currently about 13.7 billion years old.

There are many variations on this legend. For instance, in some tellings, the temple is a monastery and the priests are monks. The temple or monastery may be said to be in different parts of the world - including Hanoi, Vietnam, and may be associated with any religion. In some versions, other elements are introduced, such as the fact that the tower was created at the beginning of the world, or that the priests or monks may make only one move per day.

The Flag Tower of Hanoi may have served as the inspiration for the name.

[edit] Solution

Most toy versions of the puzzle have 8 disks. The game seems impossible to many novices, yet is solvable with a simple algorithm:

[edit] Non-recursive solution

In alternate moves:

move the smallest disk to the peg it has not recently come from
move another disk legally (there will only be one possibility)

To decide the first ever move, move the smallest disk to the target final destination peg if there are an odd number of disks, and to the non-target peg if there are an even number.

So if the number of disks is even the solution will start:

Move smallest disk to intermediate peg
Move 2nd smallest disk to target peg
Move smallest disk to target peg
Move 3rd smallest disk to intermediate peg
Move smallest disk to starting peg
Move 2nd smallest disk to intermediate peg
Move smallest disk to intermediate peg
Move 4th smallest disk to target peg
Move smallest disk to target peg
Move 2nd smallest disk to starting peg
Move smallest disk to starting peg
Move 3rd smallest disk to target peg
Move smallest disk to intermediate peg
Move 2nd smallest disk to target peg
Move smallest disk to target peg

etc.

[edit] Recursive algorithm

Label the pegs A, B, C; these labels may move at different steps;
Let n be the total number of disks;
Number the disks from 1 (smallest, topmost) to n (largest, bottommost).

To move n disks from peg A to peg B:

Move n−1 disks from A to C. This leaves the nth disk alone on peg A;
Move the nth disk from A to B;
Move n−1 disks from C to B so they sit on the nth disk.

The above is a recursive algorithm: to carry out steps 1 and 3, apply the same algorithm again for n−1. The entire procedure is a finite number of steps, since at every deeper level of recursion, n is decreased by one and hence at some point the algorithm will be required for n = 1. The step of moving a single disk from peg A to peg B is trivial.

The Tower of Hanoi is a problem often used to teach beginning programming, in particular as an example of a simple recursive algorithm. It is also an example of an exponential time algorithm — for all but the smallest number of disks, it will take an impractically huge amount of time, even on the fastest computers in the world. There is no way to improve on this, because the minimum number of moves required to solve the puzzle is exponential in the number of disks.

Using recurrence relations, we can compute the exact minimum number of moves that this solution requires, which is $2 n - 1$ , where $n$ is the number of disks. This result is obtained by noting that steps 1 and 3 take $T n - 1$ time and step 2 takes constant time, giving $T n = 2 T n - 1 + 1$ .

A simple and elegant implementation in Haskell (a functional programming language) is as follows:

hanoi n = hanoi' n 1 2 3
hanoi' 0 _ _ _ = []
hanoi' n f i t = (hanoi' (n-1) f t i) ++ (f, t) : (hanoi' (n-1) i f t)

where n is the number of disks; this program returns a list of all the moves required.

Here is an mirrored implementation in SML programming language:

fun hanoi (0,_,_,_) = [] | 
hanoi (n,l,c,r) = 
  hanoi(n-1,l,r,c) @ (l,c)::hanoi(n-1,r,c,l);

This is a recursive implementation in C programming language

void move(int n, char src, char dst)
{
        /* moved disk n from peg src to peg dst */
}

void hanoi(int n, char src, char dst, char tmp)
{
        if (n == 0)
                return;

        hanoi(n-1, src, tmp, dst);
        move(n, src, dst);
        hanoi(n-1, tmp, dst, src);
}

To find the optimal solution from an arbitrary initial configuration, the algorithm can be generalized as follows:

char disks[NDISCS];

void move(int n, char dst)
{
        /* moved disk n to peg dst */
        disks[n-1] = dst;
}

void hanoi(int n, char dst)
{
        if (n == 0)
                return;

        if (disks[n-1] != dst) {
                char src = disks[n-1];
                char tmp = /* find the value of the third peg (that isn't src nor dst */ ;
                hanoi(n-1, tmp);
                move(n, dst);
        }
        hanoi(n-1, dst);
}

Where the disks array indicates in which peg each disc is at that moment. As C arrays start at index 0, the position disks[n-1] refers to the nth disk.

[edit] Binary solutions

Disk positions may be determined more directly from the binary (base 2) representation of the move number (the initial state being move #0, with all digits 0, and the final state being #2ⁿ−1, with all digits 1), using the following rules:

There is one binary digit (bit) for each disk
The most significant (leftmost) bit represents the largest disk. A value of 0 indicates that the largest disk is on the initial peg, while a 1 indicates that it's on the final peg.
The bitstring is read from left to right, and each bit can be used to determine the location of the corresponding disk.
A bit with the same value as the previous one means that the corresponding disk is stacked on top the previous disk on the same peg.
- (That is to say: a straight sequence of 1's or 0's means that the corresponding disks are all on the same peg).
A bit with a different value to the previous one means that the corresponding disk is one position to the left or right of the previous one. Whether it is left or right is determined by this rule:
- Assume that the initial peg is on the left and the final peg is on the right.
- Also assume "wrapping" - so the right peg counts as one peg "left" of the left peg, and vice versa.
- Let n be the number of greater disks that are located on the same peg as their first greater disk and add 1 if the largest disk is on the left peg. If n is even, the disk is located one peg to the left, if n is odd, the disk located one peg to the right.

For example, in an 8-disk Hanoi:

Move #0 (00000000)
- The largest disk is 0, so it is on the left (initial) peg.
- All other disks are 0 as well, so they are stacked on top of it. Hence all disks are on the initial peg.
Move #255 (11111111)
- The largest disk is 1, so it is on the right (final) peg.
- All other disks are 1 as well, so they are stacked on top of it. Hence all disks are on the final peg and the puzzle is complete.
Move #216 (11011000)
- The largest disk is 1, so it is on the right (final) peg.
- Disk two is also 1, so it is stacked on top of it, on the right peg.
- Disk three is 0, so it is on another peg. Since n is odd, it is one peg to the right, i.e. on the middle peg.
- Disk four is 1, so it is on another peg. Since n is still odd, it is one peg to the right, i.e. on the right peg.
- Disk five is also 1, so it is stacked on top of it, on the right peg.
- Disk six is 0, so it is on another peg. Since n is even, the disk is one peg to the left, i.e. on the middle peg.
- Disks seven and eight are also 0, so they are stacked on top of it, on the middle peg.

The above algorithm can be coded in Scheme as follows:

(define (conf m h f t) ; m=move number, h=height of tower, f=starting peg, t=destination peg
 ; express the height in the number of disks and identify the pegs by the numbers 0, 1 and 2.
 (let loop ((prev-zero? #t) (mask (arithmetic-shift 1 (sub1 h))) (rotation (- t f)) (f f))
  (if (zero? mask) ()
   (let ((zero-bit? (zero? (bitwise-and mask m))) (mask (arithmetic-shift mask -1)))
    (if (eq? prev-zero? zero-bit?) (cons f (loop zero-bit? mask (- rotation) f))
     (let ((f (modulo (+ f rotation) 3)))
      (cons f (loop zero-bit? mask rotation f))))))))

; This procedure produces a list of the positions of the disks in order of decreasing size.
; Example:

(conf #e6022e20 80 0 2) ; in less than a milisecond on a plain 1.8 GHz personal computer:
;--> (01111111100001201201221111201112012000000210211112002102200222222222222222222222)

The source and destination pegs for the nth move can also be found elegantly from the binary representation of n using bitwise operations. To use the syntax of the C programming language, the nth move is from peg (n&n-1)%3 to peg ((n|n-1)+1)%3, where the disks begin on peg 0 and finish on peg 1 or 2 according as whether the number of disks is even or odd. Furthermore the disk to be moved is determined by the number of times the move count can be divided by 2 (i.e. the number of zero bits at the right), counting the first move as 1 and identifying the disks by the numbers 0, 1, 2 etc in order of increasing size. This permits a very fast non-recursive computer implementation of the solution. It also allows a move and the resulting distribution of disks to be computed without reference to any previous move or distribution of disks:

; h : total number of disks
; m : move counter, starting with 1 for the first move.
; f : starting peg; the pegs are identified by the numbers 0, 1 and 2.
; t : destination peg
; d : disk (numbered 0, 1, 2, etc in order of increasing size)
; Function =quotient= takes two integer numbers and computes their quotient rounded to integer towards zero.
; (rot3 m) : sense of rotation of the remaining third peg during move m.
; (rotd d) : sense of rotation of disk d.
; mcnt : number of moves disk d has made after a total of m moves.
; from : the peg a disk is taken from during move m.
; onto : the peg a disk is put onto during move m.
; thrd : the remaining third peg. (- 3 from onto)
; posi : position of disk d after a total of m moves.

(define (exp2 n        ) (expt   2 n))
(define (mod2 n        ) (modulo n 2))
(define (mod3 n        ) (modulo n 3))
(define (pari n        ) (add1 (mod2 (add1 n))))
(define (rotd h   d f t) (mod3 (* (- t f) (pari (- h d)))))
(define (rot3 h     f t) (rotd h 0 f t))
(define (mcnt m   d    ) (quotient (+ m (exp2 d)) (exp2 (add1 d))))
(define (thrd m h   f t) (mod3 (- f (* m (rot3 h f t)))))
(define (onto m h   f t) (mod3 (- (thrd m h f t) (rotd h (disk m) f t))))
(define (from m h   f t) (mod3 (+ (thrd m h f t) (rotd h (disk m) f t))))
(define (posi m h d f t) (mod3 (+ f (* (rotd h d f t) (mcnt m d)))))

(define 2log (let ((log2 (log 2))) (lambda (z) (/ (log z) log2))))
(define (disk m) (sub1 (inexact->exact (round (2log (add1 (bitwise-xor m (sub1 m))))))))
; This requires that the inexact function 2log is always within one half of the exact value.
; If this condition is not met, the following definition should be used:
; (define (disk m) (if (odd? m) 0 (add1 (disk (quotient m 2)))))         ; for m ≠ 0 or
; (define (disk m) (if (odd? m) 0 (add1 (disk (arithmetic-shift m -1))))) ; for m ≠ 0
; No, Scheme does not have a primitive function like bit-count (which would be nice for function =disk=)

[edit] Gray code solution

The binary numeral system of Gray codes gives an alternative way of solving the puzzle. In the Gray system, numbers are expressed in a binary combination of 0s and 1s, but rather than being a standard positional numeral system, Gray code operates on the premise that each value differs from its predecessor by only one (and exactly one) bit changed. The number of bits present in Gray code is important, and leading zeros are not optional, unlike in positional systems.

If one counts in Gray code of a bit size equal to the number of disks in a particular Tower of Hanoi, begins at zero, and counts up, then the bit changed each move corresponds to the disk to move, where the least-significant-bit is the smallest disk and the most-significant-bit is the largest.

Counting moves from 1 and identifying the disks by numbers starting from 0 in order of increasing size, the ordinal of the disk to be moved during move m is the number of times m can be divided by 2.

This technique tells you which disk to move, but not where to move it to. For the smallest disk there are always two possibilities. For the other disks there is always one possibility, except when all disks are on the same peg, but in that case either it is the smallest disk that must be moved or the objective has already been achieved. Luckily, there is a rule which does say where to move the smallest disk to. Let f be the starting peg, t the destination peg and r the remaining third peg. If the number of disks is odd, the smallest disk cycles along the pegs in the order f->t->r->f->t->r, etc. If the number of disks is even, this must be reversed: f->r->t->f->r->t etc. [1]

[edit] Long solutions

A modification of the game can be to move the tower from one peg to another peg using as many moves as possible without ever producing the same distribution of disks more than once. A simple algorithm (written in Scheme) is:

(define (long-move-tower height from-peg onto-peg thrd-peg)
 (if (positive? height)
  (let ((height-1 (sub1 height)))
   (long-move-tower height-1 from-peg onto-peg thrd-peg)
   (move-disk       height-1 from-peg thrd-peg onto-peg)
   (long-move-tower height-1 onto-peg from-peg thrd-peg)
   (move-disk       height-1 thrd-peg onto-peg from-peg)
   (long-move-tower height-1 from-peg onto-peg thrd-peg))))

Where procedure (move-disk d f t r) moves disk d from peg f onto peg t, ignoring peg r. The number of moves of this uniquely defined solution is 3^height-1 and all 3^height different distributions of disks are traversed (when including the starting distribution). This is called a Hamilton path. For this solution the disk to be moved can be found with a ternary gray code in a similar way as explained for the shortest solution, which is uniquely defined too. In fact there is a ternary Gray code starting with all digits 0 and ending with all digits equal 2, that lists the successive distributions of disks of a Hamilton path from peg 0 to peg 2 for a tower of h disks, each code showing the positions of the disks in decreasing order of size when read from left to right. This Gray code is uniquely defined by imposing the extra condition that each digit is switched more often than each more significant digit on the left. This is the code needed for the Tower of hanoi.

(define (number->p-ary-gray-code n h p) ; n h p --> n-th h digit p-ary gray-code
 (let ((2p (* 2 p)))
  (let loop ((n n) (h h) (gc ()))
   (if (zero? h) gc
    (let ((q (quotient n p)) (r (modulo n 2p)))
     (loop q (sub1 h) (cons (if (>= r p) (- 2p r 1) r) gc)))))))

(define (p-ary-gray-code->number gc p) ; n-th p-ary gray-code --> n
 (let loop ((gc gc) (significance (expt p (sub1 (length gc)))))
  (if (null? gc) 0
   (let ((digit (car gc)) (gc (cdr gc)))
    (let ((n (loop gc (quotient significance p))))
     (+ (* digit significance)
      (if (odd? digit) (- significance n 1) n)))))))

(define (number->hanoian-gray-code n h) (number->p-ary-gray-code n h 3))
(define (hanoian-gray-code->number gc) (p-ary-gray-code->number gc 3))

The disk to be moved is determined by the number of times the move counter can be divided by 3. Where the disk is to be moved to can easily be determined too. For every triplet of moves, move the smallest disk twice in succession in the same direction, followed by a move of one of the larger disks (only one direction possible) Between every triplet of moves reverse the direction of the smallest disk. The very first move of the smallest disk is to be made from the starting peg onto the remaining third peg. Also observe that the remaining third peg of each move alternates between the starting and destination peg. These statements are easily proven by mathematical induction.

(define (exp3 n        ) (expt   3 n))
(define (mod3 n        ) (modulo n 3))
(define (mod4 n        ) (modulo n 4))
(define (mcnt m   d    ) (+ (* 2 (quotient m (exp3 (add1 d)))) (mod3 (quotient m (exp3 d)))))
(define (thrd m h   f t) (if (odd? m) t f))
(define (onto m h   f t) (posi m h (disk m) f t))
(define (from m h   f t) (- 3 (onto m h f t) (thrd m h f t)))
(define (posi m h d f t) (vector-ref (vector f (- 3 f t) t (- 3 f t)) (mod4 (mcnt m d))))
(define (disk m) (if (zero? (mod3 m)) (add1 (disk (quotient m 3))) 0))

Another modification is to move a tower from a peg back to the same peg while traversing all distributions of disks. (circular Hamilton path) There are exactly two solutions, but they mirror each other in the sense that there is in fact one path that can be traversed in both directions. Obviously, the length of the path is 3^height. A simple algorithm for the circular Hamilton path is:

(define (circular-hamilton-move-tower h a b c) ; h=height. a, b and c are the three pegs.
 (if (positive? h) ; start with a tower at peg a, move tower to peg b, then to peg c and finally return to peg a.
  (let ((h-1 (sub1 h)))
   (hamilton-start  h-1 a c b)   ; The largest disk is moved three times.
   (move-disk       h-1 a b c)   ; Between these moves the longest non selfcrossing path is used in order to move the
   (long-move-tower h-1 c a b)   ; partial tower consisting of the h-1 smaller disks from one peg onto another one.
   (move-disk       h-1 b c a)   ; Together the procedures hamilton-start and hamilton-finish make such a longest
   (long-move-tower h-1 a b c)   ; non selfcrossing path too. The moves made by hamiton-finish followed by
   (move-disk       h-1 c a b)   ; those of hamilton-start form a longest non selfcrossing path for the same
   (hamilton-finish h-1 b a c)))); partial tower from peg b to peg c.

(define (hamilton-start h a b c)
 (if (positive? h)
  (let ((h-1 (sub1 h)))
   (hamilton-start  h-1 a c b)
   (move-disk       h-1 a b c)
   (long-move-tower h-1 c b a))))

(define (hamilton-finish h a b c)
 (if (positive? h)
  (let ((h-1 (sub1 h)))
   (long-move-tower h-1 a c b)
   (move-disk       h-1 a b c)
   (hamilton-finish h-1 c b a))))

[edit] Graphical representation

The game can be represented by an undirected graph, the nodes representing distributions of disks and the branches representing moves. For one disk, the graph is a triangle:

 /\
/__\

For h+1 disks, take the graph of h disks and replace each small triangle by:

     /\
    /__\
   /    \
  /      \
 /\      /\
/__\ __ /__\

The above graph is for 2 disks. The angular points of the outermost triangle represent distributions with all disks on the same peg. For 3 disks the graph is:

                 ccc
                 /\         ; call the pegs a, b and c
            acc /__\ bcc    ; list disk positions from left to right in order of increasing size
               /    \
          abc /      \ bac
             /\      /\
        bbc /__\ __ /__\ aac
           /  cbc  cac  \
      bba /              \ aab
         /\              /\
    cba /__\aba      bab/__\ cab
       /    \          /    \
  caa /      \aca  bcb/      \ cbb
     /\      /\      /\      /\
aaa /__\ __ /__\ __ /__\ __ /__\ bbb
      baa  bca cca ccb acb abb

Each side of the outermost triangle represent the shortest ways of moving a tower from one peg to another one. The branch in the middle of the sides of the largest triangle represents a move of the largest disk. The branch in the middle of the sides of each next smaller triangle represents a move of each next smaller disk. The sides of the smallest triangles represent moves of the smallest disk.

The longest non repetive way for three disks can be visualized by erasing the unused branches:

                 ccc
                 /\         ; call the pegs a, b and c
            acc /  \ bcc    ; list disk positions from left to right in order of increasing size
               /    \
          abc /      \ bac
              \      /
        bbc  __\    /__  aac
           /  cbc  cac  \
      bba /              \ aab
         /                \
    cba /__ aba      bab __\ cab
            \          /
  caa        \aca  bcb/        cbb
     /\       \      /       /\
aaa /  \ __  __\    /__  __ /  \ bbb
      baa  bca cca ccb acb abb

The circular hamilton path for three disks is:

                 ccc
                 /\         ; call the pegs a, b and c
            acc /  \ bcc    ; list disk positions from left to right in order of increasing size
               /    \
          abc /      \ bac
              \      /
        bbc  __\    /__  aac
           /  cbc  cac  \
      bba /              \ aab
          \              /
    cba  __\aba      bab/__  cab
       /                    \
  caa /       aca  bcb       \ cbb
     /       /\      /\       \
aaa /__  __ /  \ __ /  \ __  __\ bbb
      baa  bca cca ccb acb abb

The graphs clearly show that:

From every arbitrary distribution of disks, there is exactly one shortest way to move all disks onto one of the three pegs.
Between every pair of arbitary distributions of disks there are one or two different shortest paths.
From every arbitrary distribution of disks, there are one or two different longest non selfcrossing paths to move all disks to one of the three pegs.
Between every pair of arbitary distributions of disks there are one or two different longest non selfcrossing paths.
Let N_h be the number of non selfcrossing paths for moving a tower of h disks from one peg to another one. Then:
- N₁=2
- N_h+1=(N_h)²+(N_h)³.
- For example: N₈≈1.5456x10⁷⁹⁵

[edit] Applications

The Tower of Hanoi is frequently used in psychological research on problem solving. There also exists a variant of this task called Tower of London for neuropsychological diagnosis and treatment of executive functions.

The Tower of Hanoi is also used as Backup rotation scheme when performing computer data Backups where multiple tapes/media are involved.

As mentioned above, the Tower of Hanoi is popular for teaching recursive algorithms to beginning programming students. A pictorial version of this puzzle is programmed into the emacs editor, accessed by typing M-x hanoi. There is also a sample algorithm written in Prolog.

The Tower of Hanoi is also used as a memory test by neuropsychologists trying to evaluate amnesia.

[edit] Four pegs and beyond

Although the three-peg version has a simple recursive solution as outlined above, the optimal solution for the Tower of Hanoi problem with four or more pegs is still an open problem. This is a good example of how a simple, solvable problem can be made dramatically more difficult by slightly loosening one of the problem constraints.

The fact that the problem with four or more pegs is an open problem does not imply that no algorithm exists for finding (all of) the optimal solutions. Simply represent the game by an undirected graph, the nodes being distributions of disks and the edges being moves (of length 1) and use Dijkstra's algorithm to find one (or all) shortest paths moving a tower from one peg onto another one. However, even smartly implemented on the fastest computer now available, this algorithm provides no way of effectively computing solutions for large numbers of disks; the program would require more time and memory than available. Hence, even having an algorithm, it remains unknown how many moves an optimal solution requires and how many optimal solutions exist for 1000 disks and 10 pegs.

Though it is not known exactly how many moves must be made, there are some asymptotic results. There is also a "presumed-optimal solution" that can be recursively applied to find a solution - see Paul Stockmeyer's survey paper for an explanation and some variants of the four-peg problem.

Although it agrees with computer experiments for small numbers of disks, there is not yet a general proof that this presumed-optimal solution is in fact optimal. However, results in 2004 showed that the presumed-optimal solution must be of the same order of magnitude as the optimal solution.

[edit] Description of the presumed-optimal solution

The problem for four pegs is sometimes called "Reve's puzzle". A solution for four (or more) pegs, which has not been proved to be optimal, is described below:

Let $n$ be the number of disks.
Let $r$ be the number of pegs.
Define $T (n, r)$ to be the number of moves required to transfer n disks using r pegs

The algorithm can be described recursively:

For some $k$ , $1 \leq k < n$ , transfer the top $k$ disks to a single other peg, taking $T (k, r)$ moves.
Without disturbing the peg that now contains the top $k$ disks, transfer the remaining $n - k$ disks to the destination peg, using only the remaining $r - 1$ pegs, taking $T (n - k, r - 1)$ moves.
Finally, transfer the top $k$ disks to the destination peg, taking $T (k, r)$ moves.

The entire process takes $2 T (k, r) + T (n - k, r - 1)$ moves. Therefore, we should pick $k$ for which this quantity is minimum.
This algorithm (with the above choice for $k$ ) is presumed to be optimal, and no counterexamples are known.

[edit] Two stacks and more stacks

A recent U.S. patent application discloses multi-stack Tower of Hanoi puzzles [Feb. 1, 2007, Serial No.11/701,454] with two or more stacks and twice as many pegs as stacks. After beginning on a particular peg, each stack displaces and is displaced by a different colored stack on another peg when the puzzle is solved. Disks of one color also have another peg that excludes all other colors, so that there are three pegs available for each color disk, two that are shared with other colors and one that is not shared. On the shared pegs, a disk may not be placed on a different colored disk of the same size, a possibility that does not arise in the standard puzzle.

The simplest multi-stack game has two stacks and four pegs, and it requires three times as many moves to solve as the single stack classic. The game proceeds in seesaw fashion with longer and longer series of moves that alternate between colors. It concludes in reverse seesaw fashion with shorter and shorter such series of moves. Starting with the second series of three moves, these alternate series of moves double in length for the first half of the game, and the lengths are halved as the game concludes. The solution involves nesting an algorithm suitable for Tower of Hanoi into an algorithm that indicates when to switch between colors.

The addition of a centrally located universal peg open to disks from all stacks converts these multi-stack Tower of Hanoi puzzles to multi-stack Reve's puzzles as described in the preceding section. In these games four pegs are available for each color disk, two that are shared with one or two other colors depending on the number of stacks, one that is shared with all other colors however many stacks there are, and one that is not shared with other colors. The simplest game of this kind has two stacks and five pegs, and it can be solved in fewer moves than a one stack three peg game, if these moves are well executed. For this puzzle, the nested algorithm within the algorithm governing when to switch colors is for the four-peg variation of Tower of Hanoi, not the three peg standard. Two ten disk stacks may be interchanged with the extra peg in a few more moves than it takes to solve a seven disk standard Tower of Hanoi.

[edit] In popular culture

In the classic science fiction story Now Inhale, by Eric Frank Russell (Astounding Science Fiction April 1959, and in various anthologies), the human hero is a prisoner on a planet where the local custom is to make the prisoner play a game until it is won or lost, and then execution is immediate. The hero is told the game can be one of his own species', as long as it can be played in his cell with simple equipment strictly according to rules which are written down before and cannot change after play starts, and it has a finite endpoint. The game and execution are televised planet-wide, and watching the desperate prisoner try to spin the game out as long as possible is very popular entertainment; the record is sixteen days. The hero knows a rescue ship might take a year or more to arrive, so chooses to play Towers of Hanoi with 64 disks until rescue arrives. When the locals realize they've been had, they are angry, but under their own rules there is nothing they can do about it. They do change the rules, which will apply to any future prisoners. This story makes reference to the legend about the Buddhist monks playing the game until the end of the world, and refers to the game as arkymalarky. (The slang term "malarky", meaning nonsense, pre-dates this story by at least 30 years. [2])

In the Doctor Who serial "The Celestial Toymaker", the Toymaker challenges the Doctor to complete the "Trilogic Game" (ten disk Hanoi) in exactly 1,023 (2¹⁰ − 1) moves.

There is a band named Towers of Hanoi.

[edit] In video games

The puzzle is featured regularly in adventure and puzzle games. Since it is easy to implement, and easily-recognised, it is well-suited to use as a puzzle in a larger graphical game. Some implementations use straight disks, but others disguise the puzzle in some other form. What follows is a partial list of games which use the puzzle:

[edit] Notes

^ 1000 Play Thinks

[edit] See also

Baguenaudier

[edit] External links

Wikimedia Commons has media related to:

Tower of Hanoi

[edit] Online Demonstration

[edit] History

[edit] Algorithm

[edit] Events

[3] Workshop on the Tower of Hanoi and Related Problems, 18.9. - 22.9.2005, Maribor, Slovenia

Retrieved from "http://en.wikipedia.org../../../t/o/w/Tower_of_Hanoi_3a61.html"

Categories: Mechanical puzzles | Articles with example Haskell code | Articles with example Scheme code