Why Dynamic Programming and When Recursion Alone Fails in DSA Go - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Recursive Fibonacci Without Memoization

What is the output of this Go program that calculates Fibonacci numbers using simple recursion without any optimization?

DSA Go

package main
import "fmt"

func fib(n int) int {
    if n <= 1 {
        return n
    }
    return fib(n-1) + fib(n-2)
}

func main() {
    fmt.Println(fib(5))
}

A 13

B 8

C 5

D 3

💡 Hint

Remember the Fibonacci sequence starts with 0, 1, 1, 2, 3, 5...

The function fib(5) returns the 5th Fibonacci number starting from 0. The sequence is 0,1,1,2,3,5, so fib(5) = 5.

🧠 Conceptual

intermediate

Why Does Simple Recursion Fail for Large Fibonacci Numbers?

Why does using simple recursion without any optimization fail or become inefficient for calculating large Fibonacci numbers?

A Because recursion always uses more memory than iteration.

B Because recursion cannot handle numbers larger than 10.

C Because Go does not support recursion for Fibonacci calculations.

D Because it recalculates the same values many times, causing exponential time complexity.

💡 Hint

Think about how many times fib(3) is calculated when calling fib(5).

Simple recursion recalculates the same Fibonacci numbers multiple times, leading to exponential growth in calls and slow performance.

❓ Predict Output

advanced

Output of Fibonacci with Memoization in Go

What is the output of this Go program that calculates Fibonacci numbers using recursion with memoization (caching results)?

DSA Go

package main
import "fmt"

var memo = map[int]int{}

func fib(n int) int {
    if n <= 1 {
        return n
    }
    if val, ok := memo[n]; ok {
        return val
    }
    memo[n] = fib(n-1) + fib(n-2)
    return memo[n]
}

func main() {
    fmt.Println(fib(10))
}

A 89

B 55

C 34

D 144

💡 Hint

Recall the 10th Fibonacci number starting from 0 is 55.

Memoization stores previously calculated Fibonacci numbers, so fib(10) returns 55 efficiently.

🔧 Debug

advanced

Identify the Error in Recursive Fibonacci Without Memoization

What error will this Go code produce when calculating fib(-1)?

DSA Go

package main
import "fmt"

func fib(n int) int {
    if n == 0 || n == 1 {
        return n
    }
    return fib(n-1) + fib(n-2)
}

func main() {
    fmt.Println(fib(-1))
}

A Stack overflow due to infinite recursion

B Output: -1

C Compile-time error: invalid function call

D Output: 0

💡 Hint

Check what happens when n is negative in the recursive calls.

Since fib(-1) does not hit the base case properly, it calls fib(-2) and fib(-3) endlessly, causing stack overflow.

🧠 Conceptual

expert

Why Dynamic Programming is Preferred Over Simple Recursion for Overlapping Subproblems

Which statement best explains why dynamic programming is preferred over simple recursion when solving problems with overlapping subproblems?

A Dynamic programming stores results of subproblems to avoid repeated calculations, improving efficiency.

B Dynamic programming uses loops instead of recursion, which is always faster.

C Simple recursion cannot solve problems with overlapping subproblems.

D Dynamic programming always uses less memory than recursion.

💡 Hint

Think about how caching results helps avoid repeated work.

Dynamic programming saves results of subproblems (memoization or tabulation) to prevent recalculating them, making it efficient for overlapping subproblems.

Practice

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

easy

A. Because dynamic programming uses less memory than recursion

B. Because dynamic programming stores results to avoid repeated work

C. Because recursion cannot solve problems with multiple choices

D. Because recursion is always slower than loops

Solution

1. Step 1: Understand recursion's limitation

   Recursion often recalculates the same subproblems multiple times, causing inefficiency.

2. Step 2: Role of dynamic programming

   Dynamic programming saves results of subproblems (memoization) to avoid repeated calculations.

3. Final Answer:

   Because dynamic programming stores results to avoid repeated work -> Option B

4. Quick Check:

   Memoization avoids repeated work = D [OK]

Hint: Dynamic programming saves repeated results to speed up recursion [OK]

Common Mistakes:

• Thinking recursion is always slower than loops
• Believing recursion can't handle multiple choices
• Confusing memory use between recursion and DP

