Question 1

Consider the following recursive code snippet:
Public int mystery(int n, int m)
{
If (n == 0)
{
Return 0;
}
If (n == 1)
{
Return m;
}
Return m + mystery(n - 1, m);
}
What value is returned from a call to mystery(1,5)?
A) 1
B) 5
C) 6
D) 11

Accepted Answer

The function checks if n is 1, and if so, it returns m. Since n is 1 and m is 5, the function returns 5.

Question 2

Complete the code for the recursive method printSum shown in this code snippet, which is intended to return the sum of digits from 1 to n:
Public static int printSum(int n)
{
If (n == 0)
{
Return 0;
}
Else
{
______________________________
}
}
A) return (printSum(n - 1));
B) return (n + printSum(n + 1));
C) return (n + printSum(n - 1));
D) return (n - printSum(n - 1));

Accepted Answer

To find the sum of digits from 1 to n, we need to add n to the sum of digits from 1 to n-1. Therefore, the correct choice is to return (n + printSum(n-1)).

Question 3

Consider the recursive method myPrint shown in this code snippet:
Public void myPrint(int n)
{
If (n < 10)
{
System.out.print(n);
}
Else
{
Int m = n % 10;
System.out.print(m);
MyPrint(n / 10);
}
}
What does this method do?
A) Prints a positive int value forward, digit by digit.
B) Prints a positive int value backward, digit by digit.
C) Divides the int by 10 and prints out its last digit.
D) Divides the int by 10 and prints out the result.

Accepted Answer

The method recursively prints out the digits of a positive integer in reverse order, one digit at a time, until the entire value has been printed out.

Question 4

Consider the getArea method from the textbook shown below:
Public int getArea()
{
If (width <= 0) { return 0; } // line #1
If (width == 1) { return 1; } // line #2
Triangle smallerTriangle = new Triangle(width - 1); // line #3
Int smallerArea = smallerTriangle.getArea(); // line #4
Return smallerArea + width; // line #5
}
Which line has the recursive case?
A) line #1
B) line #2
C) line #3
D) line #4

Accepted Answer

The answer of Consider the getArea method from the textbook...

Question 5

Consider the following recursive code snippet:
Public int mystery(int n, int m)
{
If (n == 0)
{
Return 0;
}
If (n == 1)
{
Return m;
}
Return m + mystery(n - 1, m);
}
What value is returned from a call to mystery(3,6)?
A) 3
B) 6
C) 18
D) 729

Accepted Answer

The code recursively calls itself with n decreasing by 1, and adding m to the result each time. So, a call to mystery(3,6) will return 6 + mystery(2,6) which will return 6 + 6 + mystery(1,6) and then 6 + 6 + 6 which is equal to 18.

Question 6

Consider the getArea method from the textbook shown below:
Public int getArea()
{
If (width <= 0) { return 0; } // line #1
Else if (width == 1) { return 1; } // line #2
Else
{
Triangle smallerTriangle = new Triangle(width - 1); // line #3
Int smallerArea = smallerTriangle.getArea(); // line #4
Return smallerArea + width; // line #5
}
}
Assume the code in line #3 is changed to:
Triangle smallerTriangle = new Triangle(width);
This change would cause infinite recursion for which triangles?
A) Those with width equal to 0.
B) Those with width equal to 1.
C) Those with width greater than or equal to 2.
D) Triangles of any width.

Accepted Answer

The change causes infinite recursion for triangles with width greater than or equal to 2 because the width never decreases, leading to repeated calls without reaching a base case.

Question 7

Consider the code for the recursive method mysteryPrint shown in this code snippet:
Public static int mysteryPrint(int n)
{
If (n == 0)
{
Return 0;
}
Else
{
Return (n + mysteryPrint(n-1));
}
}
What will be printed with a call to mysteryPrint(-4)?
A) 0
B) -10
C) -22
D) Nothing - a StackoverflowError exception will occur

Accepted Answer

The method will endlessly recurse until a StackOverflowError occurs because there is no base case for negative values of n.

Question 8

