Tower of Hanoi - Problem

The Tower of Hanoi is a classic puzzle consisting of three rods and a number of disks of different sizes which can slide onto any rod. The puzzle starts with all disks stacked on one rod in ascending order of size (smallest on top).

The objective is to move the entire stack to another rod, following these 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
No disk may be placed on top of a smaller disk

Given n disks, print each move in the format "Move disk from [source] to [destination]" and return the total number of moves required.

Input & Output

Example 1 — Basic Case (n=3)

$ Input: n = 3

› Output: Move disk 1 from A to C Move disk 2 from A to B Move disk 1 from C to B Move disk 3 from A to C Move disk 1 from B to A Move disk 2 from B to C Move disk 1 from A to C 7

💡 Note: To move 3 disks from A to C: first move disks 1,2 to B (3 moves), then disk 3 to C (1 move), then disks 1,2 from B to C (3 moves). Total: 7 moves.

Example 2 — Minimum Case (n=1)

$ Input: n = 1

› Output: Move disk 1 from A to C 1

💡 Note: Only one disk to move directly from source A to destination C. Total: 1 move.

Example 3 — Small Case (n=2)

$ Input: n = 2

› Output: Move disk 1 from A to B Move disk 2 from A to C Move disk 1 from B to C 3

💡 Note: Move disk 1 to B, disk 2 to C, then disk 1 on top of disk 2. Total: 3 moves.

Constraints

1 ≤ n ≤ 20
Output each move on a separate line
Return total number of moves as the last line

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 18 f Facebook 8

The Tower of Hanoi is elegantly solved using recursion. The key insight is that moving n disks breaks down into three steps: move n-1 disks out of the way, move the largest disk, then move n-1 disks to their final position. The recursive approach provides the optimal solution with exactly 2^n - 1 moves. Time: O(2^n), Space: O(n).

Common Approaches

✓ Iterative Simulation

⏱️ Time: O(2^n) Space: O(n)

Use three stacks to represent the rods and simulate the Tower of Hanoi moves iteratively. This approach uses a mathematical property: for n disks, alternate between moving the smallest disk and making the only legal move not involving the smallest disk.

Recursive Solution

⏱️ Time: O(2^n) Space: O(n)

The elegant recursive solution that breaks down the problem: to move n disks from source to destination, first move n-1 disks to auxiliary rod, then move the largest disk to destination, finally move n-1 disks from auxiliary to destination.

Iterative Simulation — Algorithm Steps

Initialize three stacks representing the three rods
Place all disks on the source rod
Alternate between moving smallest disk and making other legal moves
Continue until all disks are on destination rod

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create three stacks, place all disks on rod A

Alternate Moves

Move smallest disk, then make other legal move

Complete

All disks moved to destination rod

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int* data;
    int top;
    int capacity;
} Stack;

Stack* createStack(int capacity) {
    Stack* stack = (Stack*)malloc(sizeof(Stack));
    stack->data = (int*)malloc(capacity * sizeof(int));
    stack->top = -1;
    stack->capacity = capacity;
    return stack;
}

void push(Stack* stack, int item) {
    stack->data[++stack->top] = item;
}

int pop(Stack* stack) {
    return stack->data[stack->top--];
}

int peek(Stack* stack) {
    return stack->data[stack->top];
}

int isEmpty(Stack* stack) {
    return stack->top == -1;
}

char moves[1000][100];
int moveCount = 0;

void makeMove(Stack* rods[], int from, int to, char rodNames[][2]) {
    int disk = pop(rods[from]);
    push(rods[to], disk);
    sprintf(moves[moveCount++], "Move disk %d from %s to %s", disk, rodNames[from], rodNames[to]);
}

int findSmallestDisk(Stack* rods[]) {
    int minDisk = INT_MAX;
    int minRod = -1;
    for (int i = 0; i < 3; i++) {
        if (!isEmpty(rods[i]) && peek(rods[i]) < minDisk) {
            minDisk = peek(rods[i]);
            minRod = i;
        }
    }
    return minRod;
}

int solution(int n) {
    moveCount = 0;
    Stack* rods[3];
    char rodNames[3][2] = {"A", "B", "C"};
    
    for (int i = 0; i < 3; i++) {
        rods[i] = createStack(n);
    }
    
    // Place all disks on rod A
    for (int i = n; i >= 1; i--) {
        push(rods[0], i);
    }
    
    int totalMoves = (1 << n) - 1;
    
    for (int mc = 0; mc < totalMoves; mc++) {
        if (mc % 2 == 0) {
            int smallestRod = findSmallestDisk(rods);
            int nextRod = n % 2 == 1 ? (smallestRod + 1) % 3 : (smallestRod + 2) % 3;
            makeMove(rods, smallestRod, nextRod, rodNames);
        } else {
            int smallestRod = findSmallestDisk(rods);
            int otherRods[2];
            int idx = 0;
            for (int i = 0; i < 3; i++) {
                if (i != smallestRod) otherRods[idx++] = i;
            }
            
            if (isEmpty(rods[otherRods[0]])) {
                makeMove(rods, otherRods[1], otherRods[0], rodNames);
            } else if (isEmpty(rods[otherRods[1]])) {
                makeMove(rods, otherRods[0], otherRods[1], rodNames);
            } else if (peek(rods[otherRods[0]]) < peek(rods[otherRods[1]])) {
                makeMove(rods, otherRods[0], otherRods[1], rodNames);
            } else {
                makeMove(rods, otherRods[1], otherRods[0], rodNames);
            }
        }
    }
    
    for (int i = 0; i < moveCount; i++) {
        printf("%s\n", moves[i]);
    }
    
    // Free memory
    for (int i = 0; i < 3; i++) {
        free(rods[i]->data);
        free(rods[i]);
    }
    
    return moveCount;
}

int main() {
    int n;
    scanf("%d", &n);
    int result = solution(n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Need to make 2^n - 1 moves to solve the puzzle optimally

⚠ Quadratic Growth

Space Complexity

O(n)

Three stacks to store the disks, each can hold up to n disks

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Tower of Hanoi - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler