Ebook Data Structures and Abstractions With Java 4Th Edition Carrano Solutions Manual Full Chapter PDF

Data Structures and Abstractions with
Java 4th Edition Carrano Solutions

Manual
Visit to download the full and correct content document: https://testbankdeal.com/dow
nload/data-structures-and-abstractions-with-java-4th-edition-carrano-solutions-manua
l/
Lab 6 Recursion—Part I
Goal
In this lab you will design and implement recursive algorithms. The primary focus in this lab will be algorithms
that make a single recursive call. Tail recursion will be explored. An improved recursive algorithm for
computing Fibonacci numbers will be developed.
Resources
• Chapter 7: Recursion
• Lab6Graphs.pdf – Full size versions of the blank graphs for this lab
Java Files
• Count.java
• RecursiveFactorial.java
• RecursiveFibonacci.java
• RecursiveStringReplace.java
• TestFactorial.java
• TestFibonacci.java
• TestReplace.java
• TimeFibonacci.java
Warning: There is a lot of material in the introduction and pre-lab for this lab. Make sure to start early to
give yourself enough time to complete them before the lab.
Introduction
Recursion is an important technique that shows up in diverse areas of computer science, such as the definition
of computer languages, the semantics of programs, the analysis of algorithms, data structure definitions, and
algorithms. Some of the better algorithms are either recursive or based on recursive algorithms. Also, recursive
algorithms are often very elegant and show an economy of expression.
Since some students struggle with recursion, this lab starts out with some simple applications to improve your
familiarity. The improved version of Fibonacci at the end of the lab is a more complicated example that shows
the true power of recursion. Applying yourself to this lab and the one after should get you comfortable with
recursion. This will be especially useful when merge sort and quick sort are discussed and then again later
when trees are presented. For students who want even more practice with recursion and functional
programming, experiment with the language Lisp. It is one of the oldest computer languages and is still in use.
Its original core was strictly recursive, though iterative constructs were quickly added. Programming in Lisp or
Scheme (one of its derivatives) is an interesting way to practice recursive programming.
Recursion is closely related to iteration. With the appropriate data structures, any iterative algorithm can easily
be turned into a recursive algorithm. Similarly, any recursive algorithm can be made iterative. Tail recursive
algorithms can be easily converted into an iterative algorithm. (Good Lisp compilers will convert tail recursive
code into a loop.) Other recursive algorithms can be converted into an iterative algorithm by using a stack. (See
Lab 10 Explicit Stacks in Recursion for an example.) In some cases, finding an equivalent nonrecursive
algorithm that does not use a stack can be quite challenging.
The basic idea of recursion is to solve a problem by first solving one or more smaller problems. Once this has
been done, the solutions of the smaller problems are combined to form the solution to the original problem. The
repetitive nature of recursion comes into play in that to solve the smaller problems, you first solve even smaller
problems. You cannot defer the solution indefinitely. Eventually, some very small problem must be solved
directly.
Lab Manual for Data Structures and Abstractions with Java ™ 57

Recursive Design
There are five parts to designing a recursive algorithm.
Identify the problem: What are the name and arguments of the original problem to be solved?
Identify the smaller problems: What are the smaller problems that will be used to solve the original
problem?
Identify how the answers are composed: Once the solutions to the smaller problems are in hand, how are
they combined to get the answer to the original problem?
Identify the base cases: What are the smallest problems that must be solved directly? What are their
solutions?
Compose the recursive definition: Combine the parts into a complete definition.
A recursive design for computing factorial will be used to illustrate the process. The standard recursive
definition of factorial is well known (see the resources), so we will make a slight that will reduce the number of
recursive calls made.
Identify the problem:

Factorial(n)
Identify the smaller problems:

(Reduce the problem size by two instead of one.)
Factorial(n – 2)
Identify how the answers are composed:

Factorial(n) = n * (n –1) * Factorial(n – 2)
Identify the base cases:

Certainly Factorial(1) is 1. But is this enough? Consider Factorial(6). Applying the recursion gives
Factorial(6) = 6*5* Factorial(4)

Factorial(6) = 6*5*4*3* Factorial(2)
Factorial(6) = 6*5*4*3*2*1* Factorial(0)
Factorial(6) = 6*5*4*3*2*1*0*(–1) Factorial(–2)
Factorial(6) = 6*5*4*3*2*1*0*(–1) *(–2) *(–3) Factorial(–4)
...
58 Lab 6 Recursion—Part I
Clearly, this recursion has two chains of problems, odds and evens.
Chain of Chain of
problems Factorial(6) problems Factorial(7)
with even with odd
arguments arguments
Factorial(4) Factorial(5)
Factorial(-2) Factorial(-1)
... ...
Both chains must have a base case. An appropriate question is “Where in the even chain should the
recursion stop?” Looking at the last two expansions in the recursion, you see that the resulting product will
be zero, which is not the correct result. No negative n is suitable for the base case. This just leaves the
question of whether the base case for the even chain should be Factorial(2) or Factorial(0). If Factorial(0) is
the base case, what is its value? The value that makes the recursive definition work is 1.
Factorial(0) = 1
Factorial(1) = 1
Compose the recursive definition:
Factorial(n) = 1 if n=0 or n=1

n * (n–1) * Factorial(n–2) if n > 1
From here you can write down the code:
int factorial(int n)
{
int result;
if( n < 2)
result = 1;
else
result = n *(n–1)*factorial(n–2);
return result;
}
An alternate version can be created by recognizing that the base cases are simple and can be folded into the
initialization.
int factorial(int n)
{
int result = 1;
if( n >= 2)
result = n *(n–1)*factorial(n–2);
return result;
}

Recursion with Structures
A list is a data structure that is an ordered collection of items. It will be discussed in more detail in Chapter 12.
It is interesting because this was the basic data structure that Lisp used originally and it was recursively defined.
It was basically a linked structure composed of “cons” pairs. The first part of the cons is a list item value and
the second is a link to the rest of the list (another cons pair). From this definition, there are two obvious methods
that can be used on a list. The first method (originally “car” in lisp) returns the first item of the list. The rest
method (originally “cdr” in lisp) returns the rest of list not including the first item. These correspond to the two
parts of the cons cell. To build a list we can use the cons method that builds a cons pair out of an item and a
list. The base case of the recursive definition is an empy list represented by nil.

Reverse(L)

To reduce the size of the problem, some function of the arguments must decrease. In this case, the list L
must be reduced in size. Consider the following instance of reverse:
Reverse( { 1 2 3 4 5 } ) = { 5 4 3 2 1 }
We can reduce the problem by removing the first item and reversing what is left.
Reverse( { 2 3 4 5 } ) = { 5 4 3 2 }
This can clearly be used to get the solution to the original problem. So in this case the smaller problem is
Reverse(rest(L))

From the example, it is clear that the first item in L must be pasted onto the end of the solution to the smaller
problem.
Reverse(L) = append( Reverse(rest(L)), first(L))

An empty list is the smallest possible list and is represented by nil. Reversing an empty list results in an
empty list.
Reverse(nil) = nil
Reverse(L) = nil if L is nil

append( Reverse(rest(L)), first(L)) if L is not nil
Code is but a short step away.
<T> List<T> reverse(List<T> ls)

{
List<T> result = new ArrayList<T>();
if( ls.size() > 0)
{
result =reverse( ls.subList(1,ls.size() ));
result.add(ls.get(0));
}
return result;
}
The recursive definition used the operations append, first, and rest. In the code, the type of the argument is the
built-in List class from Java. The implementation must use appropriate methods from List to accomplish the
three operations. Since only a single character is being appended, the add() method can be used to place it at
the end of the list. Since the first item is in location 0 of the list, get(0) will extract the first value of the list.
The subList() method allows one to get a range of items from the list. By starting at 1, everything except the
first value will be in the sublist.
There is one more thing to note about this implementation. It is functional in the sense that its argument is
unchanged by the method. It returns a new list, which is the reverse of the argument. While this works well for
the abstract definition of a list, is it equally good for an array representation of a list? Each of the operations
(append, first, and rest) can be implemented, but they will not be very efficient. Often for an array, it is desired
that the array be changed in place instead of creating a new array with the result.
The following redesign of the problem has the constraint that the items to be reversed are stored in an array and
it is desired that the reverse be done in place.

Reverse(A)
Looking ahead, there is a problem. The arguments must decrease in some fashion, yet the array will remain
a constant size. What is decreasing is not the array, but the portion of the array that the recursion is working
on. An auxiliary method that does the actual recursion is required.
ReverseAux(A, start, end)

The portion of the array that is considered must be reduced in size. Consider the following instance of
reverse:
Initially A is [ 1 2 3 4 5 ].
After ReverseAux ([ 1 2 3 4 5 ], 0, 4 ), A is [ 5 4 3 2 1 ].
As opposed to Reverse, ReverseAux does not return anything but has a side effect.
Suppose the same reduction in problem size is used as before (reverse the rest of the array).
Initial array A
1 2 3 4 5
A afterward
ReverseAux 1 5 4 3 2
start = 1
end = 4
5 4 3 2 1
Goal
How can you get from { 1 5 4 3 2 } to { 5 4 3 2 1 }? While it is possible, it requires that every data value be
moved. Trying to use ReverseAux ( { 1 2 3 4 5 }, 0, 3 ) results in the same kind of difficulty.
One solution is to reduce the portion of the array being worked on by moving both ends inward.
ReverseAux(A, start+1, end–1)

