Question 1

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 when n is less than or equal to 1. This is because the function returns n when n is less than or equal to 1, and this is the only way the function can terminate.

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

The correct choice is C because it correctly adds the current number `n` to the sum of numbers from 1 to `n-1` using recursion.

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 prints the digits of a positive integer in reverse order by recursively processing the last digit first.

Question 4

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 returns the product of the numbers from bottom to top, inclusive. In this case, the product is 4 * 5 * 6 * 7 = 120.

Question 5

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 would cause infinite recursion for triangles with width greater than or equal to 2 because the new Triangle object created in line #3 would have the same width as the original Triangle object, and the getArea method would be called recursively on the new Triangle object with the same width.

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
}
}
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 occurs in line #4 where the method getArea() is called on a smaller instance of Triangle.

Question 7

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

The method prints the last digit first and then recursively calls itself with the rest of the number, effectively reversing the digits. For 821, it prints 1, then 2, then 8, resulting in 128.

Question 8

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 conditions are in lines #1 and #2, where the method returns a value without further recursive calls.

Question 9

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 10

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...

Question 11

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 method terminates when either n <= 0 or n == 1, as these conditions return a value without further recursive calls.

Question 12

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...

Question 13

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 condition `if (n <= 0)` ensures that the recursion stops when `n` is zero or negative, preventing infinite recursion.

Question 14

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 15

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 function mystery(n, m) calculates n * m using recursion. For mystery(3, 6), it computes 6 + 6 + 6, which equals 18.

Question 16

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 is "if (i == 0)" because it stops the recursion by returning a value without making another recursive call.

Question 17

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

A successful recursive method requires special cases (base cases) to handle the simplest computations directly and a recursive call to simplify the computation by breaking it down into smaller instances of the same problem. Mutual recursion is not necessary for a single recursive method.

Question 18

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 19

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 checks if n is less than 10, and since 8 is less than 10, it directly prints 8.

Question 20

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 does not handle negative numbers, leading to infinite recursion and eventually a StackOverflowError.

Quiz 13: 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.

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 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 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 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 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 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 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) ?

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 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.

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 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 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) ?