# Program for Tower of Hanoi

• Difficulty Level : Medium
• Last Updated : 08 Jul, 2021

Tower of Hanoi is a mathematical puzzle where we have three rods and n disks. The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules:

1. Only one disk can be moved at a time.
2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
3. No disk may be placed on top of a smaller disk.

Approach :

Attention reader! All those who say programming isn't for kids, just haven't met the right mentors yet. Join the  Demo Class for First Step to Coding Coursespecifically designed for students of class 8 to 12.

The students will get to learn more about the world of programming in these free classes which will definitely help them in making a wise career choice in the future.

```Take an example for 2 disks :
Let rod 1 = 'A', rod 2 = 'B', rod 3 = 'C'.

Step 1 : Shift first disk from 'A' to 'B'.
Step 2 : Shift second disk from 'A' to 'C'.
Step 3 : Shift first disk from 'B' to 'C'.

The pattern here is :
Shift 'n-1' disks from 'A' to 'B'.
Shift last disk from 'A' to 'C'.
Shift 'n-1' disks from 'B' to 'C'.

Image illustration for 3 disks :``` Examples:

```Input : 2
Output : Disk 1 moved from A to B
Disk 2 moved from A to C
Disk 1 moved from B to C

Input : 3
Output : Disk 1 moved from A to C
Disk 2 moved from A to B
Disk 1 moved from C to B
Disk 3 moved from A to C
Disk 1 moved from B to A
Disk 2 moved from B to C
Disk 1 moved from A to C```

## C++

 `// C++ recursive function to``// solve tower of hanoi puzzle``#include ``using` `namespace` `std;` `void` `towerOfHanoi(``int` `n, ``char` `from_rod,``                    ``char` `to_rod, ``char` `aux_rod)``{``    ``if` `(n == 1)``    ``{``        ``cout << ``"Move disk 1 from rod "` `<< from_rod <<``                            ``" to rod "` `<< to_rod<

## Java

 `// JAVA recursive function to``// solve tower of hanoi puzzle``import` `java.util.*;``import` `java.io.*;``import` `java.math.*;``class` `GFG``{``static` `void` `towerOfHanoi(``int` `n, ``char` `from_rod,``                    ``char` `to_rod, ``char` `aux_rod)``{``    ``if` `(n == ``1``)``    ``{``        ``System.out.println(``"Move disk 1 from rod "``+``                           ``from_rod+``" to rod "``+to_rod);``        ``return``;``    ``}``    ``towerOfHanoi(n - ``1``, from_rod, aux_rod, to_rod);``    ``System.out.println(``"Move disk "``+ n + ``" from rod "` `+``                       ``from_rod +``" to rod "` `+ to_rod );``    ``towerOfHanoi(n - ``1``, aux_rod, to_rod, from_rod);``}` `// Driver code``public` `static` `void`  `main(String args[])``{``    ``int` `n = ``4``; ``// Number of disks``    ``towerOfHanoi(n, ``'A'``, ``'C'``, ``'B'``); ``// A, B and C are names of rods``}``}` `// This code is contributed by jyoti369`

## Python3

 `# Recursive Python function to solve tower of hanoi` `def` `TowerOfHanoi(n , from_rod, to_rod, aux_rod):``    ``if` `n ``=``=` `1``:``        ``print``(``"Move disk 1 from rod"``,from_rod,``"to rod"``,to_rod)``        ``return``    ``TowerOfHanoi(n``-``1``, from_rod, aux_rod, to_rod)``    ``print``(``"Move disk"``,n,``"from rod"``,from_rod,``"to rod"``,to_rod)``    ``TowerOfHanoi(n``-``1``, aux_rod, to_rod, from_rod)``        ` `# Driver code``n ``=` `4``TowerOfHanoi(n, ``'A'``, ``'C'``, ``'B'``)``# A, C, B are the name of rods` `# Contributed By Harshit Agrawal`

## C#

 `// C# recursive program to solve tower of hanoi puzzle``using` `System;``class` `GFG``{``    ``static` `void` `towerOfHanoi(``int` `n, ``char` `from_rod, ``char` `to_rod, ``char` `aux_rod)``    ``{``        ``if` `(n == 1)``        ``{``            ``Console.WriteLine(``"Move disk 1 from rod "` `+ ``                              ``from_rod + ``" to rod "` `+ to_rod);``            ``return``;``        ``}``        ``towerOfHanoi(n-1, from_rod, aux_rod, to_rod);``        ``Console.WriteLine(``"Move disk "` `+ n + ``" from rod "` `+ ``                          ``from_rod + ``" to rod "` `+ to_rod);``        ``towerOfHanoi(n-1, aux_rod, to_rod, from_rod);``    ``}``    ` `    ``//  Driver method``    ``public` `static` `void` `Main(String []args)``    ``{``        ``int` `n = 4; ``// Number of disks``        ``towerOfHanoi(n, ``'A'``, ``'C'``, ``'B'``);  ``// A, B and C are names of rods``    ``}``}` `//This code is contributed by shivanisinghss2110`