Initial array A
1 2 3 4 5
A afterward
ReverseAux 1 4 3 2 5
start = 1
end = 3
5 4 3 2 1
Goal
To get the desired result, all that remains is to swap the first and last entries.
ReverseAux(A, start, end) is
1. ReverseAux(A, start+1, end–1)

2. swap(A[start], A[end]);

Since the reduction is by two, we have two chains of recursive method calls, one each for arrays with odd
and even numbers of values to be reversed. If start is the same as end, there is one value to be reversed in
place. If start is less than end there is more than one value to be reversed. What if start is greater than end?
It is convenient to let this represent the situation where there are no values to be reversed.
If the portion of array to be reversed is empty or contains a single entry, the reverse is the same as the
original and nothing needs to be done.
ReverseAux(A, x, y) where x >= y

is
1. Do nothing.
Reverse(A) = ReverseAux(A, 0, A.length - 1)
ReverseAux(A, start, end) is
1. Do Nothing. if start >= end

or
1. ReverseAux(A, start+1, end–1) if start < end
2. swap(A[start], A[end])
Tail Recursion
The composition work that a recursive algorithm does can either be performed before or after the recursive call.
Here is a trace of the calls that ReverseAux does on a list with six entries.
A=[654321]
State of A going
down the
recursion ReverseAux
A
swap A[0] and A[5]
A=[123456] start = 0
end = 5
A=[154326]
ReverseAux
A=[12345]
swap A[1] and A[4]
A=[123456] start = 1
end = 4
A=[124356]
ReverseAux
A=[12345] swap A[2] and A[3]
A=[123456] start = 2
end = 3
A=[123456]
ReverseAux
A=[12345] Base case:
A=[123456] start = 3 do nothing
end = 2
In this case the swap is done after the recursive call and all the work is done on the way back up the chain.

In a tail recursion, all the work is done on the way down the chain. Suppose that the definition is modified to
become
Reverse(A) = ReverseAuxTail(A, 0, A.length - 1)
ReverseAuxTail (A, start, end) is
1. Do Nothing. if start >= end

or
1. swap(A[start], A[end]) if start < end
2. ReverseAuxTail (A, start+1, end–1)
Here is a trace of the calls that ReverseAuxTail does on a list with six entries.
A=[654321]
A=[123456]
ReverseAuxTail
A
swap A[0] and A[5]
start = 0
end = 5
A=[654321]
A=[623451]
ReverseAuxTail
A=[12345]
swap A[1] and A[4]
start = 1
end = 4
A=[654321]
A=[653421]
ReverseAuxTail
A=[12345]
swap A[2] and A[3]
start = 2
end = 3
A=[654321]
A=[654321]
ReverseAuxTail
Base case: A=[12345]
do nothing start = 3
end = 2
State of A going
down the
recursion
The tail recursive method is composing the answer as it goes down the chain of recursive calls. Once it reaches
the base case, all the work has been done and it can return immediately. Also notice that once the next method
in the chain of recursive calls is invoked, the variables start and end are no longer needed. This means that you
can use an iteration that just has one copy of start and end.
In the version that is not tail recursive, start and end cannot be discarded until after the swap is completed.
Therefore, it must have multiple pairs of start and end, one for each recursive call. These values will be stored
on the system stack.
Often a tail recursive method will have an argument whose purpose is to store a partial solution as it is being
composed. This can be illustrated by revisiting reverse on a list. Remember that the composition step was
Reverse(L) = append( Reverse(rest(L)), first(L))
In this case, the rest operation will be performed on the way down the chain of recursive calls, but the append is
done on the way back up. Unlike reverse with an array, it is not simply a matter of moving statements around.
The solution is to add another variable, which will hold the partial solution.

Reverse(L)
ReverseAuxTail(L, partial)

Again, the size of the list will be reduced by using the rest operation. Consider the following instance of
reverse:
ReverseAuxTail ( { 1 2 3 4 5 }, partial0 ) = { 5 4 3 2 1 }
It is not clear what partial is yet, but the next call will be
ReverseAuxTail ( { 2 3 4 5 }, partial1 ) = { 5 4 3 2 1}
Remember that the result of the final recursive call will be the final solution, so all tail recursive calls will
return the solution. Continuing on,
ReverseAuxTail ( { 3 4 5 }, partial2 ) = { 5 4 3 2 1}
ReverseAuxTail ( { 4 5 }, partial3 ) = { 5 4 3 2 1}
ReverseAuxTail ( { 5 }, partial4 ) = { 5 4 3 2 1}
ReverseAuxTail ( { }, partial5 ) = { 5 4 3 2 1}
Each entry must be added to the partial solution. Looking at the second to last call, the value 5 must be
prepended to the front of the partial solution. (In Lisp, we can easily create a new list with a value at the
front using the cons method. If fact, adding a value at the end of a list is much more complicated.) The
smaller problem is therefore:
ReverseAuxTail (tail(L), prepend(first(L), partial) )

In a tail recursion, all the work in determining how to compose the final solution from the smaller problem
is done in identifying the smaller problem.
ReverseAuxTail (L, partial) =

ReverseAuxTail (tail(L), prepend(first(L), partial) )

An empty list is still the smallest possible list. It will be represented by nil. In this case, though nil is not
returned. When the base case is reached the partial solution is now a complete solution and will be returned.
ReverseAuxTail (nil, partial) = partial

There is one remaining piece of business. What should the initial partial solution be? Since each of the
values will be prepended to it one by one, the only possible choice is nil (an empty list).
Reverse(L) = ReverseAuxTail (L, nil)
ReverseAuxTail (L, partial) =
partial if L is nil
ReverseAuxTail (rest(L), prepend(first(L), partial) ) if L is not nil

Here is the code.
<T> List<T> reverse(List<T> ls)

{
return reverseAuxTail(ls, new ArrayList<T>());
}
<T> List<T> reverseAuxTail(List<T> ls, List<T> partial)

{
if ( ls.size() == 0)
return partial;
else
{
partial.add(0, ls.get(0));
return reverseAuxTail(ls.subList(1,ls.size()), partial);
}
}
The following diagram shows a trace of the method.
returns { 4 3 2 1 }
Reverse
L = {1 2 3 4 }
returns { 4 3 2 1 }
ReverseAuxTail
prepend 1 to {} L={1234}
partial = {}
returns { 4 3 2 1 }
prepend 2 to { 1 } ReverseAuxTail
L={234}
partial = { 1 }
returns { 4 3 2 1 }
ReverseAuxTail
prepend 3 to { 2 1 } L={34}
partial = { 2 1 }
returns { 4 3 2 1 }
ReverseAuxTail
prepend 4 to { 3 2 1 } L={4}
partial = { 3 2 1 }
returns { 4 3 2 1 }
Base case: ReverseAuxTail

return partial L={}
partial = { 4 3 2 1 }
Double Recursion
All of the recursive algorithms presented so far have a simple chain of recursive calls. Each recursive call in
turn makes a single invocation of a smaller recursive problem. A number of recursive algorithms can make two
or more recursive invocations. The classic example of a double recursion is the standard recursive definition of
the sequence of Fibonacci numbers
0, 1, 1, 2, 3, 5, 8, 13, 21, . . .
Each is the sum of the previous two numbers in the sequence. The recursive definition is
F(n) =0 if n = 0
1 if n = 1
F(n–2) + F(n–1) if n > 1
Here is the pattern of recursive calls made for the F(5) tree. (A tree is a mathematical structure composed of
vertices and edges. Each call is a vertex in the tree. Edges represent a method invocation. The root of the tree
is at the top of the diagram and it grows down. The height of the tree is the length of the longest path from the
root. Trees will be discussed in greater depth later when a corresponding data structure is created.)
F(5)
F(3) F(4)
F(1) F(2) F(2) F(3)
F(0) F(1) F(0) F(1) F(1) F(2)
F(0) F(1)
The problem with this kind of recursion is that the number of recursive calls made can grow exponentially as
the tree of problems gets taller. Though it takes a bit of analysis to show, the number of invocations for this
recursive definition of Fibonacci numbers is exponential in n.
One way of dealing with the exponential growth is to guarantee that the height of the tree grows slowly as the
problem size increases. To accomplish this requires that the size of the problem reduce quickly as you go down
a branch in the tree. The merge sort algorithm, which will be presented later, guarantees this by solving two
subproblems each of which is half the size of the original. Halving the size of the subproblems limits the height
of the tree to log2n.
The other way of dealing with the problem is to look for many instances of the same smaller problem. In those
cases we can try two approaches. Memoization stores the results to problems when they are encountered for the
first time. The next time a problem is seen, the result is just retrieved. The pattern for a memoized Fibonacci is

shown next. An asterisk indicates the first evaluation. An underline indicates second evaluations. Base cases
are just evaluated normally.
F(5)*
F(3)* F(4)*
F(1) F(2)* F(2) F(3)
F(0) F(1)
The other technique for dealing with this problem is to iteratively evaluate from small problems to larger
problems. Note that for the Fibonacci sequence each number only depends on the previous two values, so you
do not need to keep all the values. This results in the standard iterative algorithm for computing Fibonacci
numbers.
Timing Programs
The different algorithms for computing Fibonacci numbers will be timed in this lab. This introduces a number
of complications. To find the time, the following chunk of code will be used.
Calendar start = Calendar.getInstance();
// The Code being timed goes here
Calendar end = Calendar.getInstance();

