Tower of Hanoi (without recursion)

Here is the most recent version of this Tower of Hanoi program.

This self-answer includes a description of the changes made to the original program.

/* Tower.c

   Tower of Hanoi -- mechanical solution

   Place one of the three rods upright at each corner of a triangle.

                                      rod B
                                        /\
                                       /  \
                                      /    \
                                     /      \
                                    /        \
                                   /          \
                            rod A /------------\ rod C
                           (start)              (finish)

   Alternate between moving the smallest disk and making the only valid move
   which does not involve the smallest disk.

   The smallest disk always moves in the same direction: counter-clockwise if
   there are an odd number of disks in the puzzle; clockwise if there are an
   even number of disks in the puzzle.

   from "The Icosian Game and the Tower of Hanoi" in THE SCIENTIFIC AMERICAN
   BOOK OF MATHEMATICAL PUZZLES & DIVERSIONS by Martin Gardner, (Simon and
   Schuster, 1959), pp. 55 - 62
*/

#include <stdio.h>

#define MAXNUM 10
#define START   0
#define FINISH  2

int isSolved(int arr[], int n)
{
    for (int i = 0; i < n; ++i) {
        if (arr[i] != FINISH) {
            return 0;
        }
    }

    return 1;
}

void swap(int *px, int *py)
{
    int temp = *px;
    *px = *py;
    *py = temp;
}

int isOdd(int x)
{
    return ((x % 2) == 1);
}

int main (void)
{
    printf("\n"
           "Tower of Hanoi puzzle\n"
           "\n");
    int numberOfDisks;
    do {
        printf("number of disks (1 to %d): ", MAXNUM);
        scanf("%d", &numberOfDisks);
    } while ((numberOfDisks < 1) || (numberOfDisks > MAXNUM));

    int rod[numberOfDisks];
    for (int i = 0; i < numberOfDisks; ++i) {
        rod[i] = START;
    }
    int smallestDir = (isOdd(numberOfDisks)) ? -1 : 1;
    int alternateRodTable[3][2] = { {1, 2}, {0, 2}, {0, 1} };

    printf("\n"
           "solution\n"
           "\n");

    int moveCount = 0;
    do {
        ++moveCount;

        int disk, rodFrom, rodTo;
        if (isOdd(moveCount)) {
            // move smallest disk
            disk = 0;
            rodFrom = rod[disk];
            rodTo = rodFrom + smallestDir;
            if (rodTo < START) {
                rodTo = FINISH;
            }
            if (rodTo > FINISH) {
                rodTo = START;
            }
        }
        else {
            // move alternate disk
            // determine which disk is at the top of each rod
            // set default value (empty rod) to greater than the largest disk
            int topDisk[3] = { numberOfDisks, numberOfDisks, numberOfDisks };
            // stack each disk on its respective rod
            // smaller disks overwrite larger disks
            for (int i = numberOfDisks - 1; i > -1; --i) {
                topDisk[rod[i]] = i;
            }
            // select the two rods which do not involve the smallest disk
            rodFrom = alternateRodTable[rod[0]][0];
            rodTo = alternateRodTable[rod[0]][1];
            // check which of the two possible "From => To" moves is valid
            if (topDisk[rodFrom] > topDisk[rodTo]) {
                swap(&rodFrom, &rodTo);
            }
            disk = topDisk[rodFrom];
        }
        rod[disk] = rodTo;

        printf("%4d: disk %2d rod %c => %c\n", moveCount, disk + 1, rodFrom + 'A', rodTo + 'A');
    } while (! isSolved(rod, numberOfDisks));

    return 0;
}

The following changes, suggested by Caridorc, have been included in this version of the program:

Variables are declared just before use (instead of at the beginning of the program). Loop index variables are declared within the loop itself.

Vertical whitespace, mostly in the form of blank lines, has been reduced.

The Boolean flag variable, everyOtherMove, which controlled the alternating moves has been dropped; the alternating moves are now handled by simply testing the odd/even condition of the variable moveCount. This same odd/even test is also used at the beginning of the program to set the value of the variable which determines the direction of movement for the smallest disk.

The more commonly used MOD operator (%) has replaced the bitwise AND operator (&).

The conditional (ternary) statement appears just once: to set the direction to move the smallest disk in the puzzle. This is a simple IF ELSE expression in a single line. I resisted the temptation to use a conditional in two other instances -- when checking whether the smallest disk wraps around when being moved and when selecting the two rods to use in moving the alternate disk. In those two instances the conditionals seemed overly complicated or cryptic.

Other changes include:

A more detailed explanation of the algorithm in the top comment section.

Using 0-based arrays (instead of an array which leaves the zeroth element of the array unused).

Providing a more complete description on determining which disk is at the top of each of the three rods when moving the alternate disk.

Replacing the lengthy Switch statement -- which selects the two rods to use when moving the alternate disk -- with a 3 by 2 element table and just 2 related statements.

The swap routine is now a separate function.

If your compiler does not support variable length arrays the statement int rod[numberOfDisks]; will generate an error -- an error such as "expected constant expression ... array allocation." To resolve this error, in the simplest possible way, change the statement from int rod[numberOfDisks]; to int rod[MAXNUM];