.

A square with area 400.0 has a perimeter of 80.0
    

.

1

.

1

.

Once.

.

You only need to keep track of one "instance"/"copy" of the local variables and once a value is assigned to them the value doesn't change. Hence, you can trace the execution of this method without an eraser.

.

A square with area 400.0 has a perimeter of 80.0
    

.

1

.

1

.

A value is assigned to width one time. A value is assigned to perimeter five times.

.

It is a little more difficult to trace this method because the value of perimeter changes. So, you either have to erase old values (if you don't care about the history) or cross them out (if you want to keep track of how it changed over time).

.

A square with area 400.0 has a perimeter of 80.0
    

.

1

.

4

.

Initially 1, then 2, then 3, then 4.

.

Because there are multiple "instances"/"copies" of the method and local variables and you have to remember where each copy was called from and will return to. This makes it very hard keep track of everything.

and make one card for main() and one card for findPerimeterOfSquare(). (Note: If you're working on this during a scheduled lab period, pre-printed cards are available for increaseBy().)

When the method returns, write down the return value, take the card off of the stack, and replace the method call (on the next card) with the return value.

.

A square with area 400.0 has a perimeter of 80.0
    

.

    The answer is: 6
    

.

-1 (indicating that the target is not in the array named data).

.

3 (i.e., the index of the element containing the value 7).

.

0 (i.e., the index of the element containing the value 1).

.

Even if the call to search() that is passed first and middle finds the target, it still calls search() and passes it middle+1 and last.

.

    public static int search(int first,  int last, 
                             int target, int[] data)
    {
        int      middle, result;
        

        result = -1;
        
        if (first == last) // The base case
        {
            if (target == data[first])
            {
                result = first;                
            }
        }
        else              // Refinement (i.e., shrink the search space)
        {
            if ((target >= data[first]) && (target <= data[last]))
            {
                middle = (first + last) / 2;
                result = search(first, middle, target, data);
                if (result < 0)
                {
                    result = search(middle + 1, last, target, data);
                }
            }
        }
        return result;
    }

.

    Coins needed for 4 cents: 4
    

.

4

.

I added an int attribute named methodCalls, added a constructor that initialized it to 0, and increased it by 1 at the top of the change() method. (In preparation for the final exam: You should understand why methodCalls needs to be an attribute and not a local variable. You should also understand why this attribute should not be static. You should think about the implications of making both the change() method and the methodCalls attribute static.)

I also added a resetMethodCallCounter() method that I could call to assign the value 0 to methodCalls and an accessor method.

• amount when the method is entered
• number each time it changes
• min each time it changes

.

    public int change(int[] coins, int amount) 
    {
        int i, j, min, number;

        methodCalls++;
        
        System.out.println(" ");
        System.out.println("=== Entering change() for the " + 
                           methodCalls+" time ===");
        min = amount;
        
        System.out.println("amount: "+amount);

        // If we can make change with one coin then we are done
        //
        for (i=0; i < coins.length; i++) {
            
            if (coins[i] == amount) return 1; // The base case
        }
        
        // Refine the solution
        //
        for (j=1; j <= (amount/2); j++) {
            
            number = change(coins, j) + change(coins, amount-j);
            System.out.println("j: "+j+"\tnumber: "+number);
            if (number < min)
            {
                System.out.println("\tmin: "+number);
                min = number;
            }
        }
        
        return min;
    }    
    

.

=== Entering change() for the 1 time ===
amount: 4

=== Entering change() for the 2 time ===
amount: 1

=== Entering change() for the 3 time ===
amount: 3

=== Entering change() for the 4 time ===
amount: 1

=== Entering change() for the 5 time ===
amount: 2

=== Entering change() for the 6 time ===
amount: 1

=== Entering change() for the 7 time ===
amount: 1
j: 1    number: 2
j: 1    number: 3
j: 1    number: 4

=== Entering change() for the 8 time ===
amount: 2

=== Entering change() for the 9 time ===
amount: 1

=== Entering change() for the 10 time ===
amount: 1
j: 1    number: 2

=== Entering change() for the 11 time ===
amount: 2

=== Entering change() for the 12 time ===
amount: 1

=== Entering change() for the 13 time ===
amount: 1
j: 1    number: 2
j: 2    number: 4

.

            System.out.println("   ---Recursing from the left");
            numberFromLeftCall = change(coins, j);

            System.out.println("   ---Recursing from the right");
            numberFromRightCall = change(coins, amount-j);

            number = numberFromLeftCall + numberFromRightCall;
    

.

    Coins needed: 2
    

The change() method was called 889 times.

.

.

.