long diff = end.getTime().getTime() -
start.getTime().getTime();
System.out.println("Time to compute ... was "

+ diff + " milliseconds.");
Each time the getInstance() method is invoked, the current system time will be retrieved. That time is the
number of milliseconds from some fixed date. One consequence of this is that the difference may be off by as
much as a millisecond. Any time of that order is not to be trusted. With the speed of today’s computers, some
algorithms may complete well within that time frame. To address this issue, the code that is being timed may
be inside a for loop that will execute the code multiple times. The reported time will be divided by the number
of times the loop executed. This, of course, will introduce an extra bit of time for the loop overhead, but it is
assumed that this will be small and can therefore be ignored.
Our timing difficulties are further complicated by the fact that the code being timed may not have been running
the whole time. The Java Runtime Environment (JRE) is not the only program being executed. As the load on
the computer changes, the amount of time the program gets will change as well. Running the same timing code
with the same parameters will not give you the same result. You hope that the results are within 10%, but there
is no guarantee. Another complicating factor is that the JRE is threaded. (Multiple tasks can be running each in
their own thread within the JRE.) Some development environments will have threads running that will compete
with your program’s thread for time.
Another issue is that as computers get faster, the time required for the execution of an implementation of an
algorithm will decrease. This presents some problems in the instructions for the labs. An appropriate number
of times to execute a loop today may be insufficient tomorrow. Two strategies have been used to ameliorate
these problems.
The first strategy guarantees that enough iterations are done to get a reasonable execution time (usually on the
order of a minute or so). The code is timed once for a fixed number of iterations. That time is then used to
determine the number of iterations to use for the subsequent tests.
The second strategy addresses how to plot the times in a graph. Instead of plotting the actual time, a ratio is
plotted instead. The ratio will be the actual time divided by a baseline time (usually the time for the smallest
input). While the times themselves will vary from computer to computer, the ratios should be fairly stable.
Pre-Lab Visualization
Count
To start, consider a very simple recursion that does not do anything but displays all the integer values from 1 to
n. Each call of the recursion will be for a different value of count and has the responsibility of printing that
value. The original call will be for the largest value to be printed.
First consider the problem of counting from 1 up to n. The smallest value that should be printed is 1. When
doing the recursive design, think about whether the display should be done on the way down the recursion chain
or on the way back up.

Show the operation of your definition on the number 4 in the following diagram. Inside the boxes, show the
values of the arguments passed into the method. On the left-hand side, show the operations done before the
recursive call by the method. On the right-hand side, show operations done after the recursive call.
CountUp
CountUp
CountUp
CountUp
CountUp
Now consider the problem of counting down. In this definition, the same values will be displayed, but in
decreasing order. This should be very similar to the design of counting up.

recursive call by the method. On the right-hand side, show operations done after the recursive call.
CountDown
CountDown
CountDown
CountDown
CountDown
String Replace
Consider the problem of taking a String object and replacing every 'a' in the string with a 'b'. In general,
the actual characters will be parameters of the replace method. The first problem you run into is that a String
is immutable. (Once a String object has been created, it cannot be changed.) . So unlike an array, where the
replace operation can be done in place, an approach more akin to the recursive reverse on a list is needed.
Examine the methods of the String class and show how you would implement each of the following
operations.
First:
Rest:
Append/Prepend:
Using those opeations and consulting reverse as a model, complete the recursive design for replace on a string.

Show the operation of your definition on the string "abcb" with 'b' replaced by 'e' in the following diagram.
Inside the boxes, show the values of the arguments passed into the method. On the left-hand side, show the
operations done before the recursive call. On the right-hand side, show operations done after the recursive call
and indicate what value is returned.
ReplaceString
ReplaceString
ReplaceString
ReplaceString
ReplaceString
Tail Recursive Factorial
As is common with tail recursive designs, an extra variable for the partial solution needs to be added. Factorial
will call a helper method that will do the actual recursion. Think about what factorial is computing in
conjunction with the value of n that is available as one goes down the recursion.

Show the operation of your definition on the number 4 in the following diagram. In the boxes, show the values
of the arguments passed into the method. On the left-hand side, show the operations done before the recursive
call. On the right-hand side, show operations done after the recursive call and indicate what value is returned.
Factorial
FactorialAux
FactorialAux
FactorialAux
FactorialAux
FactorialAux
Improving Fibonacci
As was mentioned in the introduction, one way of controlling a double recursion is to limit the height of the
recursion tree. The standard recursive definition for Fibonacci numbers only reduces the problem size by one
and two. This results in a tree that has height n. To control the height, you must define the recursion in terms
of much smaller problem sizes.
Consider the values of F(n) in the following table.
n F(n)
0 0
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
9 34
10 55
11 89
12 144
13 233
14 377
If the value of F(2n) can be related to the value of F(n), the problem size will be reduced by half and the growth
of the tree will be tamed. In the following table, write down the numerical relation between F(n) and F(2n).
n F(n) F(2n) Relation between F(n) and F(2n)

1 1 1
2 1 3
3 2 8
4 3 21
5 5 55
6 8 144
7 13 377
Perhaps there is a pattern here. Clearly, though F(2n) does not depend on just F(n). Since Fibonacci is double
recursion, perhaps the values depend on values that neighbor F(n). In the following table, write down the
numerical relation.
n F(n-1) F(n) F(n+1) F(2n) Relation between F(n-1), F(n), F(n+1) and F(2n)
1 0 1 1 1
2 1 1 2 3
3 1 2 3 8
4 2 3 5 21
5 3 5 8 55
6 5 8 13 144
7 8 13 21 377

What simple formula does this relation follow?
While the pattern of values we see in the tables is a good sign that there is a general relationship, by itself it is
not concrete evidence. It is possible that the relation fails for larger values of n. A proof by mathematical
induction of the discovered formula is required and can be done.
The F(n+1) term in the formula can be eliminated to produce
F(2n) = F(n)F(n) + 2F(n)F(n-1)
While this definition works for even values, what about odd values? Starting with the formula
F(2n+2) = F(2n+1) + F(2n)
one can derive

F(2n+1) = 2F(n)F(n) + 2F(n)F(n-1) + F(n-1) F(n-1)
This results in the recursive definition (Height Limited Doubly Recursive)
F(n)= 0 n=0
1 n=1
F2 (n/2) + 2F(n/2)F(n/2–1) n is even and > 1
2F2 (n/2) + 2F(n/2)F(n/2-1) + F2 (n/2-1) n is odd and > 1
Show the pattern of calls for F(17) and record the values produced by each call.
What is the height of the tree for F(n)?
How many recursive calls are made? Express your answer in big-O notation.
Tail Recursive Fibonacci

Note that the previous recursive formulation still has repeated subproblems. Therefore, memoization or an
iterative formulation can improve the performance even more. We see, however, that not all possible
subproblems need to be computed. To do an iterative solution from the bottom, the needed subproblems have
to be identified.
Consider the following two partial trees.
F(24)
F(12) F(11)
F(6) F(5) F(5) F(4)
F(23)
F(11) F(10)
F(5) F(4) F(5) F(4)
Looking at the third line, the first tree depends on three different problems, while the second only depends on
two problems. The second tree is more desirable in that it has fewer problems it repeats. The first tree needs
to be fixed so that only two values are needed at each level of the tree.
The problem arises when the larger of the two values in the second line is even. What is desired is a definition
of F(2n–1) in terms of F(n) and F(n–1). Looking at the definitions for F(2n) and F(2n+1) and recalling that any
Fibonacci number is the sum of the previous two, it is easy to derive the relations.
F(2n-1) = F(n)F(n) + F(n-1)F(n-1)

F(2n) = F(n) F(n) + 2F(n)F(n-1)
F(2n+1) = 2F(n) F(n) + 2F(n)F(n-1) + F(n-1) F(n-1)

Using the relation for F(2n–1) for F(11) in the first tree gives
Now each level in the tree will only have two values. The two values needed on the next level are determined
by the n value on the level above. If it is even, use the formulas:
F(2n) = F(n)F(n) + 2F(n)F(n-1)
F(2n–1) = F(n)F(n) + F(n-1)F(n-1)
If it is odd, use the formulas

F(2n+1) = 2F(n)F(n) + 2F(n)F(n-1) + F(n-1)F(n-1)
F(2n) = F(n)F(n) + 2F(n)F(n-1)
The only remaining problem is to determine which pairs of Fibonacci numbers will be computed for a given n.
Write down the pairs needed for n=50.
Suppose n is 163. Each of the pairs is recorded in the following table. The values will depend on the bits in
163. To the right is the bit pattern for 163. Circle the bit that is associated with each pair. Indicate which pair
of formulas was used to get that row from the row below.
F(81) F(80) 1 0 1 0 0 0 1 1
F(40) F(39) 1 0 1 0 0 0 1 1
F(20) F(19) 1 0 1 0 0 0 1 1
F(10) F(9) 1 0 1 0 0 0 1 1
F(5) F(4) 1 0 1 0 0 0 1 1
F(2) F(1) 1 0 1 0 0 0 1 1
F(1) F(0) 1 0 1 0 0 0 1 1
What pair is always at the bottom?
Which bit determines the row for F(2) and F(1)?
If the determining bit is even, which pair of formulas is used?
It is now time to design the tail recursive method for Fibonacci numbers. Again, a tail recursive helper method
will be used. This time, however, two partial solutions are required (one for each of the pairs of values). The
bits in n will determine the pattern of values. Two extra methods will be needed. The first will get the second
most significant bit (the bit to the right of the most significant bit) of a number n. The second will remove the
second most significant bit from a number n.
Consider the number 5. It has the bit pattern 1012. The second bit from the left is 0. Removing the 0 gives 112,
which is 3.
What are the bit patterns for 96, 95, 16, 15, and 9?
Give an algorithm to find the second most significant bit in a number n.
Verify that it works on the bit patterns for 96, 95, 16, 15, and 9.

