recursion quiz

sider the fib method from the textbook shown below. public static long fib(int n) { if (n <= 2) { return 1; } else { return fib(n - 1) + fib(n - 2); } } Calling fib(3) will trigger ___ recursive call(s) and execute the terminating condition ___ time(s), respectively. 1, 1 2, 2 1, 2 2, 1

2,2

The string "eat" has ____ permutations. 2 4 6 8

6

Consider the method powerOfTwo shown below: public boolean powerOfTwo(int n) { if (n == 1) // line #1 { return true; } else if (n % 2 == 1) // line #2 { return false; } else { return powerOfTwo(n / 2); // line #3 } } How many recursive calls are made from the original call powerOfTwo(63) (not including the original call)? 6 4 1 0

0

Consider the recursive version of the fib method from the textbook shown below: public static long fib(int n) { if (n <= 2) { return 1; } else { return fib(n - 1) + fib(n - 2); } } How many more recursive calls to fib will be made from the original call of fib(7) than from the original call of fib(6) (not counting the original calls)? 1 2 5 10

10

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)? 821 128 12 10

128

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)? 1 2 6 24

2

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)? 1 5 6 11

5

Consider the recursive square method shown below that takes a non-negative int argument: public int square(int n) { return square(n, n); } public int square(int c, int n) { if (c == 1) { return n; } else { return n + square(c - 1, n); } } Assume that the last return statement is changed to this: return square(c - 1, n); What would a call to square(7) return? 7 13 14 49

7

How many recursive calls to the fib method shown below would be made from an original call to fib(4)? (Do not count the original call) public int fib(int n) { // assumes n >= 0 if (n <= 1) { return n } else { return (fib(n - 1) + fib(n - 2)); } } 1 2 4 8

8

Which of the following statements about palindromes is correct? The empty string is not a palindrome. The string "I" is not a palindrome. The string "rascal" is a palindrome. All strings of length 0 or 1 are palindromes.

All strings of length 0 or 1 are palindromes.

Which of the following options could be used as a terminating condition for a recursive method that finds the middle character of a String with any number of characters? I the length of the String is 1 II first and last String characters match III the String is not empty I II I, II and III I and III

I

Recursion does NOT take place if any of the following happen: I method A calls method B, which calls method C, which calls method B II method A calls method B, which calls method A III method A calls method B, B returns, and A calls B again I I and II II III

III

Which of the following statements about recursion is correct? It is not necessary to have a special terminating case in all recursions. It is not necessary to simplify the argument in the recursive call. A recursive solution will always run faster than an equivalent iterative solution. In many cases, a recursive solution will be easier to understand and to implement than an iterative solution.

In many cases, a recursive solution will be easier to understand and to implement than an iterative solution.

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 } Assume that line #2 is changed to this: if (width == 1) { return 2; } How would this affect calls to getArea? It would add 1 to all calls except those where width <= 0. It would make no difference to any call. It would double every triangle area. It would subtract 1 from all calls.

It would add 1 to all calls except those where width <= 0.

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)? 0 -10 -22 Nothing - a StackoverflowError exception will occur

Nothing - a StackoverflowError exception will occur

A palindrome is a word or phrase that reads the same forward or backward. Consider the following code snippet: public boolean palindrome(String string) { return isPal(string, 0, string.length() - 1); } private boolean isPal(String string, int left, int right) { if (left >= right) { return true; } else if (string.charAt(left) == string.charAt(right)) { return isPal(string, left + 1, right - 1); } else { return false; } } What is the purpose of the palindrome method? Return the palindrome to the calling method. Provide the string, along with its first and last indexes to the recursive isPal method. Send the recursive isPal method its terminating condition. Recursively call itself.

Provide the string, along with its first and last indexes to the recursive isPal method.

What is the purpose of a recursive helper method? Shield the user of the recursive method from the recursive details. Speed up the execution. Eliminate the recursion. Add another base case.

Shield the user of the recursive method from the recursive details.

Consider the getArea method from the textbook shown below: public int getArea() { if (width <= 0) { return 0; } // line #1 Triangle smallerTriangle = new Triangle(width - 1); // line #2 int smallerArea = smallerTriangle.getArea(); // line #3 return smallerArea + width; // line #4 } If line#1 was removed, what would be the result? The recursive method would cause an exception for values below 0. The recursive method would construct triangles whose width was negative. The recursive method would terminate when the width reached 0. The recursive method would correctly calculate the area of the original triangle.

The recursive method would construct triangles whose width was negative.

Consider the fib method from the textbook shown below: public static long fib(int n) { if (n <= 2) { return 1; // line #1 } else { return fib(n - 1) + fib(n - 2); // line #2 } } Assume line #1 is changed to this: if (n <= 2) { return n; } What effect will this change have? This will return 21 from fib(6) This will return 13 from fib(6) This will return 8 from fib(6) This will return 6 from fib(6)

This will return 13 from fib(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? Those with width equal to 0. Those with width equal to 1. Those with width greater than or equal to 2. Triangles of any width.

Those with width greater than or equal to 2.

____ is a problem-solving technique that examines partial solutions, abandons unsuitable ones, and returns to consider other candidate solutions. Debugging Traceback Backtracking Recursion

backtracking

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) line 1 and 2 d) line 4

d) line 4

Complete the code for the calcPower recursive method shown below, which is intended to raise the base number passed into the method to the exponent power passed into the method: public static int calcPower(int baseNum, int exponent) { int answer = 0; ________________________ { answer = 1; } else { answer = baseNum * calcPower (baseNum, exponent - 1); } return answer; } if (exponent == 0) if (exponent == 1) if (exponent == -1) if (exponent != 1)

if (exponent == 0)

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. if (i == 0) return j return add(i - 1, j + 1) there is no terminating condition

if (i == 0)

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? n <= 0 n == 1 n <= 0 or n == 1 n > 0

n <= 0 or n == 1

A recursive method without a special terminating case would _________ end immediately. not be recursive. be more efficient. never terminate.

never terminate

Complete the following code snippet, which is intended to be a recursive method that reverses a String value: public static String reverseIt(String s) { if (s.length() <= 1) { return s; } else { ________________________ } } return reverseIt(s.substring(0)) + s.charAt(1); return reverseIt(s.substring(0)) + s.charAt(0); return reverseIt(s.substring(1)) + s.charAt(1); return reverseIt(s.substring(1)) + s.charAt(0);

return reverseIt(s.substring(1)) + s.charAt(0);

Complete the following code snippet, which is intended to be a recursive method that reverses a String value: public static String reverseIt(String s) { if (s.length() <= 1) { _________ } else { return reverseIt(s.substring(1)) + s.charAt(0); } } return s; return 0; return s.charAt(0); return s.substring(1);

return s;

Backtracking _____. starts from the end of the program and works backward to the beginning. starts with a partial solution and builds it up to get closer to the goal. never abandons a partial solution. explores only one path toward a solution

starts with a partial solution and builds it up to get closer to the goal.

In recursion, the terminating condition is analogous to a loop _________. call iteration termination condition initialization condition

termination condition