How to solve the Towers of Hanoi puzzle

The Classical Towers of Hanoi - an initial position of all disks is on post 'A'.

Fig. 1 The solution of the puzzle is to build the tower on post 'C'.

Fig. 2 The Arbitrary Towers of Hanoi - at start, disks can be in any position provided that a bigger disk is never on top of the smaller one (see Fig. 3). At the end, disks should be in another arbitrary position. * )

Fig. 3

Solving the Tower of Hanoi

'Solution' shortest path Recursive Solution:

1. Identify biggest discrepancy (=disk N) 2. If moveable to goal peg Then move Else 3. Subgoal: set-up (N1)-disk tower on non-goal peg.

4. Go to 1. ... Some authors use the term "regular" position for any of the 3ndisk arrangements that obey the rule of no disk on top of a smaller disk, and "perfect" position for one of the 3 disk arrangements with all disks on a single peg. Then the above algorithm is optimal between a regular position and a perfect position, or between a perfect position and a regular position, but not between two regular positions. P.K. Stockmeyer

Solving the Tower of Hanoi - 'regular' to 'perfect'

Let's start thinking how to solve it. Let's, for the sake of clarity, assume that our goal is to set a 4 diskhigh tower on peg 'C' - just like in the classical Towers of Hanoi (see Fig. 2). Let's assume we 'know' how to move a 'perfect' 3 disk-high tower. Then on the way of solving there is one special setup. Disk 4 is on peg 'A' and the 3 disk-high tower is on peg 'B' and target peg 'C' is empty.

Fig. 4 From that position we have to move disk 4 from 'A' to 'C' and move by some magic the 3 disk-high tower from 'B' to 'C'. So think back. Forget the disks bigger than 3. Disk 3 is on peg 'C'. We need disk 3 on peg 'B'. To obtain that, we need disk 3 in place where it is now, free peg 'B' and disks 2 and 1 stacked on peg 'A'. So our goal now is to put disk 2 on peg 'A'.

Fig. 5 Forget for the moment disk 3 (see Fig. 6). To be able to put disk 2 on peg 'A' we need to empty peg 'A' (above the thin blue line), disks smaller than disk 2 stacked on peg 'B'. So, our goal now is to put disk 1 on peg 'B'. As we can see, this is an easy task because disk 1 has no disk above it and peg 'B' is free.

Fig. 6 So let's move it.

Fig. 7 The steps above are made by the algorithm implemented in Towers of Hanoi when one clicks the "Help me" button. This button-function makes analysis of the current position and generates only one single move which leads to the solution. It is by design. When the 'Help me' button is clicked again, the algorithm repeats all steps of the analysis starting from the position of the biggest disk - in this example disk 4 - and generates the next move - disk 2 from peg 'C' to peg 'A'.

Fig. 8 If one needs a recursive or iterative algorithm which generates the series of moves for solving arbitrary Towers of Hanoi then one should use a kind of back track programming, that is to remember previous steps of the analysis and not to repeat the analysis of the Towers from the ground. But this is another story.

*)

Mind that this setup may be not on the shortest path between the start and the end of the classical Towers. This can happen if one has made some wrong moves while resolving the classical Towers.

Towers of Hanoi Puzzle

Towers of Hanoi (aka Tower of Hanoi) is a mathematical puzzle invented by a French Mathematician Edouard Lucas in 1983. Initially the game has few discs arranged in the increasing order of size in one of the tower like shown above. The number of discs can vary, but there are only three towers. The goal is to transfer the discs from one tower another tower. However you can move only one disk at a time and you can never place a bigger disc over a smaller disk. It is also understood that you can only take the top most disc from any given tower.While this site doesn't require any general knowledge (unlike who wants to be a millionaire or other trivia games) it does require an astute mind and logical thinking.

Solution
Before trying to understand the general algorithm used to solve Tower of Hanoi, it is always better to learn to solve Tower of Honoi with three or four discs. Once you master solving the puzzle with three or four discs, you can solve the same puzzle with more discs with the following algorithm. 1)Move the top N-1 disks from Source to Auxiliary tower,