Give an algorithm to return the value found by removing the second most significant bit in a number n.
Verify that it works on the previous bit patterns.
Using the methods secondMSB() and reduceBySecondMSB(), design a tail recursive algorithm for
Fibonacci numbers.
Does your definition work for n=0?
Does your definition work for n=1?
recursive call by the method. On the right-hand side, show operations done after the recursive call and indicate
what value is returned.
Fibonacci
FibonacciAux
FibonacciAux
FibonacciAux
FibonacciAux

Directed Lab Work
Count
The first goal of this lab is to implement a couple of simple recursive methods that do not compute or return
anything. Their sole purpose is to print integer values and give you some practice with recursion.
Step 1. Look at the skeleton in Count.java. Compile and run the main method in Count.
Checkpoint: The program will ask you for an integer value. Enter any value. A couple messages will be
displayed, but no counting will happen.
Step 2. Refer to the count up recursive design from the pre-lab exercises. Complete the recursive method
countUp().
Checkpoint: Run Count. For the integer value enter 5. You should see 1 2 3 4 5.
Step 3. Refer to the count down recursive design from the pre-lab exercises. Complete the recursive
method countDown().
Final checkpoint: Run Count. For the integer value enter 5. You should see 5 4 3 2 1.
String Replace
The next goal is to complete a recursive method that will replace all occurrences of a given character with
another character.
Step 1. Compile and run the main method in TestReplace.
Checkpoint: The program will run and get a null pointer exception.
Step 2. Refer to the string replace recursive design from the pre-lab exercises and complete the method
replace() in RecursiveStringReplace.java..
Final Checkpoint: Compile and run TestReplace. All tests should pass.
Tail Recursive Factorial

The next goal is to complete a tail recursive helper method that will compute the factorial function.
Step 1. Compile and run the main method in TestFactorial.
Checkpoint: The program will run and fail most tests.
Step 2. Refer to the recursive design from the pre-lab exercises and complete the methods
tailRecursive() and helper() in RecursiveFactorial.java.
Final Checkpoint: Compile and run TestFactorial. All tests should pass.
Timing Basic Fibonacci

The next goal is to see how long it takes to compute Fibonacci numbers using the basic recursive formulation.
Step 1. Compile TimeFibonacci.
Step 2. Run the code for succesively larger even values of n and record the first value of n for which the
time is greater than 100 milliseconds. (24 is a good place to start your search.)
FIRST EVEN VALUE OF N

FOR WHICH THE TIME OF
BASIC FIBONACCI IS GREATER X=
THAN 100 MILLISECONDS
Step 3. Fill in the values for n in the following table. Run the program and fill in the times. Stop timing
when the time is longer than 100,000 milliseconds (about 2 minutes).
N TIME IN MILLISECONDS TO COMPUTE F(N)

USING THE BASIC FIBONACCI RECURSION
X =
X+ 2 =
X+ 4 =
X+ 6 =
X+ 8 =
X+ 10 =
X+ 12 =
X+ 14 =
X+ 16 =
X+ 18 =
X+ 20 =
X+ 22 =
X+ 24 =
X+ 26 =
X+ 28 =
X+ 30 =
Step 4. Plot points from the preceding table on the following graph. Don’t worry about plotting the
points that are off the graph.

Step 5. Draw a smooth curve that approximates the points.
A Better Version of Fibonacci

The next goal is to implement the better versions of fibonacci that were discovered in the pre-lab exercises.
They will be timed.
Step 6. Refer to the pre-lab exercise and complete the implementation of the method better() in
RecursiveFibonacci. (Use the height limited doubly recursive formula.)
Step 7. Compile TestFibonacci.
Checkpoint: Run TestFibonacci. All tests for the better Fibonacci formulation should pass.
A Tail Recursive Version of Fibonacci
Step 8. Refer to the recursive formulation from the tail recursion section on Fibonacci in the pre-lab
exercises and complete the implementation of the method secondMSB() in RecursiveFibonacci. Don’t
forget to change the return statement.
exercises and complete the implementation of the method reduceBy2ndMSB() in RecursiveFibonacci.
Step 10. Test the two methods you just created.
exercises and create a LM recursive helper method in RecursiveFibonacci that uses secondMSB() and
reduceBy2ndMSB().
Step 12. Complete the method tailRecursive() in RecursiveFibonacci that calls the tail recursive
helper method you created.
Step 13. Compile TestFibonacci.
Checkpoint: Run TestFibonacci. All tests for the both Fibonacci formulations should pass.
More Timing of Fibonacci

Step 14. Comment out the call to timeBasic() in TimeFibonacci.
Step 15. Uncomment the code to time the better and tail recursive versions of Fibonacci in
TimeFibonacci.
Step 16. Run TimeFibonacci. Enter 100 for n and 100000 for the number of trials. Fill in the value in
the table.
TIME IN MILLISECONDS TO COMPUTE F(100) T=

USING THE BETTER RECURSIVE FORMULA
Step 17. Complete the following computation.
TRIALS = 10000 / T =
Step 18. Fill in the following table. Use the value of TRIALS from the previous step for the number of
trials.
TIME IN TIME IN
MILLISECONDS MILLISECONDS
FOR BETTER FOR TAIL
FIBONACCI RECURSIVE
FIBONACCI
n=10
n=20
n=30
n=40
n=50
n=60
n=70
n=80
n=90
n=100
Step 19. Plot points (in different colors) for the times for two different versions of Fibonacci in the table.
Put appropriate value labels on the y-axis of the graph.
Note that even though the better formulation allows computations for larger values of N in terms of time, the
computed value also grows exponentially and is still problematic. The methods all use the long data type and
will quickly overflow.

Post-Lab Follow-Ups
1. Develop a recursive algorithm for computing the product of a sequence of odd values. (Eg.
ProdOdd(11) = 1*3*5*7*9*11.) Use that method to develop a recursive algorithm for factorial that
splits the problem into a product of even values and a product of odd values.
2. Develop a recursive algorithm that given a and n, computes the sum

S = 1 + a + a2 + ... + an
3. Develop a recursive algorithm similar to string replace which works in place on an array of characters.
4. Develop a recursive algorithm for computing the second most significant bit of a number n.
5. Develop a recursive algorithm for computing the result of removing the second most significant bit
from a number n.
6. Look at the ratio of the times for computing Fibonacci numbers F(n) and F(n+2) using the basic
recursive formula. Given that you know F(X), predict the amount of time it would take to compute
F(X+50). Predict the amount of time it would take to compute F(X+100).
7. Write a loop to compute successive values of F(n) using the tail recursive version. For what value of n
does the computation overflow?
Another random document with
no related content on Scribd:
dos espanhóis mas dá iguais. E se querem experimentar já lhes não
digo que leiam d’Annunzio e logo Gauthier. Leiam por exemplo
d’Annunzio e Suderman. Se vos não der a impressão que os livros
de d’Annunzio são escritos por uma mulher, não sei que diga!
Tolstoi quando começou às punhadas a Shakespeare devia sentir
a tortura do russo do livro de Eça. E todavia Tolstoi com tôda a sua
mansidão, a sua paciência sofredora, a sua resignação passiva e
néo-cristã não pode compreender a tempestade de paixões que é
Shakespeare. Porque Shakespeare é o colosso do Ódio e do Amor,
o Céu, a Terra e o Inferno. E eu penso que é preciso ser-se um
vélho bruto para não compreender Shakespeare.
Outro tanto dirão de mim. Não compreender d’Annunzio? ¿O
poeta do amor subtil, dos perfumes, dos lilazes, da volúpia perene,
capitosa e aristocrata; o prosador imaterial, cheio de doçura,
magistral, ilustre, divino, mirífico; a pena de ouro que traçou o
Fuoco, o Crime, as Virgens? Eu sei lá! Mas é um crime! E estou
repêso de confessar o meu pecado. Eu não sabia... E ponho-me a
querer entender d’Annunzio. Tomarei um explicador. Porfiarei. A
minha ignorância é lamentável. Mas, quando estou envergonhado e
confuso um diabinho irónico vem e segreda-me ao ouvido que os
outros, que o adoram, que o admiram, percebem-no tanto como eu.
Compreendo agora. É uma «ideia feita», o culto de d’Annunzio. E
como o desgraçado Cornuski, eu, torcendo as mãos, na minha
impotência de o compreender terei que murmurar
desconsoladamente o meu:—«Como é belo!»
Um poema
(Carta ao general Henrique das Neves)
Meu amigo:
JÁ lá vai mês e meio de silêncio sôbre o recebimento do poema
Apoteose Humana, que o meu amigo teve a gentileza de me ofertar
em nome do autor. Só hoje lhe escrevo, mas lá diz o ditado... O
amigo sabe o que o ditado diz. Pediu-me a minha opinião. Sem
embargo dela ser uma opinião a pé, uma opinião infantaria, pacata,
modesta e de bons costumes, vou dar-lha. Sou pouco amigo de dar,
mas emfim...
Eu podia dizer-lhe cousas muito lisongeiras do poema do seu
amigo. Podia dizer-lhe mesmo que ambos eram talentosos,
modestos, bem criados, que recolhiam a horas, não fumavam, etc.,
etc. Mas não. Prefiro dizer-lhe abertamente o que penso,
brutalmente, sem transigências nem banalidades. Portanto o que aí
vai é rude, com a rudeza dum homem que não precisa para nada
dos seus confrades em letras, consagrados, e não consagrados, e
que vive «achando a quàsi todos os deuses pés de barro, ventre de
gibóia a quàsi todos os homens e a quàsi todos os tribunais portas
travessas» como já nos Gatos escrevia Fialho.
Bem se vê que o seu poeta, o sr. M. Joaquim Dias, nunca saiu do
Faial. Se saisse não fazia poemas a uma cousa que não conhece
senão em teoria:—O Homem. Mantegazza, que o estudou a fundo,
sabe o que êle é; eu que lido com êle, ha muito sei o que êle vale. O
que lhe digo em verdade é que êle nunca mereceu os versos do seu
amigo.
O poeta julga o Homem pelos livros. Livros são, quàsi sempre,
gramofones de ideias. Deixe-os cantar. Valia-lhe mais um ano de
viagens do que ler todos os livros que tratam do Homem. É o seu
amigo, médico? É teólogo? É psicólogo? É legista? Só assim se
compreendia que êle conhecesse o assunto do seu poema. Porque
o médico conhece o homem em tôda a sua miséria; o teólogo em
tôda a sua estupidez; o legista em tôda a sua maldade, e o
psicólogo em tudo isto junto. Mas o seu amigo é sómente poeta?
Poeta, nada mais? Sim, isso vê-se logo. Poeta é sonhador. Os
poetas teem ideias muito diversas de todos os outros mortais. São
poetas e basta.
Pediu-me uma carta. A carta aqui vai. Se lha não envio particular,
pelo correio, é porque receio que lhe introduzam algum décimo da
lotaria espanhola e o amigo sofra transtornos por minha causa. Mais
nada.
Logo no prefácio diz o seu poeta: «...Fiz, pois, uma apoteose ao