Consider the getArea method from the book shown below.
Public int getArea()
{
If (width <= 0) { return 0; } // line #1
Else if (width == 1) { return 1; } // line #2
Else
{
Triangle smallerTriangle = new Triangle(width - 1); // line #3
Int smallerArea = smallerTriangle.getArea(); // line #4
Return smallerArea + width; // line #5
}
}
Assume lines #1 and #2 were changed to this:
If (width == 1) { return 1; } // new line #1-2
What will happen when this code is executed?
A) A negative or zero width would cause problems.
B) Nothing - the method would still be correct.
C) We would lose our only recursive case.
D) A positive width would reduce the correct area by 1.

Accepted Answer

The answer of Consider the getArea method from the book...

Question 9

What is required to make a recursive method successful?
I special cases that handle the simplest computations directly
II a recursive call to simplify the computation
III a mutual recursion
A) I
B) II
C) I and II
D) I, II, and III

Accepted Answer

To make a recursive method successful, we need to handle special cases that are the simplest computations directly, and then make a recursive call to simplify the computation. Mutual recursion is not always necessary for a successful recursive method, so option III is not needed. Therefore, the correct answer is C (I and II).

Question 10

Consider the following code snippet for calculating Fibonacci numbers recursively:
Int fib(int n)
{
// assumes n >= 0
If (n <= 1)
{
Return n;
}
Else
{
Return (fib(n - 1) + fib(n - 2));
}
}
Identify the terminating condition.
A) n < 1
B) n <= 1
C) fib(n - 1)
D) fib(n - 1) + fib(n - 1)

Accepted Answer

The terminating condition is the base case when n is equal to or less than 1, as the Fibonacci sequence starts with 0 and 1. Therefore, the function should return n when n is 0 or 1, and this is ensured by the condition "n <= 1". Choices A, C, and D do not correctly represent the terminating condition.

Question 11

Consider the recursive method shown below:
Public static int strangeCalc(int bottom, int top)
{
If (bottom > top)
{
Return -1;
}
Else if (bottom == top)
{
Return 1;
}
Else
{
Return bottom * strangeCalc(bottom + 1, top);
}
}
What value will be returned with a call to strangeCalc(4,7)?
A) 1
B) -1
C) 120
D) 840

Accepted Answer

The method multiplies the current bottom value with the result of the same method called with a bottom value incremented by 1 until it reaches the top value. In this case, the method will be called with the parameters (4,7), and it will perform the following calculations:
- strangeCalc(4,7) = 4 * strangeCalc(5,7)
- strangeCalc(5,7) = 5 * strangeCalc(6,7)
- strangeCalc(6,7) = 6 * strangeCalc(7,7)
- strangeCalc(7,7) = 1 (because bottom == top)
Substituting the values, we get:
- strangeCalc(4,7) = 4 * strangeCalc(5,7) = 4 * 5 * strangeCalc(6,7) = 4 * 5 * 6 * strangeCalc(7,7) = 4 * 5 * 6 * 1 = 120.
Therefore, the method will return the value 120.

Question 12

Consider the getArea method from the textbook shown below.
Public int getArea()
{
If (width <= 0) { return 0; } // line #1
Else if (width == 1) { return 1; } // line #2
Else
{
Triangle smallerTriangle = new Triangle(width - 1); // line #3
Int smallerArea = smallerTriangle.getArea(); // line #4
Return smallerArea + width; // line #5
}
}
Where is/are the recursive call(s)?
A) line #1
B) line #2
C) lines #1 and #2
D) line #4

Accepted Answer

The recursive call in this method is in line #4, where it creates a new instance of the Triangle class with a width one less than the current width, and then calls the getArea method on that smaller triangle. This process repeats until the width is 1, at which point the recursion stops and the method returns 1. Therefore, the correct answer is D.

Question 13

Consider the recursive method myPrint:
Public void myPrint(int n)
{
If (n < 10)
{
System.out.print(n);
}
Else
{
Int m = n % 10;
System.out.print(m);
MyPrint(n / 10);
}
}
What is printed for the call myPrint(8)?
A) 10
B) 8
C) 4
D) 21

Accepted Answer

