Tower of Hanoi Problem in DSA C - Build from Scratch

Tower of Hanoi Problem

📖 Scenario: Imagine you have three rods and a number of disks of different sizes which can slide onto any rod. The puzzle starts with the disks neatly stacked in ascending order of size on one rod, the smallest at the top, making a conical shape.The objective is to move the entire stack to another rod, obeying the following simple rules:Only one disk can be moved at a time.Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack or on an empty rod.No disk may be placed on top of a smaller disk.

🎯 Goal: You will write a C program that uses a recursive function to solve the Tower of Hanoi problem for 3 disks. The program will print each move showing which disk moves from which rod to which rod.

📋 What You'll Learn

Create an integer variable n to represent the number of disks (3).

Create a recursive function void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) that prints the moves.

Call the towerOfHanoi function with the correct arguments to solve the puzzle.

Print each move in the format: Move disk X from rod Y to rod Z.

💡 Why This Matters

🌍 Real World

The Tower of Hanoi problem helps understand recursion, a key concept in programming and problem solving.

💼 Career

Recursion is used in many software engineering tasks like parsing, searching, and algorithm design.

1

Create the number of disks variable

Create an integer variable called n and set it to 3 to represent the number of disks.

DSA C

# Your code here

Hint

Use int n = 3; inside the main function.

2

Write the towerOfHanoi recursive function

Write a recursive function called towerOfHanoi with parameters int n, char from_rod, char to_rod, and char aux_rod. The function should print the moves to solve the puzzle using the format Move disk %d from rod %c to rod %c\n. Implement the base case and recursive calls correctly.

DSA C

#include 

// Write the towerOfHanoi function here

int main() {
    int n = 3;
    return 0;
}

Hint

Use recursion: move n-1 disks to auxiliary rod, move the nth disk, then move n-1 disks to target rod.

3

Call the towerOfHanoi function in main

Inside the main function, call towerOfHanoi with arguments n, 'A', 'C', and 'B' to solve the puzzle from rod A to rod C using rod B as auxiliary.

DSA C

#include 

void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) {
    if (n == 1) {
        printf("Move disk 1 from rod %c to rod %c\n", from_rod, to_rod);
        return;
    }
    towerOfHanoi(n - 1, from_rod, aux_rod, to_rod);
    printf("Move disk %d from rod %c to rod %c\n", n, from_rod, to_rod);
    towerOfHanoi(n - 1, aux_rod, to_rod, from_rod);
}

int main() {
    int n = 3;
    // Call towerOfHanoi here
    // Your code here
}

Hint

Call towerOfHanoi with n, 'A', 'C', 'B'

4

Print the moves to solve Tower of Hanoi

Run the program to print the sequence of moves to solve the Tower of Hanoi problem for 3 disks. The output should show each move in the format Move disk X from rod Y to rod Z.

DSA C

#include 

void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) {
    if (n == 1) {
        printf("Move disk 1 from rod %c to rod %c\n", from_rod, to_rod);
        return;
    }
    towerOfHanoi(n - 1, from_rod, aux_rod, to_rod);
    printf("Move disk %d from rod %c to rod %c\n", n, from_rod, to_rod);
    towerOfHanoi(n - 1, aux_rod, to_rod, from_rod);
}

int main() {
    int n = 3;
    towerOfHanoi(n, 'A', 'C', 'B');
    // Print output
    // Your code here
}

Hint

Run the program and check the printed moves.

Practice

1. What is the minimum number of moves required to solve the Tower of Hanoi problem with 3 disks?

easy

A. 6

B. 5

C. 9

D. 7

Solution

1. Step 1: Understand the formula for minimum moves

   The minimum moves required for n disks is 2^n - 1.

2. Step 2: Calculate for 3 disks

   For 3 disks, minimum moves = 2^3 - 1 = 8 - 1 = 7.

3. Final Answer:

   7 -> Option D

4. Quick Check:

   2^3 - 1 = 7 [OK]

Hint: Use formula 2^n - 1 for minimum moves [OK]

Common Mistakes:

• Using n instead of 2^n - 1
• Calculating 2*n - 1 instead of 2^n - 1
• Confusing number of disks with moves

2. Which of the following is the correct recursive function signature in C for solving Tower of Hanoi?

easy

A. void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod);

B. int towerOfHanoi(int n, char from_rod, char to_rod);

C. void towerOfHanoi(int n, int from_rod, int to_rod);

D. void towerOfHanoi(int n, char from_rod, char to_rod);

Solution