Homem, a êsse ser que triunfou nas lutas terríveis do passado, que
compreende os fenómenos e as leis e progride». Ora eu não admiro
o Homem. Se algum sentimento tenho por êle ou é desconfiança ou
desprêzo.
Deus, criando o homem à sua imagem e semelhança, foi um
escultor bem medíocre. E pode limpar a mão à parede, se é essa a
suprema manifestação do seu génio. Depois, maravilhosa forma de
reclamo, deu às criaturas o poder de reproduzirem infinitamente a
sua obra prima.
Ora diga-me, meu caro amigo: ¿Em que devemos admirar essa
obra, essa vil e miserável máquina de ossos, nervos, músculos e
tendões? ¿Que criou, que inventou ela de produtivo? ¿Inventou a
dinamite, a melinite, a himalaíte? ¿Canhões que arrasam cidades,
projécteis cataclísmicos, blindagens pavorosas? ¿E isso que vale?
¿Inventou os deuses, os reis, as religiões, os ritos e os dogmas? ¿E
isso para que serve?
Antigamente, nos tempos primitivos, o Homem trocava um
machado de pedra pela pele dum urso. Agora troca a mesma pele
por umas pequenas rodelas de ouro, de prata ou de cobre, com uns
números, a que chamou dinheiro, que são tudo, valem tudo e tudo
podem.
Antigamente não pagava décimas, nem contribuições, nem
impostos. Era senhorio da sua caverna e não necessitava de tomar
óleo de fígado de bacalhau. Não tinha botas, mas não sofria dos
calos. Com a invenção das botas vieram os calos, e com os calos o
rifão que diz «quem tem calos não vai a apertos». Parece que o
general vae concordando? Apenas falei em calos, pareceu-me ouvir
dizer o meu amigo: «Diga-me cá a mim o que isso é!»
A mulher era nua e mentirosa. O homem era quási urso, porque o
urso era quási homem. Ainda não havia médicos, nem boticas, nem
literatos, e a poesia, meu caro amigo, tinha muito menos pau de
campeche. O ar era de todos, a terra de todos era e cada um fazia o
que muito bem queria. Depois é que veio essa pouca vergonha de
arregimentar a gente, sob o nome de famílias, tríbus, nações, etc.,
que fêz com que viesse a praga dos chefes, chefes e mandões de
tôdas as castas e feitios, qual deles mais nocivo e funesto: chefes
de família, chefes de repartição, chefes de polícia, chefes de estado
e até generais, meu caro amigo.
Os enterros eram todos iguais. Não havia enterros de primeira
classe. Desconhecia-se o espartilho, a sobrecasaca, o chapéu alto,
e as vantagens do algodão, que impinge por boa mulher o arenque
mais chupado. Veja lá que temposinho!
Se os povos estavam em guerra era tareia bruta, mòcada de criar
bicho. Mas não metia tiros. Era tudo a cacete. Ainda se não tinha
inventado a metralhadora, o leque da Morte, nem a baioneta, uma
navalha que por não se poder trazer na algibeira do fato, se traz
pendurada à cinta, numa algibeira de lata.
Os deuses eram muitos, mas todos súcios, todos pândegos. E
apesar de não haver jornais, todos sabiam perfeitamente o que se
fazia no Olimpo. Se chovia é que Baco se empiteirara e que o vinho
era branco,—que é bebida diurética. Vá vendo!
Caminhamos pois da liberdade para a servidão. ¿Onde está êsse
progresso de que fala o seu poeta? Se êle me quere impingir que
progredimos, porque mais isto, mais aquilo... temos conversado!
Quere um exemplo? ¿O general não padece de apertos de
uretra? Ora suponha que padecia. Se fôsse no tal tempo vertia onde
muito bem desejava, que ninguêm tinha nada com isso. Mas nestes
tempos de progresso, vá o general fazer isso na rua, e verá o que
lhe sucede. São dez tostões de multa. Vá vendo que progresso tão
catita!
Mas que o progresso é indubitável... sim... não digo que não. Veja
lá se nos tempos em que o homem se cobria de peles podia haver
gatunos de carteiras! Isso podia êle. Ainda não havia bolsos! E se
antes de se inventarem as casacas se corria perigo de confundir um
criado de mesa com um conselheiro de estado!
Eu embirro com o meu semelhante. É, por via de regra, cínico,
trapaceiro, mentiroso e velhaco. Li algures que êle era meu irmão...
em Cristo. Deve ser intrujice, porque eu não conheço Cristo nem
seu irmão.
Quando me estende a mão lá tem a sua fisgada. E eu desconfio
logo que, se já me não embarrilou, está para me embarrilar.
Nestes tempos de progresso, tenho pena de não ser troglodita.
Teria tudo que não tenho e sobejar-me-ia muito do que tenho. Seria
feliz. Dir-me-há o general que hoje se sabe. ¿Mas que diabo de
felicidade dá o saber que êles foram muito mais felizes do que nós?
Olhe que saber alguêm feliz faz sangue mau. ¿E pode por acaso
ser-se feliz, hoje? Não. E então podia.
Aí tem. Antigamente havia liberdade. A de hoje é só poética. O
homem de hoje é um escravo e a sua carta de alforria é a morte. Se
o general contesta lembro-lhe se não tem por desventura alguma
décima relaxada. Não tem? Não tem, mas pode ter.
Como vê, não concordo com o tema da Apoteose Humana. Êle é
de tal ordem que, se o poeta não merece que o general lhe dê oito
dias de detenção, tambêm não é caso para louvor na ordem do dia.
Eu não concordo. Sou novo e conheço já um número
avultadíssimo de patifes. O general é velho, deve conhecer muitos
mais. O diabo então, que é velhíssimo, deve conhecer um pavor
deles.
Já vai longa esta. Eu não sou maçador de profissão e já me ia
tornando impertinente.
Desculpe-me e creia-me
um soldado raso de letras, bastante
insurreccionado.
Oriente
O trabalho é afinal uma cousa consoladora. Talvez a única felicidade
que a vida tem. Trabalhar, trabalhar muito, o trabalho tornado ideia
fixa, sem dar logar a outras ideias, sem dar logar ao sonho, sem
deixar que a Fantasia arquitecte os seus castelos dourados em
douradas bolas de sabão! Invejo os que assim trabalham. Zola
invejava o trabalho rude dos operários. Ser marceneiro, ser
carpinteiro, chegar a noite, ter a sua cadeira ou a sua cómoda
pronta, e descansar! Todavia Zola era como poucos um trabalhador.
Lembro-me de Zola sempre que olho para a estante da minha
livraria, onde se enfileira a obra vasta de Blasco Ibáñez. Eu, algures,
já lhe chamei o Zola da Espanha. Cada vez que vejo a sua obra me
convenço mais de que não errei. Sómente Zola era um rude e
esforçado trabalhador, vindo ainda com um plano que nada
conseguiu fazer mudar e, à semelhança de Balzac, pondo-o em
prática numa série interminável de volumes. Blasco não. É um Zola
sem plano. Talento robusto e pasmoso, não tem de Zola a
testarudez orientadora nem o gigantesco e sintético sôpro
insuflador. Mas para Zola espanhol está bem. Um admirável e
correntio estilo, uma ironia às vezes contundente, amável outras
vezes e sobretudo um poder pictural assombroso. Colorista intenso
são verdadeiramente zolaescas as suas descrições. E até no
aspecto humano se parece com Zola. Como Zola êle é um homem
de bons músculos, nervos sólidos e uma pertinácia que chega a
assombrar.
Vem isto a propósito do novo livro de Blasco. Intitula-se Oriente e
é a reunião de crónicas suas publicadas em jornais espanhóis e sul-
americanos. Tem êste volume na sua obra um número bastante
elevado. No seu género é porêm o segundo ou terceiro. Blasco tem
um livro adorável que intitulou Nel pais del arte e o Paris, reunião de
artigos. O primeiro da sua viagem à Itália, crónicas maravilhosas de
leveza e de transparência; o segundo das suas impressões da
capital do universo, como os franceses pomposamente chamam à
sua feia cidade. Êste, são impressões da sua estada em Vichy,
estação de água célebre, e da sua visita ao Oriente das mil e uma
noites, das princesas encantadas, das mulheres de véu na cara, dos
serralhos, dos rajás, dos sultões, onde há sublimes portas e
séquitos maravilhosos, pedrarias, lendas, desconhecidas floras,
mulheres desconhecidas, sensações nunca experimentadas. É por
isso que dentro da alma de cada artista uma mulher velada se
debruça segredando-lhe—Ao Oriente! Ao Oriente! O Oriente é o
desconhecido, será sempre o desconhecido.
Leiam-se embora tôdas as descrições desde as Cartas que os
padres jesuitas escreveram do Japão no ano..., e das Peregrinações
de Fernão Mendes Pinto até aos mais recentes trabalhos; leiam-se
os autores franceses e inglêses que se esforçam por mostrar-nos o
Oriente scientífica, artística e mentirosamente; leia-se tudo, leiam
tudo o que quiserem, que sempre êsse desejo lhes empeçonhará a
existência. Quem não foi a Paris anseia por ir lá. Depois quere ir
mais longe. Mas emquanto não foi, Paris é tudo. Há criaturas
debruçadas sôbre esta palavra: Paris, a Babilónia, onde a Arte é
grande, onde tudo é grande, porque tudo é grande na fantasia. A
cidade enorme, onde há esplêndidas mulheres, equipagens
faustuosíssimas, nababos, banqueiros, artistas ante os quais o
mundo inteiro boquiabre a sua admiração. Porque a criatura que
sonha não sonha que as esplêndidas mulheres são ambiciosas
vulgares onde só a toilette é alguêm, que as equipagens
conheceram e conhecerão múltiplos donos, que os nababos são às
vezes postiços, que os banqueiros são quási sempre escrocs, e que
os artistas são sempre uns pobres diabos que se matam, que se
arruinam, que se gastam a correr atraz duma quimera que com êles
se encafua quási sempre dentro do caixão de chumbo ou de
casquinha que os leva direitinhos, com a guia de marcha para a
Imortalidade, a dormir no Père-Lachaise.
Ao Oriente! Ao Oriente! Chateaubriand foi ao Oriente. Foi lá
tambêm Flaubert. Foi lá Maxime du Camp. Gomez Carrillo então
quintessencia o maravilhoso nas suas impressões da viagem
encantada—blagueur eterno, mixto risonho de fanfarrão espanhol e
jornalista parisiense. Já Amicis, êsse Amicis, ultimamente morto,
traçara as páginas adoráveis da Constantinopla. Pierre Loti então,
postiço, sonhador e desdenhoso, contava as cousas com um ar de
quem tinha o Oriente na algibeira. E para dizer que tinha, fizera da
loucura realidade. Os seus salões eram orientais. E se alguêm
duvidava, êle, correcto oficial de marinha, ciceronando, mostrava um
Pierre Loti vestido de Buda, um Pierre Loti vestido de bonzo, ora
hierático, ora pontifical, ora mandarinado, ora em uma cabaia de
vulgar mortal.
Blasco Ibáñez escutou tambêm a mulher velada.
Tinha lido alêm de tudo isto aquele imortal louco que se chamou
Julio Verne. Acreditava pois em maravilhas. Foi, viu e escreveu um
livro, o que é uma linda vingança. Antigamente dizia-se chegou, viu
e venceu. Daqui os amorudos lamechas fizeram o incomparável—
chegar, ver e ser vencido. Isto é de molde dizer-se de joelho em
terra, a mão no peito e assim um certo ar patético. Assim um certo
ar bironiano, como se o pobre lord tivesse que ver com estas tolices.
O escritor, porêm, lê, acredita, faz as malas, compra o bilhete, vai,
roubam-no descaradamente em tôda a parte, é comido de
percevejos cosmopolitas, percevejos que, tendo vindo da
Cochinchina no couvre-pieds dum inglês, embarcam no outro dia na
manta de viagem dum tirolês, encontra por tôda a parte caminhos
de ferro, patifes, estradas reais intransitáveis, uma ignorância
pasmosa e um fedor humano?! Que faz para se vingar? Puxa da
caneta, uma caneta com depósito de tinta, puxa dos linguados e zás
—sai livro. Em logar de contar o que passou, o que sofreu, as suas
aventuras e os seus arrependimentos, as saudades que teve da sua
casota e as vezes que torceu a orelha e ela não deitou sangue, não
senhor! Conta cousas maravilhosas, fantasia, intruja e passa a
balela aos outros. De tudo isto resulta um pouco: que todos os livros
de viagem se parecem, exactamente como as cartas de amor, cujo
fundo amoroso passional e estilístico está nesse livro de génio que
se chama o Secretário dos amantes, tão genial que devia ser
obrigatório, e que se não existisse se tornaria patriótico inventá-lo; e
que as viagens me são extremamente aborrecidas, com o que
ninguêm tem absolutamente nada.
Se o Oriente não trouxesse a etiqueta de Vicente Blasco Ibáñez,
eu diria encolhendo os ombros e parodiando o verso célebre de
Espronceda: «que haya un libro más que importa al mundo!» Mas
não. Tive que o ler, e declaro que não perdi o tempo. O Oriente é
curiosamente interessante, e interessantemente curioso. Há nele de
tudo. Descrições maravilhosas, ironia fácil, graça, e de vez em
quando até gravidade, uma gravidade nada protocolária, porque eu
não sei o que isso seja em Espanha, quando me lembro da Marcha
da Cadiz e do Morrongo.
Publicado primitivamente em crónicas, recolhidas agora em
volume, êste livro nada destôa da obra de Blasco, mesmo se
dissermos que Blasco é autor de livros maravilhosos como La
Horda, Entre naranjos, Flor de Mayo e outros. E que, alêm disso,
está horrorosamente traduzido em tôdas as línguas, como o Máximo
Gorki, de quem um entendido me dizia outro dia: «Gorki é um mártir.
Imagine que êle, escrevendo em russo, tem sido traduzido em tôdas
as línguas e dialectos por aí abaixo». É assim uma cousa parecida
com uma história contada aqui e que mil bôcas fôssem passando
umas às outras até Alcântara. Cada uma tinha dado um átomo da
sua originalidade. Tinha ido substituindo ou transformando. ¿Pois
não é uma lei que «na natureza nada se perde, tudo se
transforma»? Quando chegou a Alcântara a história está tôda
transformada. Deixou de ser do seu inventor para ser duma
sociedade anónima. Tal qual Gorki. «O Gorki em russo, diz o meu
interlocutor, parece-se tanto com o que aí conhecemos, que foi
traduzido do espanhol para onde havia vindo do francês e assim por
diante, como uma galinha se parece com uma espada, para não
dizer um ôvo com um espêto».
O Oriente deslumbrou Blasco. Foi, viu e publicou o seu livro. Acho
bem. Acho bem, tanto mais que deu aos seus 20:000 ou não sei
quantos leitores o prazer de ler um livro adorável e
desenfastiadamente escrito, que nos põe bem com a arte e com as
viagens.
E agora, que fechei o livro e me preparo para fechar a crónica,
sempre lhes direi que o trabalho é uma cousa consoladora. Eu
penso assim. O meu vizinho,—todo o cronista tem um vizinho
pensador ou pensativo,—pensa que o trabalho é bom para preto.
Não importa. Eu penso que o trabalho ainda nos põe bem com a
vida e que, se assim não fôsse, eu não teria ido ao Oriente em
espírito, não teria lido um livro magnífico e não teria gostosamente
esportulado os seis tostões que me custou o livro de Blasco.
As flores
CERTA ocasião em que, ido dos confins de Lisboa, me decidi a
visitar o solitário poeta do Hereje e da Traição na sua casa da rua da
Bela Vista, à Graça, ouvi dele, ao perguntar-lhe qual a sua flor
favorita, a seguinte resposta: «Que sei eu, meu amigo? As flores
são como as criaturas. Há nelas tambêm uma hierarquia. ¿Quem
pode deixar de adorar uma dessas rosas do Japão, aveludada,
enlanguescida, aristocrata, soberana? A rosa chá é uma duqueza
formosíssima e decotada. Ah! a rosa chá! Mas tenho uma decidida
predilecção pelo cravo rubro, o cravo sangue, estridoroso, flamante
como uma bandeira desfraldada. O cravo petulante! A violeta é uma
menina romântica. Há violetas que sabem de cor versos inteiros de
Soares de Passos. A camélia é uma delambida. Não veste bem.
Tem algo duma burguezinha carnuda e afectada. Mas não desadoro
na sua humildade o cacto silvestre e a flor de lis».
Ora, como o meu querido Gomes Leal, considero que não há
nada que se pareça tanto com uma linda mulher do que uma bela
rosa. E por isso é que, sempre, ao ver uma rosa me lembro duma
bela mulher. Ao ver um campo de flores, um jardim cuidado e
mimado, como Alexandre ao espraiar os olhos pelo seu exército
dum milhão de homens, não posso deixar de scismar em que tudo
aquilo foi feito para morrer. Alexandre considerava que ao fim dum
século nenhum de todo aquele brilho sobreviveria, nenhum dos seus
guerreiros conservaria o seu porte marcial e humano. Eu, ao ver a
montre dum florista, na falta de jardins por onde alongar os olhos,
penso tristemente que nada restará daquela beleza ao fim de cinco
dias. Envelheceram os cravos, murcharam as rosas, penderam os
lírios, os amor-perfeitos secaram. O próprio funcho, o feto silvestre,
êsses mesmos se vão secando. E de tôda aquela beleza nada
resta, nada. Fôlhas sêcas, fôlhas moribundas, flores agonizantes. O
tempo, impiedosamente, com sua mão gelada as tocou e lhes foi a
pouco e pouco dando a morte...
Uma rosa branca é uma linda mulher. A mulher envelhece como a
rosa; a rosa morre como a mulher. Conservo na minha vida uma
grande saudade. Foi duma rosa branca, enorme, perfumada, que
numa jarrinha, onde um par dulcíssimo e precioso, entrajado à
Império e miniaturado à Watteau, dançava um clássico minuete,
viveu, agonizou e morreu. Trouxera-a uma tarde, déra-ma não sei
quem. Posta na sua jarra, depois de mil cuidados, a rosa era linda e
desdenhosa. Linda e desdenhosa me acostumara a vê-la. Falava-
me às vezes. O seu perfume dizia-me cousas estranhas,
misteriosas, exquisitas, que me embriagavam, que me faziam
sonhar.
Acostumei-me a corporizar a rosa.
Já não era uma flor com a sua anatomia que a botânica me
ensinara. Era uma linda criatura, sonhadora, melancólica, fiel e
amada, que me fazia feliz, mas que se definhava na sua solidão. A-
pesar do calor dos meus beijos, do meu recolhimento profundo e
magoado, ela foi-se «pouco a pouco amortecendo», como no soneto
célebre de João de Deus. Uma dorida mágua a mirrava e
entristecia. Sem saber porque, via a minha rosa tossir. Mimei-a.
Incapaz de amar alguêm, de a alguêm ser fiel, ageitei-lhe o pouso,
dulcifiquei-lhe a estada. Fui seu enfermeiro vigilante. A pouco e
pouco, porêm, a-pesar-de todos os meus cuidados, emurchecia.
Uma tristeza vaga entrou com ela. Perdeu o brilho. Do setim das
suas fôlhas sumiu-se o lustro, e amarrotou-se como as saias de
sêda que se metem a trazer por casa. Encarquilhou-se. E um belo
dia, como aquela donzela dos versos de Vítor Hugo, que morreu
valsando, a minha rosa morreu. Tombou da haste agonizante.
Docemente, tristemente, assisti à sua morte. Vejo agora no fundo
duma caixa, o seu caixão, aquela rosa que foi o meu único amor, e
que é hoje a única saudade da minha vida. Porque amei
estremecidamente aquela linda rosa aveludada cujo perfume ainda
hoje me entontece. E não a posso ver, ao seu cadáver, uma múmia
galante e ressequida, que não entristeça. Era tão linda!
Tambêm amo apaixonadamente as violetas. Diga embora o meu
poeta que elas são românticas. Eu adoro os românticos, porque não
sou no fundo mais do que um romântico que se travestiu em homem
desta época para que o não roubem, para que o não assaltem, para
que o não explorem, para que o não espanquem. Se adoro os
românticos, é porque êles são afinal os únicos que sabem sentir e
os únicos que souberam amar.
Camilo, o romântico apaixonado, amou outra vez ao escrever a D.
Maria Izabel as cartas de amor que seu filho assinava. E pelo rapto
foi uma flor que o vélho romântico indicou para dar o sinal no peitoril
da janela da raptada. Uma flor! Camilo, que fôra um romântico tôda
a vida, como um romântico amando, e odiando com uma sanha que
só hoje se encontra nos vélhos alfarrábios, como um romântico
morreu. Quem poria hoje uma flor? diz Alberto Pimentel. Ninguêm.
¿Tambêm, quem ama hoje as flores apaixonadamente? Um ou outro
maduro que as cultiva, que as estremece e que as chora. Adoro as
violetas. São simples e são modestas.
O perfume das flores é o espírito das mulheres. Há flores
magníficas, supremas de graça, estonteantes de côr, que não
cheiram. Não gosto delas. Há mulheres vestidas de setim,
perfumadas a lilás, que não teem perfume. Quem as pode amar?
Os homens, querendo corrigir a natureza, fizeram flores de conta
própria por cruzamentos e enxertos. Sairam flores macabras, flores
canailles, flores que lembram cocottes, berrantes, auriflamantes,
estonteadoras. Mas não cheiram. Não teem perfume. Como o pintor
da antiguidade que encomendara ao discípulo uma Vénus e que
êste lha apresentara ataviada, mas feia—gargantilhas de pérolas,
barreira de ouro, colar de diamantes, pedraria em profusão—as
flores cruzadas são lindas mas não teem perfume. E logo a resposta
do mestre nos vem à bôca: Fizeste-a rica porque a não pudeste
fazer formosa! É o mesmo. Porque as não puderam fazer
perfumadas, fizeram-nas formosíssimas.
É agora a época das flores. Os dias de sol, lindos, dias tépidos
como os de agora, fazem amar as flores, porque ¿quem as pode
amar em dias londrinos, de nevoeiro e chuva? ¿Quem pode viver
sem o perfume da violeta? Se não fôssem as violetas, a vida seria
duma monotonia assustadora. E tão indispensável se tornam à vida
que duma linda mulher sei eu que não pode viver sem elas. Quantas
vezes, bocejante de tédio, neurastenizada, ela me diz
parafraseando a frase célebre do filósofo alemão:—«Ah! meu
amigo! Se não fôssem as violetas eu não gostaria de viver». Ao seu
peito um ramo de violetas rejuvenesce eternamente. No seu
toucador um frasco de violetas perfuma o ambiente e lhe perfuma a
carne. À sua mesa certas são as violetas, em que os seus dentes
gulosos se atufam, como nas fôlhas de rosa os dentes brancos
dessa poética Madona do Campo Santo.
Depois destas flores mimadas, veem as flores modestas e as
flores terríveis. Flores modestas, a papoula e o malmequer. «Mal me
quer... muito... pouco... nada». Sina rudimentar, sina do acaso. Aos
iludidos ela diz sempre falso: “Muito”. O tempo vem e afinal era
“nada”. Como o malmequer mentiu?! O malmequer é sempre
mentiroso. Se diz “muito” a gente duvida e tem sempre razão. Se diz
“nada” a gente não acredita. E é por isso que falando êle sempre
verdade, porque sempre diz nada, a gente o não quere nas jarras, o
desfolha sem amor. Porque nós odiamos quási sempre quem nos
diz a verdade sem lisonjas e sem paixões.
Nas flores terríveis temos a mancenilha. A mancenilheira é uma
criatura diabólica. Persisto em corporizar as flores. A mancenilha é
uma mulher, uma mulher que dá a morte. Uma daquelas mulheres
que matam, sorrindo, que sorrindo arruinam, e que trazem consigo
sómente a infelicidade. Nunca encontrei nenhuma mulher-
mancenilheira. Eis aqui porque adoro a mancenilha, que não
conheço. Porque a não conheço e porque dá a morte sorrindo.
Quanto custa uma mulher?
TIBÉRIO, filósofo machacaz e meu amigo, tendo lido nesse
extraordinário doido que se chamou Nietzsche, que tudo pode ser
pago porque tudo tem seu preço, veio a mim, resoluto e inquietador,
saber qual o preço que em boa razão se deve dar por uma mulher.
Tibério é um filósofo cheio de ironia azêda e eu, pobre de mim,
confessando-lhe a minha ignorância, resolvi consultar os padres
mestres, os calhamaços e os chavões. Áquele que perdêra os
óculos a arrumar a livraria, aconselhou Castilho que os procurasse
no Dicionário, letra O, que lá estavam. Pois nos livros,—nos livros
há de tudo como na botica—devia vir por fôrça a resolução do
problema.
Procurei, deitei abaixo a livraria e nada. Os meus livrecos eram
todos, ou quási todos, subservientes. Em lhes cheirando a saias...
Tinha ideia dum tal Schopenhauer, filósofo de bôca amarga,
estômago sólido e algibeira quente. O que êle dizia, porque todos
estes filósofos dizem cousas, era pouco, mesmo muito pouco.
E Tibério esperava resposta, mãos nas algibeiras, perna traçada.
Então?...
Suava. Guérin Ginisty dizia, isso lembrava-me eu, que, no fundo,
uma mulher nunca resiste a bons argumentos: «Com quinhentos
luíses, a mais segura delas, indigna-se... Com mil, defende-se...
Com dois mil, perturba-se... Com mais alguma cousa, cede». Tibério
amigo, aqui tem você! Foi o que se pôde arranjar! Mas Tibério sorria
e fazia uma careta. Acho forte, respondeu! Dois mil luíses é muito!
Acho caro! Muito caro, mesmo.
E Tibério, lesto, acabou o cigarro,—não sei se disse que Tibério
fuma desalmadamente!—abriu a porta e foi-se.
Agora aqui fico considerando na pergunta. Fôra uma vergonha
tanta ignorância junta. Mas, era a derrota de tôda esta livralhada de
que me ufano tanto. Era a derrota de tudo isto, ante o gesto
desdenhoso e a pergunta irritante dum filósofo safardana e
impertinente. Nada, não tinha geito nenhum. Considerei, estudei o
problema.
Já lá vai algum tempo depois da pergunta. Agora, se o bom
Tibério me aparecer, mostrando o meu ar mais profundo e o meu
mais retórico gesto, dir-lhe-hei:
«Tibério amigo: O preço duma mulher varia conforme as
circunstâncias. Na Austrália compra-se uma mulher por uma garrafa
de vidro, ou por uma faca ferrugenta. Hás-de concordar que não é
caro! Na Cafraria, por uma quantidade de cabeças de gado bovino,
quantidade que varia de dez a setenta cabeças. Na Índia, por um
porco ou por bois. Mas, se deres mais de dez bois, já foste comido!
Na Islândia compra-se uma mulher por um marco. Em pontos da
África por uma garrafa de rum, e olha que não é barato! O rum
sempre vale mais.
Entre os povos civilizados, o negócio é mais demorado. Casar
com ela, é a fórmula. Então dá-lhe o nome. E ela vendeu-se ou
porque sim, ou por ver a sua tranquilidade assegurada, ou porque o
marido tem boa posição, é deputado, ou lhe pode dar vestidos. Há
tambêm uma outra moeda. Essa, chama-se Amor.
O Amor é uma bebida e uma embriaguez. São duas criaturas que
se encontraram e se propozeram beber do mesmo copo. Beberam
até cair. Depois a bebida começa a repugnar-lhes e adormecem.
Essa repugnância chama-se Saciedade e o adormecer,
Esquecimento. Quem um dia adormeceu no amor ou quando
acordou está curado ou não acordou jamais.
Ora eu, amigo Tibério, não acredito no Amor, cousa em que
jamais algum homem forte acreditou. O amor é uma cousa para
crianças, uma teia de aranha. É preciso estar quietinho para que ela
se não rompa. Depois não acredito que tu ames! ¿Pois tu, com êsse
carão ignóbil de farçola, sabes lá amar? Mesmo que amar é
subalternizar-se. Quem ama curva-se. Quem ama, meu caro amigo,
transige. Quem ama, sim, quem ama... emfim não te aconselho a
que compres mulher nenhuma com essa moeda. Sai pelos olhos da
cara.
Bem. Mas suponhamos que realmente a queres comprar por êsse
preço. Eu te digo: Tu que a queres, é porque a desejas. Ora não há
nada tão jesuita como um desejo. (Isto é de Balzac, mas tão
profundo que parece meu). Mas desejar não é tudo. É preciso
paciência, uma paciência enorme, uma daquelas paciências que
vulgarmente se chamam paciências de ...cordato paciente. A
paciência, ou leva ao triunfo, ou à cura. Com paciência, saberás
esperar. As impaciências são nefastas e tão funestas em trato de
gente limpa que Acácio, conselheiro, a caminho de presidente do
conselho, diz que elas são próprias da gente ordinária. Acácio é
chavão, Acácio sabe disso. Nada percebe de amor, mas tem
dinheiro, e quem tem dinheiro, tem tudo e mais amor.
Ora, ia dizendo! com paciência descobrirás o fraco da pretendida.
Lá diz Molière: Não é bem Molière, é Castilho, mas isso não tira
nem põe:
Nem o mais forte resiste