2)Move the Nth disk from Source to Destination tower, 3)Move the N-1 disks from Auxiliary tower to Destination tower. Transfering the top N-1 disks from Source to Auxiliary tower can again be thought as a fresh problem and can be solve in the same manner. So once you master solving Tower of Hanoi with three disks, you can solve it with any number of disks with the above algorithm.

Tower of Hanoi
The Tower of Hanoi puzzle was invented by the French mathematician Edouard Lucas in 1883. We are given a tower of eight disks (initially four in the applet below), initially stacked in increasing size on one of three pegs. The objective is to transfer the entire tower to one of the other pegs (the rightmost one in the applet below), moving only one disk at a time and never a larger one onto a smaller. The puzzle is well known to students of Computer Science since it appears in virtually any introductory text on data structures or algorithms. Its solution touches on two important topics discussed later on:

recursive functions and stacks recurrence relations

The applet has several controls that allow one to select the number of disks and observe the solution in a Fast or Slow manner. To solve the puzzle drag disks from one peg to another following the rules. You can drop a disk on to a peg when its center is sufficiently close to the center of the peg. The applet expects you to move disks from the leftmost peg to the rightmost peg.

Buy this applet What if applet does not run?

Recursive solution
Let call the three pegs Src (Source), Aux (Auxiliary) and Dst (Destination). To better understand and appreciate the following solution you should try solving the puzzle for small number of disks, say, 2,3, and, perhaps, 4. However one solves the problem, sooner or later the bottom disk will have to be moved from Src to Dst. At this point in time all the remaining disks will have to be stacked in decreasing size order on Aux. After moving the bottom disk from Src to Dst these disks will have to be moved from Aux to Dst. Therefore, for a given number N of disks, the problem appears to be solved if we know how to accomplish the following tasks:

1. Move the top N - 1 disks from Src to Aux (using Dst as an intermediary peg) 2. Move the bottom disk from Src to Dst 3. Move N - 1 disks from Aux to Dst (using Src as an intermediary peg)

Assume there is a function Solve with four arguments - number of disks and three pegs (source, intermediary and destination - in this order). Then the body of the function might look like
Solve(N, Src, Aux, Dst) if N is 0 exit else Solve(N - 1, Src, Dst, Aux) Move from Src to Dst Solve(N - 1, Aux, Src, Dst)

This actually serves as the definition of the function Solve. The function is recursive in that it calls itself repeatedly with decreasing values of N until a terminating condition (in our case N = 0) has been met. To me the sheer simplicity of the solution is breathtaking. For N = 3 it translates into
1. 2. 3. 4. 5. 6. 7. Move Move Move Move Move Move Move from Src to Dst from Src to Aux from Dst to Aux from Src to Dst from Aux to Src from Aux to Dst from Src to Dst

Of course "Move" means moving the topmost disk. For N = 4 we get the following sequence
1. Move 2. Move 3. Move 4. Move 5. Move 6. Move 7. Move 8. Move 9. Move 10. Move 11. Move 12. Move 13. Move 14. Move 15. Move from Src to Aux from Src to Dst from Aux to Dst from Src to Aux from Dst to Src from Dst to Aux from Src to Aux from Src to Dst from Aux to Dst from Aux to Src from Dst to Src from Aux to Dst from Src to Aux from Src to Dst from Aux to Dst

