Recursion vs Iteration When Each Wins in DSA Go - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to calculate factorial using recursion.

DSA Go

func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial([1])
}

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

An+1

B1

C0

Dn-1

Attempts:

3 left

💡 Hint

Common Mistakes

Using n+1 causes infinite recursion.

Returning 0 ends recursion incorrectly.

The factorial of n is n multiplied by factorial of n-1.

2fill in blank

medium

Complete the code to calculate factorial using iteration.

DSA Go

func factorialIter(n int) int {
    result := 1
    for i := 1; i <= [1]; i++ {
        result *= i
    }
    return result
}

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

An-1

Bn

Ci

Dresult

Attempts:

3 left

💡 Hint

Common Mistakes

Using n-1 misses the last multiplication.

Using i or result as loop limit is incorrect.

The loop runs from 1 to n to multiply all numbers for factorial.

3fill in blank

hard

Fix the error in the recursive Fibonacci function by completing the blank.

DSA Go

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

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

An+1

Bn-1

Cn-2

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using n-1 twice causes infinite recursion.

Using n+1 causes wrong results.

Fibonacci is sum of fib(n-1) and fib(n-2).

4fill in blank

hard

Fill both blanks to create a recursive function that sums numbers from 1 to n.

DSA Go

func sumToN(n int) int {
    if n == 0 {
        return 0
    }
    return n [1] sumToN([2])
}

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

A+

Bn-1

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using multiplication or division is incorrect here.

Not reducing n causes infinite recursion.

The function adds n to the sum of numbers up to n-1.

5fill in blank

hard

Fill all three blanks to create an iterative function that reverses a string.

DSA Go

func reverse(s string) string {
    result := ""
    for i := len(s) - 1; i >= [1]; i[2] {
        result += string(s[i])
    }
    return [3]
}

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

A0

B--

Cresult

Dlen(s)

Attempts:

3 left

💡 Hint

Common Mistakes

Using len(s) as lower bound causes no iterations.

Using ++ instead of -- causes infinite loop.

The loop starts from the last index and goes down to 0, appending characters to result.

Practice

1. Which situation is best suited for using recursion instead of iteration?

easy

A. When the problem can be divided into similar smaller problems

B. When you want to avoid function calls

C. When you need to use less memory

D. When the problem has a fixed number of steps

Solution

1. Step 1: Understand recursion use case

   Recursion works well when a problem can be broken down into smaller similar problems, like factorial or tree traversal.

2. Step 2: Compare with iteration

   Iteration is better for fixed steps or simple loops, but recursion shines in divide-and-conquer problems.

3. Final Answer:

   When the problem can be divided into similar smaller problems -> Option A

4. Quick Check:

   Recursion = divide and conquer [OK]

Hint: Recursion fits problems breaking into smaller similar parts [OK]

Common Mistakes:

• Thinking recursion always uses less memory
• Believing iteration is always faster
• Confusing fixed steps with recursive breakdown

2. Which of the following is the correct syntax for a recursive function in Go?

easy

A. func factorial(n int) int { if n == 0 { return 0 } return n * factorial(n-1) }

B. func factorial(n int) { if n == 0 { return 1 } return n * factorial(n-1) }

C. func factorial(n int) int { for n > 0 { return n * factorial(n-1) } return 1 }

D. func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) }

Solution

1. Step 1: Check function signature and return type

   func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) } correctly defines factorial with int input and int return type.

2. Step 2: Verify base case and recursive call

   func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) } returns 1 when n is 0 and calls factorial(n-1) correctly.

3. Final Answer:

   func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) } -> Option D

4. Quick Check:

   Correct recursion syntax = func factorial(n int) int { if n == 0 { return 1 } return n * factorial(n-1) } [OK]

Hint: Look for correct return type and base case in recursion [OK]

Common Mistakes:

• Missing return type in function signature
• Incorrect base case return value
• Using loop inside recursive function incorrectly

3. What is the output of the following Go code?

import "fmt"

func sum(n int) int {
    if n == 0 {
        return 0
    }
    return n + sum(n-1)
}

func main() {
    fmt.Println(sum(3))
}

medium

A. Error

B. 6

C. 0

D. 3

Solution

1. Step 1: Trace recursive calls for sum(3)

   sum(3) = 3 + sum(2), sum(2) = 2 + sum(1), sum(1) = 1 + sum(0), sum(0) = 0.

2. Step 2: Calculate total sum

   sum(3) = 3 + 2 + 1 + 0 = 6.

3. Final Answer:

   6 -> Option B

4. Quick Check:

   Sum 1 to 3 = 6 [OK]

Hint: Add numbers down to zero recursively [OK]

Common Mistakes:

• Forgetting base case returns 0
• Adding instead of subtracting in recursion
• Expecting output 3 instead of sum

4. Identify the error in this iterative factorial function in Go and fix it:

func factorial(n int) int {
    result := 1
    for i := 1; i <= n; i++ {
        result = result + i
    }
    return result
}

medium

A. Initialize result to 0 instead of 1

B. Change loop to decrement i

C. Change '+' to '*' in result update

D. Add base case for n == 0

Solution

1. Step 1: Analyze the loop operation

   The loop adds i to result instead of multiplying, so it calculates sum not factorial.

2. Step 2: Fix the operation to multiplication

   Change 'result = result + i' to 'result = result * i' to compute factorial correctly.

3. Final Answer:

   Change '+' to '*' in result update -> Option C

4. Quick Check:

   Factorial uses multiplication, not addition [OK]

Hint: Factorial multiplies all numbers, not adds [OK]

Common Mistakes:

• Using addition instead of multiplication
• Not initializing result to 1
• Looping backwards unnecessarily

5. You want to process a large tree structure with unknown depth. Which approach is better and why?

Options:
A) Use iteration with an explicit stack to avoid stack overflow.
B) Use recursion for simplicity but risk stack overflow.
C) Use recursion with tail call optimization to save memory.
D) Use iteration with multiple nested loops for clarity.

hard

A. Use iteration with an explicit stack to avoid stack overflow.

B. Use recursion for simplicity but risk stack overflow.

C. Use recursion with tail call optimization to save memory.

D. Use iteration with multiple nested loops for clarity.

Solution

1. Step 1: Understand recursion limits on large unknown depth

   Recursion can cause stack overflow if the tree is very deep because each call uses stack memory.

2. Step 2: Use iteration with explicit stack to control memory

   Iteration with a manual stack simulates recursion but avoids system stack overflow, making it safer for large trees.

3. Final Answer:

   Use iteration with an explicit stack to avoid stack overflow. -> Option A

4. Quick Check:

   Iteration + explicit stack = safe deep tree traversal [OK]

Hint: Use iteration with stack to handle deep recursion safely [OK]

Common Mistakes:

• Assuming recursion always safe for deep trees
• Believing Go supports tail call optimization
• Using nested loops for unknown depth structures