Aos que no fraco lhe dão.
Que mais queres? Meio Brummel, um quarto de Tartufo e um

logar no ministério da Fazenda deve chegar. E, se não chegar, olha
que sempre te digo que é caro. É pela hora da morte. «Um animal
de cabelos compridos e ideias curtas» como quere Spencer!
Acredito que, não a achando em conta, a não comprarás. «Não te
deixes ir atrás dos artifícios da mulher» é o palavreado bíblico, e
olha que é certo como as cousas certas.
Comprar a mulher em troca dum vitelo, como se faz na
Hotentócia, não acho caro.
Em troca duma tanga vermelha e quatro penas de pavão para a
carapinha, ainda está bem. Dum boi, se os bois abundam, ainda não
está fora da conta. Agora comprá-la pelo casamento acho caro. O
casamento «é um contrato perpétuo»... por tôda a vida, bem sei, diz
o código. Ora um contrato por tôda a vida, para sempre, de que um
homem se não pode evadir senão morrendo, acho duro. E é
comprar uma cousa que não serve para nada e de que a gente se
não pode desfazer vendendo-a a terceiros.
Nada. Não te aconselho êste meio. Pelo amor, vá. Amor com uma
parte de indiferença e duas de desconfiança.
Mas Tibério amigo, isso é platónico? Estarás tu apaixonado?
Apaixonado! Mas isso é inacreditável num scéptico, num ironista,
num desenganado, num filósofo emfim. Como os filósofos são
frágeis! Como o homem é afinal e no fundo uma pena leve que o
vento levanta e muda. Como você, Tibério, se deixou apaixonar.
(Aqui Tibério protestará com a veemência dum deputado da
oposição e eu rejubilo por o meu amigo Tibério ainda não ter
escorregado).
Bem me queria parecer! você, amar! Você o mordaz, o cínico, o
que diz conhecer os homens e as mulheres!
Olhe, Tibério, quere um conselho? Os homens fortes não amam.
Amar é próprio dos fracos. Tenha sempre esta máxima à cabeceira.
Guerra Junqueiro disse a Mercedes Blasco que pusesse à
cabeceira da cama a vida de Cristo e a vida de Buda. Pois digo-lhe
que guarde à cabeceira da cama a recordação do que lhe digo.
Tenha sempre presente. O amor é como o toucinho, e dêsse diz
Paulo Diacre, que todo acaba por criar ranço. Ora quem começa a
amar acredita lá que o seu toucinho crie ranço algum dia!?
Tibério: Meu amigo. ¿Leu você nos jornais a notícia daquele
homem que se suicidou em Paris, por causa duma mulher que o
deixou? ¿Leu você a história daquele que, ciumento, furou a pele
doutra com uma dúzia de punhaladas? ¿Leu você a daquele outro
que, por causa dEla, matou o rival com uma cacheirada no toutiço?
Leu você? Ora aqui tem exemplos dos que as compraram bem caro,
se é que as compraram mais do que em Ideia. Veja você se pode
passar sem isso. Não compre nenhuma. Veja se alguêm lha
empresta, ou se a encontra. E se emfim sempre se puser a comprá-
la, compre-a por tudo menos por essa tal moeda que se chama
Amor. Não se apresse. Vem no Frei Luís de Souza... «As cousas
são grandes ou pequenas, segundo a medida do desejo com que se
buscam...» Quanto menos as desejar mais baratas lhe aparecerão.
E que pena que Tibério já se tivesse ido embora! Era um discurso
tão bonito!...

