Given a positive integer N representing the number of disks in the Tower of Hanoi, the task is to solve the Tower of Hanoi puzzle using Binary representations.
Examples:
Input: N = 3
Output:
Move the 1 disk to next circular right rod
Move the 2 disk to next circular right rod
Move the 1 disk to next circular right rod
Move the 3 disk to next circular right rod
Move the 1 disk to next circular right rod
Move the 2 disk to next circular right rod
Move the 1 disk to next circular right rodInput: N = 4
Output:
Move the 1 disk to next circular right rod
Move the 2 disk to next circular right rod
Move the 1 disk to next circular right rod
Move the 3 disk to next circular right rod
Move the 1 disk to next circular right rod
Move the 2 disk to next circular right rod
Move the 1 disk to next circular right rod
Move the 4 disk to next circular right rod
Move the 1 disk to next circular right rod
Move the 2 disk to next circular right rod
Move the 1 disk to next circular right rod
Move the 3 disk to next circular right rod
Move the 1 disk to next circular right rod
Move the 2 disk to next circular right rod
Move the 1 disk to next circular right rod
Approach: The given problem can be solved based on the following observations:
- It can be observed that to move the Nth disk, (N – 1)thdisk needs to be moved. Therefore, to move (N – 1)th disk, (N – 2)thdisk needs to be moved. This process goes on recursively.
- The above procedure is similar to setting the rightmost unset bit as it requires to set all the bits to right of it first.
- Therefore, the idea is to print all the intermediate steps, every time setting the right most bit by incrementing the current number by 1.
Follow the steps below to solve the problem:
- Initialize an array, say counter[], of size N, to store the current state of the problem.
- Iterate over the range [0, 2N – 1], set the rightmost unset bit, and unset all the bits to the right of it.
- In every iteration of the above step, print the position of the rightmost unset bit as the number of the disk which is to be moved.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to increment binary counter int increment( int * counter, int n)
{ int i = 0;
while ( true ) {
// Stores the Bitwise XOR of
// the i-th bit of N and 1
int a = counter[i] ^ 1;
// Stores the Bitwise AND of
// the i-th bit of N and 1
int b = counter[i] & 1;
// Swaps the i-th bit of N
counter[i] = a;
// If b is equal to zero
if (b == 0)
break ;
// Increment i by 1
i = i + 1;
}
// Return i
return i;
} // Function to print order of movement // of disks across three rods to place // all disks on the third rod from the // first rod void TowerOfHanoi( int N)
{ // Stores the binary representation
// of a state
int counter[N] = { 0 };
// Traverse the range [0, 2^N - 1]
for ( int step = 1;
step <= pow (2, N) - 1; step++) {
// Stores the position of the
// rightmost unset bit
int x = increment(counter, N) + 1;
// Print the Xth bit
cout << "Move disk " << x
<< " to next circular"
<< " right rod \n" ;
}
} // Driver Code int main()
{ int N = 3;
TowerOfHanoi(N);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG{
// Function to increment binary counter static int increment( int [] counter, int n)
{ int i = 0 ;
while ( true )
{
// Stores the Bitwise XOR of
// the i-th bit of N and 1
int a = counter[i] ^ 1 ;
// Stores the Bitwise AND of
// the i-th bit of N and 1
int b = counter[i] & 1 ;
// Swaps the i-th bit of N
counter[i] = a;
// If b is equal to zero
if (b == 0 )
break ;
// Increment i by 1
i = i + 1 ;
}
// Return i
return i;
} // Function to print order of movement // of disks across three rods to place // all disks on the third rod from the // first rod static void TowerOfHanoi( int N)
{ // Stores the binary representation
// of a state
int [] counter= new int [N];
// Traverse the range [0, 2^N - 1]
for ( int step = 1 ;
step <= Math.pow( 2 , N) - 1 ;
step++)
{
// Stores the position of the
// rightmost unset bit
int x = increment(counter, N) + 1 ;
// Print the Xth bit
System.out.println( "Move disk " + x +
" to next circular" +
" right rod" );
}
} // Driver code public static void main(String[] args)
{ // Given inputs
int N = 3 ;
TowerOfHanoi(N);
} } // This code is contributed by offbeat |
# Python program for the above approach import math
# Function to increment binary counter def increment(counter, n):
i = 0
while ( True ):
# Stores the Bitwise XOR of
# the i-th bit of N and 1
a = counter[i] ^ 1
# Stores the Bitwise AND of
# the i-th bit of N and 1
b = counter[i] & 1
# Swaps the i-th bit of N
counter[i] = a
# If b is equal to zero
if (b = = 0 ):
break
# Increment i by 1
i = i + 1
return i
# Function to print order of movement # of disks across three rods to place # all disks on the third rod from the # first rod def TowerOfHanoi(N):
# Stores the binary representation
# of a state
counter = [ 0 for i in range (N)]
# Traverse the range [0, 2^N - 1]
for step in range ( 1 , int (math. pow ( 2 ,N))):
# Stores the position of the
# rightmost unset bit
x = increment(counter, N) + 1
#Print the Xth bit
print ( "Move disk " ,x, " to next circular" , " right rod" )
# Driver code N = 3
TowerOfHanoi(N) # This code is contributed by rag2127 |
// C# program for the above approach using System;
class GFG
{ // Function to increment binary counter
static int increment( int [] counter, int n)
{
int i = 0;
while ( true )
{
// Stores the Bitwise XOR of
// the i-th bit of N and 1
int a = counter[i] ^ 1;
// Stores the Bitwise AND of
// the i-th bit of N and 1
int b = counter[i] & 1;
// Swaps the i-th bit of N
counter[i] = a;
// If b is equal to zero
if (b == 0)
break ;
// Increment i by 1
i = i + 1;
}
// Return i
return i;
}
// Function to print order of movement
// of disks across three rods to place
// all disks on the third rod from the
// first rod
static void TowerOfHanoi( int N)
{
// Stores the binary representation
// of a state
int [] counter = new int [N];
// Traverse the range [0, 2^N - 1]
for ( int step = 1;
step <= ( int )(Math.Pow(2, N) - 1); step++)
{
// Stores the position of the
// rightmost unset bit
int x = increment(counter, N) + 1;
// Print the Xth bit
Console.WriteLine( "Move disk " + x
+ " to next circular"
+ " right rod " );
}
}
// Driver Code
public static void Main()
{
int N = 3;
TowerOfHanoi(N);
}
} // This code is contributed by ukasp. |
<script> // Javascript implementation for the above approach // Function to increment binary counter function increment(counter, n)
{ let i = 0;
while ( true )
{
// Stores the Bitwise XOR of
// the i-th bit of N and 1
let a = counter[i] ^ 1;
// Stores the Bitwise AND of
// the i-th bit of N and 1
let b = counter[i] & 1;
// Swaps the i-th bit of N
counter[i] = a;
// If b is equal to zero
if (b == 0)
break ;
// Increment i by 1
i = i + 1;
}
// Return i
return i;
} // Function to print order of movement // of disks across three rods to place // all disks on the third rod from the // first rod function TowerOfHanoi(N)
{ // Stores the binary representation
// of a state
let counter= Array.from({length: N}, (_, i) => 0);
// Traverse the range [0, 2^N - 1]
for (let step = 1;
step <= Math.pow(2, N) - 1;
step++)
{
// Stores the position of the
// rightmost unset bit
let x = increment(counter, N) + 1;
// Print the Xth bit
document.write( "Move disk " + x +
" to next circular" +
" right rod" + "<br/>" );
}
} // Driver Code
// Given inputs
let N = 3;
TowerOfHanoi(N);
// This code is contributed by sanjoy_62. </script> |
Move disk 1 to next circular right rod Move disk 2 to next circular right rod Move disk 1 to next circular right rod Move disk 3 to next circular right rod Move disk 1 to next circular right rod Move disk 2 to next circular right rod Move disk 1 to next circular right rod
Time Complexity: O(N * 2N)
Auxiliary Space: O(N)
Efficient Approach: The above approach can be optimized based on the observations that for M over the range [1, 2N – 1], source rod is equal to (m & (m – 1)) % 3 and the destination rod is equal to (m | (m – 1) + 1) % 3. Therefore, the idea is to iterate over the range [1, 2N – 1] and print the value of (i & (i – 1))%3 as source rod and (i | (i – 1) + 1)%3 as destination rod.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to print order of movement // of N disks across three rods to place // all disks on the third rod from the // first-rod using binary representation void TowerOfHanoi( int N)
{ // Iterate over the range [0, 2^N - 1]
for ( int x = 1;
x <= pow (2, N) - 1; x++) {
// Print the movement
// of the current rod
cout << "Move from Rod "
<< ((x & x - 1) % 3 + 1)
<< " to Rod "
<< (((x | x - 1) + 1) % 3 + 1)
<< endl;
}
} // Driver Code int main()
{ int N = 3;
TowerOfHanoi(N);
return 0;
} |
// Java program for the above approach class GFG{
// Function to print order of movement // of N disks across three rods to place // all disks on the third rod from the // first-rod using binary representation static void TowerOfHanoi( int N)
{ // Iterate over the range [0, 2^N - 1]
for ( int x = 1 ;
x <= Math.pow( 2 , N) - 1 ; x++)
{
// Print the movement
// of the current rod
System.out.print( "Move from Rod " +
((x & x - 1 ) % 3 + 1 ) + " to Rod " +
(((x | x - 1 ) + 1 ) % 3 + 1 ) + "\n" );
}
} // Driver Code public static void main (String[] args)
{ int N = 3 ;
TowerOfHanoi(N);
} } // This code is contributed by jana_sayantan |
# Python program for the above approach import math
# Function to print order of movement # of N disks across three rods to place # all disks on the third rod from the # first-rod using binary representation def TowerOfHanoi(N):
# Iterate over the range [0, 2^N - 1]
for x in range ( 1 , int (math. pow ( 2 , N)) ):
# Print the movement
# of the current rod
print ( "Move from Rod " ,
((x & x - 1 ) % 3 + 1 ) , " to Rod " ,
(((x | x - 1 ) + 1 ) % 3 + 1 ) )
# Driver Code N = 3
TowerOfHanoi(N) # This code is contributed by avanitrachhadiya2155 |
// C# program for the above approach using System;
class GFG{
// Function to print order of movement // of N disks across three rods to place // all disks on the third rod from the // first-rod using binary representation static void TowerOfHanoi( int N)
{ // Iterate over the range [0, 2^N - 1]
for ( int x = 1;
x <= Math.Pow(2, N) - 1; x++)
{
// Print the movement
// of the current rod
Console.Write( "Move from Rod " +
((x & x - 1) % 3 + 1) + " to Rod " +
(((x | x - 1) + 1) % 3 + 1) + "\n" );
}
} // Driver Code static void Main()
{ int N = 3;
TowerOfHanoi(N);
} } // This code is contributed by SoumikMondal |
<script> // Javascript program for the above approach // Function to print order of movement // of N disks across three rods to place // all disks on the third rod from the // first-rod using binary representation function TowerOfHanoi(N)
{ // Iterate over the range [0, 2^N - 1]
for (let x = 1;
x <= Math.pow(2, N) - 1; x++) {
// Print the movement
// of the current rod
document.write( "Move from Rod "
+ ((x & x - 1) % 3 + 1)
+ " to Rod "
+ (((x | x - 1) + 1) % 3 + 1)
+ "<br>" );
}
} // Driver Code let N = 3;
TowerOfHanoi(N);
</script> |
Move from Rod 1 to Rod 3 Move from Rod 1 to Rod 2 Move from Rod 3 to Rod 2 Move from Rod 1 to Rod 3 Move from Rod 2 to Rod 1 Move from Rod 2 to Rod 3 Move from Rod 1 to Rod 3
Time Complexity: O(2N)
Auxiliary Space: O(1)