Recursion vs Iteration When Each Wins in DSA Typescript - Compare & Choose

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Recursive Fibonacci Function

What is the output of this TypeScript code that calculates Fibonacci numbers recursively?

DSA Typescript

function fib(n: number): number {
  if (n <= 1) return n;
  return fib(n - 1) + fib(n - 2);
}
console.log(fib(5));

A 8

B 3

C 13

D 5

💡 Hint

Trace the calls for fib(5): fib(4) + fib(3).

The Fibonacci sequence starts 0,1,1,2,3,5... fib(5) returns 5.

🧠 Conceptual

intermediate

When is Iteration Better Than Recursion?

Which scenario is best suited for iteration instead of recursion?

A When the problem involves simple loops with large input sizes to avoid stack overflow

B When the problem requires exploring all branches of a tree

C When the problem has a small fixed depth and no repeated calculations

D When the problem naturally fits a divide-and-conquer approach

💡 Hint

Think about stack limits and performance with large inputs.

Iteration avoids stack overflow and is efficient for simple loops with large inputs.

🔧 Debug

advanced

Identify the Error in Recursive Factorial

What error will this TypeScript code produce when calculating factorial?

DSA Typescript

function factorial(n: number): number {
  if (n === 0) return 1;
  return n * factorial(n);
}
console.log(factorial(4));

A Returns 1 always

B Returns 24 correctly

C Stack overflow error due to infinite recursion

D Syntax error due to missing return type

💡 Hint

Check the recursive call argument.

The function calls factorial(n) instead of factorial(n-1), causing infinite recursion.

❓ Predict Output

advanced

Output of Iterative vs Recursive Sum

What is the output of this TypeScript code that sums numbers from 1 to 5 using iteration and recursion?

DSA Typescript

function sumIterative(n: number): number {
  let total = 0;
  for (let i = 1; i <= n; i++) {
    total += i;
  }
  return total;
}

function sumRecursive(n: number): number {
  if (n === 0) return 0;
  return n + sumRecursive(n - 1);
}

console.log(sumIterative(5));
console.log(sumRecursive(5));

A 10 and 15

B 15 and 15

C 15 and 10

D 10 and 10

💡 Hint

Sum of numbers 1 to 5 is 15.

Both functions correctly calculate the sum 1+2+3+4+5 = 15.

🧠 Conceptual

expert

Why Use Recursion Over Iteration?

Which reason best explains when recursion is preferred over iteration?

A When the problem is naturally hierarchical or tree-structured and easier to express recursively

B When performance and memory usage must be minimized at all costs

C When the problem involves simple counting loops with no nested calls

D When the language does not support loops

💡 Hint

Think about problem structure and clarity.

Recursion is preferred for problems like tree traversal where the structure fits recursive calls.