The method first checks if n is less than 10, which is true in the case of myPrint(8). Therefore, it simply prints out the value of n, which is 8.

Question 14

Consider the following recursive code snippet:
Public static int mystery(int n, int m)
{
If (n <= 0)
{
Return 0;
}
If (n == 1)
{
Return m;
}
Return m + mystery(n - 1, m);
}
Identify the terminating condition(s) of method mystery?
A) n <= 0
B) n == 1
C) n <= 0 or n == 1
D) n > 0

Accepted Answer

The terminating condition(s) of the method mystery are n <= 0 or n == 1. If n is less than or equal to 0, the method returns 0. If n is equal to 1, the method returns the value of m. Therefore, either condition will terminate the method and prevent it from continuing its recursive calls.

Question 15

Consider the getArea method from the textbook shown below.
Public int getArea()
{
If (width <= 0) { return 0; } // line #1
Else if (width == 1) { return 1; } // line #2
Else
{
Triangle smallerTriangle = new Triangle(width - 1); // line #3
Int smallerArea = smallerTriangle.getArea(); // line #4
Return smallerArea + width; // line #5
}
}
Where is/are the terminating condition(s)?
A) line #1
B) line #2
C) lines #1 and #2
D) line #4

Accepted Answer

The terminating condition(s) in this code is/are lines #1 and #2. If the width is less than or equal to 0, it will return 0, and if the width is 1, it will return 1. These conditions will prevent the code from entering an infinite recursion loop, ensuring that the code eventually terminates.

Question 16

Consider the code for the recursive method myPrint shown in this code snippet:
Public static int myPrint(int n)
{
If (n == 0)
{
Return 0;
{
Else
{
Return (n + myPrint(n - 1));
}
}
To avoid infinite recursion, which of the following lines of code should replace the current terminating case?
A) if (n == -1)
B) if (n <= 0)
C) if (n >= 0)
D) The terminating case as shown will avoid infinite recursion.

Accepted Answer

The current terminating case is n == 0, which means that the method will keep calling itself recursively until it reaches 0. This will result in infinite recursion if the input is negative.

To avoid this, we need to change the terminating case to something that will handle negative input. The best choice is (B) if (n <= 0), which will terminate the recursion if the input is zero or negative.

Question 17

Consider the recursive method myPrint in this code snippet:
Public void myPrint(int n)
{
If (n < 10)
{
System.out.print(n);
}
Else
{
Int m = n % 10;
System.out.print(m);
MyPrint(n / 10);
}
}
What is printed for the call myPrint(821)?
A) 821
B) 128
C) 12
D) 10

Accepted Answer

When the method myPrint(821) is called, the else block is executed. The integer variable m contains the value 1 because 821 % 10 = 1. The myPrint method is then called recursively, this time with the argument n/10, which is 82. This recursive call will again execute the else block, with m containing the value 2 (82 % 10 = 2), and the method being called recursively again with the argument 8. This final recursive call will trigger the if block, with the integer value 8 being printed. Therefore, the overall output will be 128.

Question 18

Consider the recursive method shown below:
Public static int strangeCalc(int bottom, int top)
{
If (bottom > top)
{
Return -1;
}
Else if (bottom == top)
{
Return 1;
}
Else
{
Return bottom * strangeCalc(bottom + 1, top);
}
}
What value will be returned with a call to strangeCalc(2,3)?
A) 1
B) 2
C) 6
D) 24

Accepted Answer

The answer of Consider the recursive method shown below:
Public static...

Question 19

Consider the following code snippet for recursive addition:
Int add(int i, int j)
{
// assumes i >= 0
If (i == 0)
{
Return j;
}
Else
{
Return add(i - 1, j + 1);
}
}
Identify the terminating condition in this recursive method.
A) if (i == 0)
B) return j
C) return add(i - 1, j + 1)
D) there is no terminating condition

Accepted Answer

The terminating condition in this recursive method is the if statement that checks if i equals 0. If i equals 0, the method returns j and stops the recursion.

Question 20