Ebook Data Structures and Abstractions With Java 4Th Edition Carrano Solutions Manual Full Chapter PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Ebook Data Structures and Abstractions With Java 4Th Edition Carrano Solutions Manual Full Chapter PDF

Uploaded by

Copyright:

Available Formats

Data Structures and Abstractions with

Java 4th Edition Carrano Solutions

Lab Manual for Data Structures and Abstractions with Java ™ 57

Identify the problem:

Identify the smaller problems:

Identify how the answers are composed:

Identify the base cases:

Factorial(6) = 6*5* Factorial(4)

Compose the recursive definition:

Factorial(n) = 1 if n=0 or n=1

From here you can write down the code:

Lab Manual for Data Structures and Abstractions with Java ™ 59

Identify the problem:

Identify the smaller problems:

Identify how the answers are composed:

Reverse(L) = append( Reverse(rest(L)), first(L))

Identify the base cases:

Compose the recursive definition:

Reverse(L) = nil if L is nil

Code is but a short step away.

<T> List<T> reverse(List<T> ls)

Identify the problem:

Identify the smaller problems:

ReverseAux(A, start+1, end–1)

Lab Manual for Data Structures and Abstractions with Java ™ 61

Identify how the answers are composed:

ReverseAux(A, start, end) is

1. ReverseAux(A, start+1, end–1)