2. Which Go syntax correctly declares a recursive function to compute Fibonacci numbers?

easy

A. func fib(n int) int { if n <= 1 { return n } return fib(n-1) + fib(n-2) }

B. func fib(n int) { if n <= 1 { return n } return fib(n-1) + fib(n-2) }

C. func fib(n int) int { if n < 0 { return 0 } return fib(n-1) + fib(n-2) }

D. func fib(n int) int { if n == 0 { return 0 } else { return fib(n-1) + fib(n-2) } }

Solution

1. Step 1: Check function signature and return type

   func fib(n int) int { if n <= 1 { return n } return fib(n-1) + fib(n-2) } correctly declares return type int and returns int values.

2. Step 2: Verify base cases and recursion

   func fib(n int) int { if n <= 1 { return n } return fib(n-1) + fib(n-2) } uses base case n <= 1 returning n, and recursive calls fib(n-1)+fib(n-2), which is correct.

3. Final Answer:

   func fib(n int) int { if n <= 1 { return n } return fib(n-1) + fib(n-2) } -> Option A

4. Quick Check:

   Correct signature and base case = B [OK]

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

Common Mistakes:

• Missing return type in function signature
• Incorrect base case conditions
• Returning void instead of int

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

import "fmt"

func fib(n int) int {
    if n <= 1 {
        return n
    }
    return fib(n-1) + fib(n-2)
}

func main() {
    fmt.Println(fib(5))
}

medium

A. 13

B. 8

C. 5

D. Error

Solution

1. Step 1: Trace fib(5) calls

   fib(5) = fib(4) + fib(3), fib(4) = fib(3) + fib(2), fib(3) = fib(2) + fib(1), etc.

2. Step 2: Calculate values bottom-up

   fib(0)=0, fib(1)=1, fib(2)=1, fib(3)=2, fib(4)=3, fib(5)=5

3. Final Answer:

   5 -> Option C

4. Quick Check:

   Fibonacci(5) = 5 [OK]

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

Common Mistakes:

• Confusing fib(5) with fib(6)
• Off-by-one errors in base cases
• Assuming output is sum of first 5 numbers

4. Identify the bug in this recursive Fibonacci function and choose the fix:

func fib(n int) int {
    if n == 0 {
        return 0
    } else if n == 1 {
        return 1
    }
    return fib(n-1) + fib(n-3)
}

medium

A. Change return type to float64

B. Change base case n == 0 to n <= 0

C. Add memoization to store results

D. Change fib(n-3) to fib(n-2) in the return statement

Solution

1. Step 1: Analyze recursive calls

   Function calls fib(n-1) + fib(n-3), but Fibonacci requires fib(n-1) + fib(n-2).

2. Step 2: Correct the recursive call

   Changing fib(n-3) to fib(n-2) fixes the logic to standard Fibonacci recursion.

3. Final Answer:

   Change fib(n-3) to fib(n-2) in the return statement -> Option D

4. Quick Check:

   Correct recursion calls = A [OK]

Hint: Fibonacci sums fib(n-1) and fib(n-2) only [OK]

Common Mistakes:

• Using wrong recursive indices
• Ignoring base cases
• Adding memoization without fixing recursion

5. You want to compute the nth Fibonacci number efficiently in Go. Which approach best avoids the exponential time of plain recursion?

hard

A. Use dynamic programming with memoization to store intermediate results

B. Use a tail-recursive version of Fibonacci

C. Use recursion with a global variable to count calls

D. Use recursion with multiple goroutines to parallelize calls

Solution

1. Step 1: Understand recursion inefficiency

   Plain recursion recalculates subproblems exponentially many times, causing slow performance.

2. Step 2: Compare approaches to optimize

   Memoization stores results to avoid repeated work, reducing time to linear - classic DP approach.

3. Step 3: Evaluate other options

   Global variable counting calls doesn't improve speed. Parallel recursion adds overhead and complexity without guaranteed speedup.

4. Final Answer:

   Use dynamic programming with memoization to store intermediate results -> Option A

5. Quick Check:

   Memoization avoids repeated work = C [OK]

Hint: Memoize results to avoid repeated recursion calls [OK]

Common Mistakes:

• Thinking parallel recursion always speeds up
• Using global counters instead of caching
• Thinking tail recursion avoids exponential time