Recursion

CSE225: Data Structures and Algorithms

A Look Back at Functions
#include <stdio.h>
#include <math.h>
double distance(double x1, double y1, double x2, double y2)
{
double dist;
dist = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
return dist;
}
int main()
{
double milage = distance(0, 0, 3, 4);
printf("Milage: %lf\n",milage);
return 0;
}
A Look Back at Functions
#include <stdio.h>
#include <math.h>
double distance(double x1, double y1, double x2, double y2)
{
double dist;
dist = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
return dist;
}
int main()
{
double milage = distance(0, 0, 3, 4);
printf("Milage: %lf\n",milage);
return 0;
}

main
A Look Back at Functions
#include <stdio.h>
#include <math.h>
double distance(double x1, double y1, double x2, double y2)
{
double dist;
dist = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
return dist;
}
int main()
{
double milage = distance(0, 0, 3, 4);
printf("Milage: %lf\n",milage);
return 0;
}

main distance
(0,0,3,4)
A Look Back at Functions
#include <stdio.h>
#include <math.h>
double distance(double x1, double y1, double x2, double y2)
{
double dist;
dist = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
return dist;
}
int main()
{
double milage = distance(0, 0, 3, 4);
printf("Milage: %lf\n",milage);
return 0;
}

main distance sqrt

(0,0,3,4) (25)
A Look Back at Functions
#include <stdio.h>
#include <math.h>
double distance(double x1, double y1, double x2, double y2)
{
double dist;
dist = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
return dist;
}
int main()
{
double milage = distance(0, 0, 3, 4);
printf("Milage: %lf\n",milage);
return 0;
}

(5)

main distance sqrt

(0,0,3,4) (25)
A Look Back at Functions
#include <stdio.h>
#include <math.h>
double distance(double x1, double y1, double x2, double y2)
{
double dist;
dist = sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
return dist;
}
int main()
{
double milage = distance(0, 0, 3, 4);
printf("Milage: %lf\n",milage);
return 0;
}

(5)

main distance
(0,0,3,4)
Recursion
• Recursion is a technique that solves a problem by solving a smaller
problem of the same type.
• Recursion can be implemented using a recursive function (a
function invoking itself, either directly or indirectly).
• Recursion can be used as an alternative to iteration.
• It is an important and powerful tool in problem solving and
programming.
• It is a programming technique that naturally implements the divide-
and-conquer problem solving methodology.
Factorial – Iterative Definition
n! = n * (n-1) * (n-2) * … * 2 * 1 for any integer n>0
0! = 1

Iterative Definition in C:
fval = 1;
for (i = n; i >= 1; i--)
fval = fval * i;
Factorial – Recursive Definition
• To define n! recursively, n! must be defined in terms of the
factorial of a smaller number.
• Observation (problem size is reduced):
n! = n * (n-1)!
• Base case: 0! = 1
• We can reach the base case, by subtracting 1 from n if n is a
positive integer.

Recursive Definition:
n! = 1 if n = 0
n! = n*(n-1)! if n > 0
The Nature of Recursion
1. One or more simple cases of the problem (called the stopping cases or
base case) have a simple non-recursive solution.
2. The other cases (general cases) of the problem can be reduced (using
recursion) to problems that are closer to stopping cases.
3. Eventually the problem can be reduced to base cases only, which are
relatively easy to solve.

In general:
if (base case)
solve it
else
reduce the problem using recursion // general case
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * __
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * __ Calculate 3!
3! = 3 * (3-1)!
3! = 3 * 2!
3! = 3 * __
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * __ Calculate 3!
3! = 3 * (3-1)!
3! = 3 * 2!
3! = 3 * __ Calculate 2!
2! = 2 * (2-1)!
2! = 2 * 1!
2! = 2 * __
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * __ Calculate 3!
3! = 3 * (3-1)!
3! = 3 * 2!
3! = 3 * __ Calculate 2!
2! = 2 * (2-1)!
2! = 2 * 1!
2! = 2 * __ Calculate 1!
1! = 1 * (1-1)!
1! = 1 * 0!
1! = 1 * __
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * __ Calculate 3!
3! = 3 * (3-1)!
3! = 3 * 2!
3! = 3 * __ Calculate 2!
2! = 2 * (2-1)!
2! = 2 * 1!
2! = 2 * __ Calculate 1!
1! = 1 * (1-1)!
1! = 1 * 0!
1! = 1 * __
Calculate 0!
0! = 1
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * __ Calculate 3!
3! = 3 * (3-1)!
3! = 3 * 2!
3! = 3 * __ Calculate 2!
2! = 2 * (2-1)!
2! = 2 * 1!
2! = 2 * __ Calculate 1!
1! = 1 * (1-1)!
1! = 1 * 0!
1! = 1 * 1
1! = 1
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * __ Calculate 3!
3! = 3 * (3-1)!
3! = 3 * 2!
3! = 3 * __ Calculate 2!
2! = 2 * (2-1)!
2! = 2 * 1!
2! = 2 * 1
2! = 2
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * __ Calculate 3!
3! = 3 * (3-1)!
3! = 3 * 2!
3! = 3 * 2
3! = 6
Factorial of 4 (Recursive)
Calculate 4!
4! = 4 * (4-1)!
4! = 4 * 3!
4! = 4 * 6
4! = 24
Recursive Factorial Function
// Computes the factorial of a nonnegative integer.
// Precondition: n must be greater than or equal to 0.
// Postcondition: Returns the factorial of n; n is unchanged.