Consider the getArea method from the textbook shown below.
Public int getArea()
{
If (width <= 0) { return 0; } // line #1
Else if (width == 1) { return 1; } // line #2
Else
{
Triangle smallerTriangle = new Triangle(width - 1); // line #3
Int smallerArea = smallerTriangle.getArea(); // line #4
Return smallerArea + width; // line #5
}
}
Assume line #1 is replaced with this line:
If (width <= 0) {return width;}
What will be the result?
A) The method will still return correct results for all non-negative width triangles.
B) The method will return incorrect results for triangles with width equal to 0.
C) The method will return incorrect results for triangles with width equal to 1.
D) The method will return area to be one too high for all triangles.

Accepted Answer

The answer of Consider the getArea method from the textbook...

Quiz 13: Recursion

Consider the following recursive code snippet: Public int mystery(int n, int m) { If (n == 0) { Return 0; } If (n == 1) { Return m; } Return m + mystery(n - 1, m) ; } What value is returned from a call to mystery(1,5) ?

Complete the code for the recursive method printSum shown in this code snippet, which is intended to return the sum of digits from 1 to n: Public static int printSum(int n) { If (n == 0) { Return 0; } Else { ______________________________ } }

Consider the recursive method myPrint shown in this code snippet: Public void myPrint(int n) { If (n < 10) { System.out.print(n) ; } Else { Int m = n % 10; System.out.print(m) ; MyPrint(n / 10) ; } } What does this method do?

Consider the following recursive code snippet: Public int mystery(int n, int m) { If (n == 0) { Return 0; } If (n == 1) { Return m; } Return m + mystery(n - 1, m) ; } What value is returned from a call to mystery(3,6) ?

Consider the code for the recursive method mysteryPrint shown in this code snippet: Public static int mysteryPrint(int n) { If (n == 0) { Return 0; } Else { Return (n + mysteryPrint(n-1) ) ; } } What will be printed with a call to mysteryPrint(-4) ?

What is required to make a recursive method successful? I special cases that handle the simplest computations directly II a recursive call to simplify the computation III a mutual recursion

Consider the following code snippet for calculating Fibonacci numbers recursively: Int fib(int n) { // assumes n >= 0 If (n <= 1) { Return n; } Else { Return (fib(n - 1) + fib(n - 2) ) ; } } Identify the terminating condition.

Consider the recursive method shown below: Public static int strangeCalc(int bottom, int top) { If (bottom > top) { Return -1; } Else if (bottom == top) { Return 1; } Else { Return bottom * strangeCalc(bottom + 1, top) ; } } What value will be returned with a call to strangeCalc(4,7) ?

Consider the recursive method myPrint: Public void myPrint(int n) { If (n < 10) { System.out.print(n) ; } Else { Int m = n % 10; System.out.print(m) ; MyPrint(n / 10) ; } } What is printed for the call myPrint(8) ?

Consider the following recursive code snippet: Public static int mystery(int n, int m) { If (n <= 0) { Return 0; } If (n == 1) { Return m; } Return m + mystery(n - 1, m) ; } Identify the terminating condition(s) of method mystery?

Consider the code for the recursive method myPrint shown in this code snippet: Public static int myPrint(int n) { If (n == 0) { Return 0; { Else { Return (n + myPrint(n - 1) ) ; } } To avoid infinite recursion, which of the following lines of code should replace the current terminating case?

Consider the recursive method myPrint in this code snippet: Public void myPrint(int n) { If (n < 10) { System.out.print(n) ; } Else { Int m = n % 10; System.out.print(m) ; MyPrint(n / 10) ; } } What is printed for the call myPrint(821) ?

Consider the recursive method shown below: Public static int strangeCalc(int bottom, int top) { If (bottom > top) { Return -1; } Else if (bottom == top) { Return 1; } Else { Return bottom * strangeCalc(bottom + 1, top) ; } } What value will be returned with a call to strangeCalc(2,3) ?

Consider the following code snippet for recursive addition: Int add(int i, int j) { // assumes i >= 0 If (i == 0) { Return j; } Else { Return add(i - 1, j + 1) ; } } Identify the terminating condition in this recursive method.