Recurrence relations
Let TN be the minimum number of moves needed to solve the puzzle with N disks. From the previous section T3 = 7 and T4 = 15. One can easily convince oneself that T2 = 3 and T1 = 1. A trained mathematician would also note that T0 = 0. Now let us try to derive a general formula. The recursive solution above involves moving twice (N - 1) disks from one peg to another and making one additional move in between. It then follows that TN TN-1 + 1 + TN-1 = 2TN-1 + 1 The inequality suggests that it might be possible to move N disks with fewer than 2TN-1 + 1 moves. Which is actually not the case. Indeed, when the time comes to move the bottom disk, (N - 1) smaller disks will have been moved from Src to Aux in at least TN-1 moves. Since we are trying to use as few steps as possible, we may assume that that portion of the task took exactly TN-1 moves. It takes just one move to move the biggest disk from Src to Dst. One then needs exactly TN-1 more steps to finish the task. Therefore the minimum number of moves needed to solve the puzzle with N disks equalsTN-1 + 1 + TN-1 = 2TN-1 + 1 moves. In other words, TN = 2TN-1 + 1 Thus we can define the quantity TN as T0 = 0 TN = 2TN-1 + 1 for N > 0 We may compute T1 = 2T0 + 1 = 1, T2 = 2T1 + 1= 3, T3 = 2T2 + 1 = 7 and so on sequentially. The above expression is known as a recurrence relation which, as you might have noticed, is but a recursive function. TN is defined in terms of only one of its preceding values. Other recurrence relations may be more complicated, for example, f(N) = 2f(N - 1) + 3f(N - 2). Recurrence relations appear under various guises in numerous branches of Mathematics and applications. Returning to the definition of TN, define SN = TN + 1. Then S0 = 1 and SN = TN + 1 = (2TN-1 + 1) + 1 = 2TN-1 + 2 = 2(TN-1 + 1) = 2SN-1. Which is to say that SN could be defined as S0 = 1 SN = 2SN-1 for N > 0 The latter is solved easily in the closed (non-recurrent) form SN=2N. Wherefrom TN = 2N - 1 for N 0.

#include<iostream.h> #include<stdio.h> #include<conio.h> class tower { int *t1,*t2,*t3; int x,y,z; public: void disp_tower(); void move_disk(int tx,int ty); void toh(int n,int a,int b,int c); tower(int no); ~tower(); }; tower :: tower(int no) { t1 = new int[no+1]; t2 = new int[no+1]; t3 = new int[no+1]; x = no; y = z = 0; for(int i=0,j=no ; i<no ; i++,j--) { t1[i] = j; t2[i] = t2[i] = 0; } t1[no] = t2[no] = t3[no] = 0; } tower :: ~tower() { delete []t1; delete []t2;

delete []t3; } void tower :: disp_tower() { clrscr(); cout<<" X :: "; for(int i=0;i<x;i++) { cout<<" "<<t1[i]; } cout<<" Y :: "; for(i=0;i<y;i++) { cout<<" "<<t2[i]; } cout<<" Z :: "; for(i=0;i<z;i++) { cout<<" "<<t3[i]; } getch(); } void tower :: toh(int n,int tx,int ty,int tz) //x to y using z { if(n>=1) { toh(n-1,tx,tz,ty); move_disk(tx,ty); //x to y

disp_tower(); toh(n-1,tz,ty,tx); } } void tower :: move_disk(int tx,int ty) { switch(tx) { case 1: { if(ty==2) t2[y++] = t1[--x]; else t3[z++] = t1[--x]; }break; case 2: { if(ty==1) t1[x++] = t2[--y]; else t3[z++] = t2[--y]; }break; case 3: { if(ty==1) t1[x++] = t3[--z]; else t2[y++] = t3[--z]; }break; }//end of switch } //-------------------------------------------------------------------------int main(void) {

clrscr(); cout<<"Enter the no. of disks::"; int no; cin>>no; tower obj(no); obj.disp_tower(); obj.toh(no,1,2,3); getch(); return 0; }

The Tower of Hanoi is one of the truly classic puzzle games, challenging players with its seemingly simple but frustratingly difficult goal. In the Tower of Hanoi puzzle a player attempts to move a large pile of disks, known as the Tower, from the leftmost peg to the rightmost on the puzzle board. The rules of the puzzle state that the player can only move one disk per turn and can never place a larger disk onto a smaller one at any time. Based on these guidelines, players attempt to move their initial Tower disk-by-disk towards the target third peg in a seemingly complex method of movement using any of the three available pegs until it is rebuilt onto the rightmost peg exactly as it was on the initial leftmost peg at the start of the puzzle. The puzzle was invented by the French mathematician Edouard Lucas in 1883 and is often described as a mathematical puzzle, although solving the Tower of Hanoi doesn't require any mathematical equations at all for a human player. In fact, the ChessandPoker.com Tower of Hanoi solution provides two simple algorithms that allow players to optimally solve Tower of Hanoi puzzles with any number of disks when applied to the puzzle!