int Factorial(int n)
{
if (n ==0)
return 1;
else
return (n * Factorial(n-1));
}
Tracing Factorial(4)
Factorial(4)
Tracing Factorial(4)
Factorial(4)

call

Factorial (4)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)

call

Factorial (4)
call

Factorial (3)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)
= 4 * (3 * Factorial(2))

call

Factorial (4)
call

Factorial (3)
call

Factorial (2)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)
= 4 * (3 * Factorial(2))
= 4 * (3 * (2 * Factorial(1)))

call

Factorial (4)
call

Factorial (3)
call

Factorial (2)
call

Factorial (1)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)
= 4 * (3 * Factorial(2))
= 4 * (3 * (2 * Factorial(1)))
= 4 * (3 * (2 * (1 * Factorial(0))))

call

Factorial (4)
call

Factorial (3)
call

Factorial (2)
call

Factorial (1)
call

Factorial (0)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)
= 4 * (3 * Factorial(2))
= 4 * (3 * (2 * Factorial(1)))
= 4 * (3 * (2 * (1 * Factorial(0))))
= 4 * (3 * (2 * (1 * 1)))
call

Factorial (4)
call

Factorial (3)
call

Factorial (2)
call

Factorial (1)
call return 1

Factorial (0)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)
= 4 * (3 * Factorial(2))
= 4 * (3 * (2 * Factorial(1)))
= 4 * (3 * (2 * (1 * Factorial(0))))
= 4 * (3 * (2 * (1 * 1)))
= 4 * (3 * (2 * 1)) call

Factorial (4)
call

Factorial (3)
call

Factorial (2)
call return 1*1 = 1

Factorial (1)
call return 1

Factorial (0)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)
= 4 * (3 * Factorial(2))
= 4 * (3 * (2 * Factorial(1)))
= 4 * (3 * (2 * (1 * Factorial(0))))
= 4 * (3 * (2 * (1 * 1)))
= 4 * (3 * (2 * 1)) call

= 4 * (3 * 2) Factorial (4)
call

Factorial (3)
call return 2*1 = 2

Factorial (2)
call return 1*1 = 1

Factorial (1)
call return 1

Factorial (0)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)
= 4 * (3 * Factorial(2))
= 4 * (3 * (2 * Factorial(1)))
= 4 * (3 * (2 * (1 * Factorial(0))))
= 4 * (3 * (2 * (1 * 1)))
= 4 * (3 * (2 * 1)) call

= 4 * (3 * 2) Factorial (4)
= 4 * 6 call return 3*2 = 6

Factorial (3)
call return 2*1 = 2

Factorial (2)
call return 1*1 = 1

Factorial (1)
call return 1

Factorial (0)
Tracing Factorial(4)
Factorial(4) = 4 * Factorial(3)
= 4 * (3 * Factorial(2))
= 4 * (3 * (2 * Factorial(1)))
= 4 * (3 * (2 * (1 * Factorial(0))))
= 4 * (3 * (2 * (1 * 1)))
= 4 * (3 * (2 * 1)) call return 4*6 = 24 final answer

= 4 * (3 * 2) Factorial (4)
= 4 * 6 call return 3*2 = 6

Factorial (3)
= 24
call return 2*1 = 2

Factorial (2)
call return 1*1 = 1

Factorial (1)
call return 1

Factorial (0)
A Couple of Things You Should Know

• A stack is used to keep track of function calls.