## PHP

 ` 0){``        ``TOH(``\$n``-1, ``\$A``, ``\$C``, ``\$B``);``        ``echo` `"Move disk from rod \$A to rod \$C \n"``;``        ``move(``\$A``, ``\$C``);``        ``dispPoles();``        ``TOH(``\$n``-1, ``\$B``, ``\$A``, ``\$C``);``    ``}``    ``else` `{``        ``return``;``    ``}``}` `function` `initPoles(``\$n``){``    ``global` `\$poles``;` `    ``for` `(``\$i``=``\$n``; ``\$i``>=1; --``\$i``){``        ``\$poles``[] = ``\$i``;``    ``}``}`  `function` `move(``\$source``, ``\$destination``){``    ``global` `\$poles``;``    ` `    ``// get source and destination pointers``    ``if` `(``\$source``==``"A"``) ``\$ptr1``=0;``    ``elseif` `(``\$source``==``"B"``) ``\$ptr1` `= 1;``    ``else` `\$ptr1` `= 2;``    ` `    ``if` `(``\$destination``==``"A"``) ``\$ptr2` `= 0;``    ``elseif` `(``\$destination``==``"B"``) ``\$ptr2` `= 1;``    ``else` `\$ptr2` `= 2;``    ` `    ``\$top` `= ``array_pop``(``\$poles``[``\$ptr1``]);``    ``array_push``(``\$poles``[``\$ptr2``], ``\$top``);``}` `function` `dispPoles(){ ``    ``global` `\$poles``;``    ``echo` `"A: ["``.implode(``", "``, ``\$poles``).``"] "``;``    ``echo` `"B: ["``.implode(``", "``, ``\$poles``).``"] "``;``    ``echo` `"C: ["``.implode(``", "``, ``\$poles``).``"] "``;``    ``echo` `"\n\n"``;``}` `\$numdisks` `= 4;``initPoles(``\$numdisks``);``echo` `"Tower of Hanoi Solution for \$numdisks disks: \n\n"``;``dispPoles();``TOH(``\$numdisks``);` `// This code is contributed by ShreyakChakraborty``?>`

## Javascript

 ``
Output
```Move disk 1 from rod A to rod B
Move disk 2 from rod A to rod C
Move disk 1 from rod B to rod C
Move disk 3 from rod A to rod B
Move disk 1 from rod C to rod A
Move disk 2 from rod C to rod B
Move disk 1 from rod A to rod B
Move disk 4 from rod A to rod C
Move disk 1 from rod B to rod C
Move disk 2 from rod B to rod A
Move disk 1 from rod C to rod A
Move disk 3 from rod B to rod C
Move disk 1 from rod A to rod B
Move disk 2 from rod A to rod C
Move disk 1 from rod B to rod C```
```Output:

Tower of Hanoi Solution for 4 disks:

A: [4, 3, 2, 1] B: [] C: []

Move disk from rod A to rod B
A: [4, 3, 2] B:  C: []

Move disk from rod A to rod C
A: [4, 3] B:  C: 

Move disk from rod B to rod C
A: [4, 3] B: [] C: [2, 1]

Move disk from rod A to rod B
A:  B:  C: [2, 1]

Move disk from rod C to rod A
A: [4, 1] B:  C: 

Move disk from rod C to rod B
A: [4, 1] B: [3, 2] C: []

Move disk from rod A to rod B
A:  B: [3, 2, 1] C: []

Move disk from rod A to rod C
A: [] B: [3, 2, 1] C: 

Move disk from rod B to rod C
A: [] B: [3, 2] C: [4, 1]

Move disk from rod B to rod A
A:  B:  C: [4, 1]

Move disk from rod C to rod A
A: [2, 1] B:  C: 

Move disk from rod B to rod C
A: [2, 1] B: [] C: [4, 3]

Move disk from rod A to rod B
A:  B:  C: [4, 3]

Move disk from rod A to rod C
A: [] B:  C: [4, 3, 2]

Move disk from rod B to rod C
A: [] B: [] C: [4, 3, 2, 1]```

Video Explanation

Related Articles

References:
http://en.wikipedia.org/wiki/Tower_of_Hanoi
This article is contributed by Rohit Thapliyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.