Why Dynamic Programming and When Recursion Alone Fails in DSA Java - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the base case for the Fibonacci recursion.

DSA Java

if (n == [1]) return n;

Drag options to blanks, or click blank then click option'

A1

B0

C2

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 as base case instead of 0

No base case causing infinite recursion

The base case for Fibonacci recursion is when n is 0, return 0.

2fill in blank

medium

Complete the code to recursively calculate Fibonacci numbers.

DSA Java

return fibonacci(n - 1) [1] fibonacci(n - 2);

Drag options to blanks, or click blank then click option'

A-

B/

C*

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition

Fibonacci numbers are the sum of the two previous numbers.

3fill in blank

hard

Fix the error in the recursive Fibonacci method to avoid repeated calculations.

DSA Java

if (memo[n] != [1]) return memo[n];

Drag options to blanks, or click blank then click option'

A-1

Bnull

C0

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for 0 or null which may be valid Fibonacci values

We use -1 to indicate that the Fibonacci number for n is not yet calculated.

4fill in blank

hard

Fill both blanks to implement memoization in Fibonacci recursion.

DSA Java

memo[n] = fibonacci([1]) [2] fibonacci(n - 2);

Drag options to blanks, or click blank then click option'

An - 1

B+

C-

D*

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition

Wrong index in recursive call

Memoization stores the sum of fibonacci(n-1) and fibonacci(n-2) in memo[n].

5fill in blank

hard

Fill all three blanks to create a bottom-up dynamic programming Fibonacci solution.

DSA Java

for (int i = [1]; i <= n; i++) {
    dp[i] = dp[i - [2]] [3] dp[i - 2];
}

Drag options to blanks, or click blank then click option'

A2

B1

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Starting loop at 1

Using subtraction instead of addition

Start loop from 2, use dp[i-1] + dp[i-2] to fill dp array bottom-up.

Practice

1. Why do we use dynamic programming instead of plain recursion for some problems?

easy

A. Because recursion always causes errors in large inputs

B. Because recursion cannot solve problems with loops

C. Because dynamic programming uses less memory than recursion

D. Because recursion alone can repeat calculations, making it slow

Solution

1. Step 1: Understand recursion's limitation

   Recursion solves problems by calling itself but often recalculates the same subproblems multiple times.

2. Step 2: How dynamic programming helps

   Dynamic programming stores results of subproblems to avoid repeated work, making it faster.

3. Final Answer:

   Because recursion alone can repeat calculations, making it slow -> Option D

4. Quick Check:

   Recursion repeats work, DP avoids it [OK]

Hint: DP saves repeated work recursion does [OK]

Common Mistakes:

• Thinking recursion always uses less memory
• Believing recursion cannot handle loops
• Assuming recursion always causes errors

2. Which of the following Java method signatures correctly represents a recursive function for Fibonacci numbers?

easy

A. public int fibonacci(int n) { while (n > 1) return fibonacci(n-1) + fibonacci(n-2); }

B. public void fibonacci(int n) { if (n <= 1) return n; return fibonacci(n-1) + fibonacci(n-2); }

C. public int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n-1) + fibonacci(n-2); }

D. public int fibonacci(int n) { if (n == 0) return 0; else return fibonacci(n-1) + fibonacci(n-2); }

Solution

1. Step 1: Check return type and base case

   public int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n-1) + fibonacci(n-2); } returns int and has base case for n <= 1, which is correct for Fibonacci.

2. Step 2: Identify syntax correctness

   public void fibonacci(int n) { if (n <= 1) return n; return fibonacci(n-1) + fibonacci(n-2); } has void return type but tries to return int, which is invalid. public int fibonacci(int n) { if (n == 0) return 0; else return fibonacci(n-1) + fibonacci(n-2); } misses base case for n == 1. public int fibonacci(int n) { while (n > 1) return fibonacci(n-1) + fibonacci(n-2); } uses while incorrectly.

3. Final Answer:

   public int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n-1) + fibonacci(n-2); } -> Option C

4. Quick Check:

   Correct return and base case = public int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n-1) + fibonacci(n-2); } [OK]

Hint: Check return type and base cases carefully [OK]

Common Mistakes:

• Using void return type but returning a value
• Missing base case for n=1
• Using loops incorrectly inside recursion

3. What is the output of this Java code snippet?

public class Test {
  public static int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2);
  }
  public static void main(String[] args) {
    System.out.println(fib(5));
  }
}

medium

A. 3

B. 5

C. 8

D. 13

Solution

1. Step 1: Trace fib(5) calls

   fib(5) = fib(4) + fib(3), fib(4) = 3, fib(3) = 2, so fib(5) = 3 + 2 = 5.

2. Step 2: Confirm final output

   System.out.println prints 5.

3. Final Answer:

   5 -> Option B

4. Quick Check:

   fib(5) = 5 [OK]

Hint: Recall Fibonacci sequence: 0,1,1,2,3,5... [OK]

Common Mistakes:

• Confusing fib(5) with fib(6)
• Miscounting base cases
• Assuming output is sum of all calls

4. Identify the error in this recursive Java method for factorial:

public int factorial(int n) {
  if (n == 0) return 1;
  else return n * factorial(n);
}

medium

A. Recursive call uses same n, causing infinite recursion

B. Missing base case for n == 1

C. Return type should be void

D. Factorial of 0 should return 0

Solution

1. Step 1: Analyze recursive call parameter

   The method calls factorial(n) again without reducing n, causing infinite recursion.

2. Step 2: Correct recursive call

   It should call factorial(n-1) to reduce n and reach base case.

3. Final Answer:

   Recursive call uses same n, causing infinite recursion -> Option A

4. Quick Check:

   Recursive call must reduce n [OK]

Hint: Check recursive call parameter changes [OK]

Common Mistakes:

• Not reducing n in recursive call
• Wrong base case return value
• Incorrect return type

5. You want to find the nth Fibonacci number efficiently. Which approach best avoids the problem of repeated calculations in recursion?

hard

A. Use recursion with memoization to store results of subproblems

B. Use plain recursion with no extra storage

C. Use iteration with a loop to build up from base cases

D. Use a random number generator to guess the value

Solution

1. Step 1: Understand repeated calculations in recursion

   Plain recursion recalculates the same Fibonacci numbers many times, causing slow performance.

2. Step 2: How memoization helps

   Memoization stores results of subproblems so each is computed once, speeding up recursion.

3. Step 3: Compare with iteration

   Iteration also avoids repeated work but memoization keeps recursion style with efficiency.

4. Final Answer:

   Use recursion with memoization to store results of subproblems -> Option A

5. Quick Check:

   Memoization avoids repeats in recursion [OK]

Hint: Memoize recursive calls to avoid repeats [OK]

Common Mistakes:

• Using plain recursion without memoization
• Thinking iteration is the only efficient way
• Ignoring memoization benefits