• Whenever a new function is called, all its parameters
and local variables are pushed onto the stack along with
the memory address of the calling statement (this gives
the computer the return point after execution of the
function)
Pitfalls of Recursion
• If the recursion never reaches the base case, the recursive
calls will continue until the computer runs out of memory and
the program crashes. Experienced programmers try to
examine the remains of a crash. The message “stack overflow
error” or “heap storage exhaustion” indicates a possible
runaway recursion.
• When programming recursively, you need to make sure that
the algorithm is moving toward the base case. Each
successive call of the algorithm must be solving a simpler
version of the problem.
• Any recursive algorithm can be implemented iteratively, but
sometimes only with great difficulty. However, a recursive
solution will always run more slowly than an iterative one
because of the overhead of opening and closing the recursive
calls.
Fibonacci’s Problem

“Fibonacci”
(Leonardo de
Pisa)
1170-1240
Fibonacci Numbers

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ...

where each number is the sum of the preceding two.
• Recursive definition:
• F(0) = 0;
• F(1) = 1;
• F(number) = F(number-1)+ F(number-2);
Fibonacci Numbers
int Fibonacci(int n)
{
if(n == 0)
return 0;
else if (n == 1)
return 1;
else
return Fibonacci(n-1)+Fibonacci(n-2);
}
Fibonacci Numbers
int Fibonacci(int n)
{
if(n == 0)
return 0;
else if (n == 1) Base case
return 1;
else
return Fibonacci(n-1)+Fibonacci(n-2);
}
Fibonacci Numbers
int Fibonacci(int n)
{
if(n == 0)
return 0;
else if (n == 1)
return 1;
else
return Fibonacci(n-1)+Fibonacci(n-2);
} General
case
Tracing Fibonacci(5)
F(5)
5 3 2
Return F(4)+F(3)

F(4) F(3)
2 1
Return F(3)+F(2) 1 1
Return F(2)+F(1)

F(3) F(2) F(2) F(1)

1 1
Return F(2)+F(1) 1 0
Return F(1)+F(0) 1 0
Return F(1)+F(0) Return 1

F(2) F(1) F(1) F(0) F(1) F(0)

1 0
Return F(1)+F(0) Return 1 Return 1 Return 0 Return 1 Return 0

F(1) F(0)
Return 1 Return 0
Another Example:
n choose r (combinations)

• Given n things, how many different sets of size r can be

chosen?

 n n!
   ,1  r  n (closed form)
 r  r!(n  r )!
n choose r (Combinations)

 n   n  1  n  1
       ,1  r  n (recursive )
 r   r  1  r 

with base cases:

 n  n
  n and   1
 1  n
n choose r (Combinations)

int Combinations(int n, int r)

{
if(r == 1) // base case 1
return n;
else if (n == r) // base case 2
return 1;
else //general case
return(Combinations(n-1, r-1) + Combinations(n-1, r));
}
Tracing Combinations(4,3)
Binary Search: The Recursive Way
• Base case:
1. Array is empty: item not found
2. Array is non-empty and item is the middle element:
item is found
• General case:
• Search either the right half or the left half of the array
Binary Search: The Recursive Way
template<class ItemType>
bool BinarySearch(ItemType info[], ItemType item, int fromLocation,
int toLocation)
{
if (fromLocation > toLocation) // Base case 1
return false;
else
{
int midPoint;
midPoint = (fromLocation + toLocation) / 2;
if (item < info[midPoint])
return BinarySearch(info, item, fromLocation, midPoint - 1);
else if (item == info[midPoint]) // Base case 2
return true;
else
return BinarySearch(info, item, midPoint + 1, toLocation);
}
}
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

Find 9:
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 9:
BinarySearch(A,9,0,10
)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 9:
BinarySearch(A,9,0,10
)
call

BinarySearch(A,9,0,4)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 9:
BinarySearch(A,9,0,10
)
call

BinarySearch(A,9,0,4)
call

BinarySearch(A,9,3,4)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 9:
BinarySearch(A,9,0,10
)
call

BinarySearch(A,9,0,4)
call

BinarySearch(A,9,3,4)
call

BinarySearch(A,9,4,4)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 9:
BinarySearch(A,9,0,10
)
call

BinarySearch(A,9,0,4)
call

BinarySearch(A,9,3,4)
return true
call

BinarySearch(A,9,4,4)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 9:
BinarySearch(A,9,0,10
)
call

BinarySearch(A,9,0,4) return true

call

BinarySearch(A,9,3,4)
return true
call

BinarySearch(A,9,4,4)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 9:
BinarySearch(A,9,0,10
) return true
call

BinarySearch(A,9,0,4) return true

call

BinarySearch(A,9,3,4)
return true
call

BinarySearch(A,9,4,4)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

return true

call
Find 9:
BinarySearch(A,9,0,10
) return true
call

BinarySearch(A,9,0,4) return true

call

BinarySearch(A,9,3,4)
return true
call