Optimal Algorithms for Solving Tower of Hanoi Puzzles

Tower of Hanoi Puzzles may consist of any number of disks as long as they total three or more. The most common total of disks is seven, but you may have puzzles with more (or less) disks in play. The proper solution for a Tower of Hanoi puzzle is very similar for all of the various puzzles, but varies slightly based on whether or not the total number of disks in the puzzle is Odd or Even. In this guide we'll focus on solving a seven-disk Tower of Hanoi puzzle and we've provided an example of our puzzle board in the graphic above, complete with colored disks for reference purposes. In our solution algorithms below we'll focus mainly on the top three disks of the Tower. These three disks are moved around quite a bit in an optimal solution, so it will be necessary to become familiar with them. The topmost disk is known as Disk 1. It is colored Red in our graphic and is the smallest of all the disks. The second disk from the top is called Disk 2. It is the second

smallest disk in the puzzle and is colored Orange in our examples. Finally, the third disk down is called Disk 3 and is colored Yellow. The remaining disks of various colors are simply known as Big Disks, and numbering them is not necessary. We'll now take a look at the algorithms used to solve the Tower of Hanoi and how these three focus disks will factor into each solution.

Odd Number of Disks 1. Move Disk 1 to the LEFT 2. Move Disk 2 (only move) 3. Move Disk 1 to the LEFT 4. Move Disk 3 (only move) 5. Move Disk 1 to the LEFT 6. Move Disk 2 (only move) 7. Move Disk 1 to the LEFT 8. Move a Big Disk

Even Number of Disks 1. Move Disk 1 to the RIGHT 2. Move Disk 2 (only move) 3. Move Disk 1 to the RIGHT 4. Move Disk 3 (only move) 5. Move Disk 1 to the RIGHT 6. Move Disk 2 (only move) 7. Move Disk 1 to the RIGHT 8. Move a Big Disk

In the chart to the left you'll find the two optimal move algorithms for any Tower of Hanoi puzzles based on the total number of disks in your starting Tower. The leftmost column shows the move algorithm for puzzles with an odd number of disks, and the rightmost column details the solution for puzzles with an even number of starting disks. In our guide we'll be using the "odd" algorithm since our example puzzle contains seven disks. To solve their puzzle a player will perform the applicable 8-move algorithm to their board repeatedly until all of the disks have been transferred from the leftmost starting peg to the rightmost target peg.

The two algorithms share some notable similarities, particularly that the tiny Disk 1 is repositioned on every other move in an optimal solution. For example, the odd algorithm has it moving one peg to the left on steps 1, 3, 5 and 7. So if Disk 1 currently resides on the right most peg, it would move one peg to the left to the middle peg on its turn. And if it was instead resting on the middle peg it would move one peg to the left onto the leftmost peg. But what if it is already on the leftmost peg? As we can see in our movement graphic above, you may think of the Disk 1 movements across the board as a circular motion. If Disk 1 is on the leftmost peg, moving it left would bring it back around to the right most peg. This completes the circle of movement and would once again allow Disk 1 to move left onto the middle peg and then back onto the leftmost peg again, ready to jump back around to the rightmost peg and start the sequence again. Of course, for puzzles with an Even number of disks the movements would be reversed but would follow the same pattern. Disk 1 would jump from the leftmost peg to the right, landing on the middle peg. From the middle peg it would move right onto the rightmost peg, and then back around to the leftmost peg again to complete the circular sequence. We'll now take a look at the first application of our algorithm to the seven-disk Tower of Hanoi board, which will start us on our way towards the optimal solution for the puzzle. An optimal solution solves the applicable Tower of Hanoi puzzle in the least possible number of

moves. By using our algorithms, the player is assured that their solution will always be optimal since it efficiently ensures that there are no wasted maneuvers of any disks!

How to Solve a Seven-Disk Tower of Hanoi Puzzle