Identify the base cases:

ReverseAux(A, x, y) where x >= y

Compose the recursive definition:

Reverse(A) = ReverseAux(A, 0, A.length - 1)

ReverseAux(A, start, end) is

1. Do Nothing. if start >= end

Lab Manual for Data Structures and Abstractions with Java ™ 63

Reverse(A) = ReverseAuxTail(A, 0, A.length - 1)

ReverseAuxTail (A, start, end) is

1. Do Nothing. if start >= end

Identify the problem:

Identify the smaller problems:

ReverseAuxTail (tail(L), prepend(first(L), partial) )

Identify how the answers are composed:

ReverseAuxTail (L, partial) =

Identify the base cases:

ReverseAuxTail (nil, partial) = partial

Compose the recursive definition:

Reverse(L) = ReverseAuxTail (L, nil)

ReverseAuxTail (L, partial) =

Lab Manual for Data Structures and Abstractions with Java ™ 65

<T> List<T> reverse(List<T> ls)

<T> List<T> reverseAuxTail(List<T> ls, List<T> partial)

The following diagram shows a trace of the method.

Base case: ReverseAuxTail

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

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

Lab Manual for Data Structures and Abstractions with Java ™ 67

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

Calendar start = Calendar.getInstance();

// The Code being timed goes here

Calendar end = Calendar.getInstance();

System.out.println("Time to compute ... was "

Identify the problem:

Identify the smaller problems:

Factorial(6) = 65 Factorial(4)