1. Step 1: Identify parameters needed for Tower of Hanoi

   We need number of disks and names of three rods: source, destination, auxiliary.

2. Step 2: Check function signature matching these parameters

   void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod); has int n and three char rods, matching the problem requirements.

3. Final Answer:

   void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod); -> Option A

4. Quick Check:

   Function needs 3 rods and disk count [OK]

Hint: Tower of Hanoi needs 3 rods as parameters [OK]

Common Mistakes:

• Missing auxiliary rod parameter
• Using int instead of char for rods
• Returning int instead of void

3. What will be the output of the following C code snippet for Tower of Hanoi with 2 disks?

void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) {
  if (n == 1) {
    printf("Move disk 1 from rod %c to rod %c\n", from_rod, to_rod);
    return;
  }
  towerOfHanoi(n-1, from_rod, aux_rod, to_rod);
  printf("Move disk %d from rod %c to rod %c\n", n, from_rod, to_rod);
  towerOfHanoi(n-1, aux_rod, to_rod, from_rod);
}

int main() {
  towerOfHanoi(2, 'A', 'C', 'B');
  return 0;
}

medium

A. Move disk 2 from rod A to rod C
Move disk 1 from rod A to rod B
Move disk 2 from rod B to rod C

B. Move disk 1 from rod A to rod C
Move disk 2 from rod A to rod B
Move disk 1 from rod C to rod B

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

D. Move disk 1 from rod B to rod C
Move disk 2 from rod A to rod C
Move disk 1 from rod A to rod B

Solution

1. Step 1: Trace recursive calls for n=2

   First move disk 1 from A to B, then disk 2 from A to C, then disk 1 from B to C.

2. Step 2: Match output with options

   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 matches the exact sequence of moves printed by the code.

3. Final Answer:

   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 -> Option C

4. Quick Check:

   Recursive moves for 2 disks = 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 [OK]

Hint: For 2 disks, move smaller disk to aux first [OK]

Common Mistakes:

• Swapping auxiliary and destination rods
• Printing moves in wrong order
• Confusing disk numbers

4. Identify the error in the following Tower of Hanoi C function and select the correct fix:

void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) {
  if (n == 0) {
    return;
  }
  towerOfHanoi(n-1, from_rod, aux_rod, to_rod);
  printf("Move disk %d from rod %c to rod %c\n", n, from_rod, to_rod);
  towerOfHanoi(n-1, aux_rod, to_rod, from_rod);
}

medium

A. Change base case condition to if (n == 1) instead of if (n == 0)

B. Add else before recursive calls

C. Change printf to print n-1 instead of n

D. Swap aux_rod and to_rod in recursive calls

Solution

1. Step 1: Analyze base case condition

   Base case should stop recursion when n == 1, not 0, to print the last move.

2. Step 2: Understand effect of current base case

   With n == 0, no moves are printed for the smallest disk, causing no output.

3. Final Answer:

   Change base case condition to if (n == 1) instead of if (n == 0) -> Option A

4. Quick Check:

   Base case must be n == 1 to print moves [OK]

Hint: Base case must be n == 1 to print last move [OK]

Common Mistakes:

• Using n == 0 as base case
• Changing print statement unnecessarily
• Swapping rods incorrectly

5. You want to solve Tower of Hanoi for 4 disks but print only the moves where disk 1 is moved. Which modification to the recursive function is correct?

void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod) {
  if (n == 1) {
    printf("Move disk 1 from rod %c to rod %c\n", from_rod, to_rod);
    return;
  }
  towerOfHanoi(n-1, from_rod, aux_rod, to_rod);
  printf("Move disk %d from rod %c to rod %c\n", n, from_rod, to_rod);
  towerOfHanoi(n-1, aux_rod, to_rod, from_rod);
}

hard

A. Remove all recursive calls except for n == 1 case

B. Add condition to print only if n == 1 inside the function

C. Print all moves but filter disk 1 moves outside the function

D. Change base case to n == 0 and print only disk 1 moves

Solution

1. Step 1: Understand requirement to print only disk 1 moves

   We must print moves only when disk number is 1 inside the recursive function.

2. Step 2: Modify print statements accordingly

   Keep recursive calls intact but print only when n == 1, skipping other prints.

3. Final Answer:

   Add condition to print only if n == 1 inside the function -> Option B

4. Quick Check:

   Print condition inside recursion for disk 1 only [OK]

Hint: Print moves only when disk number is 1 inside recursion [OK]

Common Mistakes:

• Removing recursive calls breaks solution
• Filtering outside loses recursion context
• Changing base case incorrectly