Step One - Move Disk 1 to the Left: The first step in the "odd" puzzle algorithm instructs us to move Disk 1 to the left. As we've just discussed, whenever Disk 1 is on the leftmost peg moving it left entails looping it back around to the rightmost peg to complete the circular left-to-right motion. As you can see in the graphic, Step 1 has been performed and now shows Disk 1 on the target rightmost peg.

Step Two - Move Disk 2: On Step 2 we're informed that we need to move Orange Disk 2, but it doesn't say where to move it. However, a closer examination of the board shows us that, based on the rule that a player may not place a bigger disk onto a smaller one, Disk 2 only has one legal move. We can confidently move Disk 2 to the middle peg to complete the step. In fact, Disk 2 will always only have one legal move.

Step Three - Move Disk 1 to the Left: The third step once again has tiny Disk 1 moving itself to the left, which means that this time it will be jumping onto Disk 2 which just moved there on our previous step. This is a legal move, of course, since Disk 1 is smaller than Disk 2. It's useful to note that Disk 1 will frequently be moving onto Disk 2. In fact, it does so twice in each algorithm on steps 3 and 7.

Step Four - Move Disk 3: Step 4 has us moving Yellow Disk 3 for the first time in the algorithm. As is the case for Disk 2, there will always only be one legal move available for Disk 3 when using our algorithms. Since Disk 3 cannot be placed on the peg containing the smaller Disk 1 as the topmost disk, the only peg Disk 3 can claim residence on is the rightmost peg. Our graphic shows the board after this move has been played.

Step Five - Move Disk 1 to the Left: As you've no doubt now become acquainted with, Step 5 requires Disk 1 to yet again be moved one peg to the left. For those players with an eye for patterns, you may notice that Disk 1 doesn't

seem to like Disk 3. In fact, if you're applying the algorithm correctly you'll actually never be placing Disk 1 onto Disk three. It always moves onto Disk 2 or a Big Disk.

Step Six - Move Disk 2: Step 6 brings about another movement for Disk 2, which once again has only one legal move available to it, this time hopping onto Yellow Disk 3. More patterns? Indeed, it would appear that each step in the algorithm so far has been working to rebuild the Disk 1-2-3 section of the initial tower. The next move will of course complete the construction and bring us closer to the end of the algorithm.

Step Seven - Move Disk 1 to the Left: Disk 1 moves to the left, looping back around to the rightmost peg and preparing for the final move of the first run-through of the algorithm. If we were just solving a three-disk Tower of Hanoi, the puzzle would already be solved at this point! But with more disks to go, we'll need to proceed to the final step of the algorithm before we'll be ready for another application.

Step Eight - Move a Big Disk: Up to this point, we've only been moving the smallest three disks back and forth on top of one another. Now that their mini-tower has been rebuilt by the algorithm, it's time to move a Big Disk. The big disk that has a legal move available to it would in this case be the Green Disk. Step 8 will always feature a completed mini-tower and only one big disk with a legal move. That's it for the first run-through!

Multiple Algorithm Applications

After finishing Step 8, the first application of the algorithm is complete. To continue the solution, the odd algorithm must once again be performed in its entirety. Move Disk 1 to the left, move Disk 2, move Disk 1 to the left again, move Disk 3, move Disk 1 to the left for the third time, move disk 2, move Disk 1 to the left and finally move the next Big Disk (in this case it's the Light-Blue disk). The graphic above shows the board after the second run-through of the algorithm so you'll be able to verify that your technique is correct. Now that you've got the hang of it, continue to apply the algorithm until your Tower of Hanoi puzzle is completely solved. Of course, if your starting tower has an even number of disks you'll need to use the alternate "Even" algorithm to solve the puzzle, which follows the same process but in the opposite direction. Complete each of the eight steps before restarting the algorithm, and eventually you'll have a completely solved Tower of Hanoi!

ChessandPoker.com Browsing Options

Thank you for reading this featured game article! Please select one of the links below to continue navigating theChess and Poker Dot Com website. Let us know if we can be of any further help. Good luck and happy gaming!