BinarySearch(A,9,4,4)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

Find 20:
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 20:
BinarySearch(A,20,0,10)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 20:
BinarySearch(A,20,0,10)
call

BinarySearch(A,20,6,10)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 20:
BinarySearch(A,20,0,10)
call

BinarySearch(A,20,6,10)
call

BinarySearch(A,20,6,7)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 20:
BinarySearch(A,20,0,10)
call

BinarySearch(A,20,6,10)
call

BinarySearch(A,20,6,7)
call

BinarySearch(A,20,6,5)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 20:
BinarySearch(A,20,0,10)
call

BinarySearch(A,20,6,10)
call

BinarySearch(A,20,6,7)
call return false

BinarySearch(A,20,6,5)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 20:
BinarySearch(A,20,0,10)
call

BinarySearch(A,20,6,10)
return false
call

BinarySearch(A,20,6,7)
call return false

BinarySearch(A,20,6,5)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

call
Find 20:
BinarySearch(A,20,0,10)
return false
call

BinarySearch(A,20,6,10)
return false
call

BinarySearch(A,20,6,7)
call return false

BinarySearch(A,20,6,5)
 index 0 1 2 3 4 5 6 7 8 9 10
A
value 1 3 5 8 9 17 32 36 42 49 53

return false

call
Find 20:
BinarySearch(A,20,0,10)
return false
call

BinarySearch(A,20,6,10)
return false
call

BinarySearch(A,20,6,7)
call return false

BinarySearch(A,20,6,5)
The Puzzle
• Tower of Hanoi is a mathematical puzzle invented by a French
Mathematician Edouard Lucas in 1883.
• The game starts by having few discs stacked in increasing order of
size. The number of discs can vary, but there are only three pegs.
The Puzzle
• The Objective is to transfer the entire tower to one of the other
pegs. However you can only move one disk at a time and you can
never stack a larger disk onto a smaller disk. Try to solve it in fewest
possible moves.
Solve Hanoi with 4 Discs
Recursive Solution
• Problem: Move N discs from source peg to destination
peg using auxiliary peg as via
• Base case:
• Move disc from source peg to destination peg (N = 1)
Recursive Solution
• Problem: Move N discs from source peg to destination
peg using auxiliary peg as via
• General case:
• Move N-1 discs from source peg to auxiliary peg via destination
peg
• Move disc from source peg to destination peg
• Move N-1 discs from auxiliary peg to destination peg via source
peg
Recursive Function for Solving Hanoi
#include <stdio.h>
void hanoi(int n, char src, char dst, char aux)
{
if(n == 1)
printf("Move disc from peg %c to peg %c\n", src,
dst);
else
{
hanoi(n-1, src, aux, dst);
hanoi(1, src, dst, aux);
hanoi(n-1, aux, dst, src);
}
}

int main()
{
hanoi(4, 'A', 'C', 'B');
return 0;
}
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
 H(1,A,B,C)

H(1,A,C,B)

H(1,B,C,A)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C) H(1,C,B,A)
H(3,A,B,C)
H(2,C,B,A) H(1,A,B,C)
H(4,A,C,B) H(1,A,C,B)
H(2,B,A,C) H(1,B,C,A)
H(3,B,C,A)
H(1,B,C,A) H(1,B,A,C)

H(2,A,C,B) H(1,C,A,B)

H(1,A,B,C)
A B C H(1,A,C,B)

H(1,B,C,A)
Recursive Function for Solving Hanoi
Output:
Move disc from peg A to peg B
Move disc from peg A to peg C
Move disc from peg B to peg C
Move disc from peg A to peg B
Move disc from peg C to peg A
Move disc from peg C to peg B
Move disc from peg A to peg B
Move disc from peg A to peg C
Move disc from peg B to peg C
Move disc from peg B to peg A
Move disc from peg C to peg A
Move disc from peg B to peg C
Move disc from peg A to peg B
Move disc from peg A to peg C
Move disc from peg B to peg C
Home-work
Modify the Hanoi function so that it produces the following output

Move disc 1 from peg A to peg B

Move disc 2 from peg A to peg C
Move disc 1 from peg B to peg C
Move disc 3 from peg A to peg B
Move disc 1 from peg C to peg A
Move disc 2 from peg C to peg B
Move disc 1 from peg A to peg B
Move disc 4 from peg A to peg C
Move disc 1 from peg B to peg C
Move disc 2 from peg B to peg A
Move disc 1 from peg C to peg A
Move disc 3 from peg B to peg C
Move disc 1 from peg A to peg B
Move disc 2 from peg A to peg C
Move disc 1 from peg B to peg C