class Fibonacci
{

	// this solves problem P5.19 in the textbook,
	// in two ways:  recursively (bad), normal (good).

	public static int fibonacci( int n )
	{
		if( n <= 0 ) return 0;

		int fib = 1;
		int fibPrev     = 1;   // fib(1),  fib(i-2)
		int fibPrevPrev = 1;   // fib(2),  fib(i-1)

		for( int i=3; i <= n; i++ ) {
			fib = fibPrev + fibPrevPrev;

			// update the prev values
			fibPrevPrev = fibPrev;
			fibPrev     = fib;
		}

		return fib;
	}

	// this is a recursive version of fibonacci.
	// it is very inefficient because it makes
	// numerous repetitive calls to itself.
	// for example, fib(9) calls fib(8) and fib(7),
	// but fib(8) calls fib(7) and fib(6).  notice
	// how fib(7) was called twice there.
	// as the fibonacci proceeds, it gets even
	// more redundant.  See section 12.9 in textbook.
	private static int fibonacciRecursiveCalls;
	public  static int fibonacciRecursive( int n )
	{
		fibonacciRecursiveCalls++;
		if( n <= 0 )
			return 0;
		if( n <= 2 )
			return 1;
		else
			return fibonacciRecursive(n-1) + fibonacciRecursive(n-2);
	}

	public static void main( String[] args )
	{
		// compute up to fib(30) as an example
		for( int i=1; i <= 30; i ++ ) {
			int fib  = fibonacci( i );

			fibonacciRecursiveCalls = 0; 
			int fibR = fibonacciRecursive( i );

			System.out.print( "fibonacci(" + i + ") = " + fib );
			System.out.print( "\tfibonacciRecursive(" + i + ") = " + fibR );
			System.out.println( "\tin " + fibonacciRecursiveCalls + " calls" );
		}
	}
}