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

Practice - 5 Tasks

1fill in blank

easy

Complete the code to calculate factorial using recursion.

DSA Typescript

function factorial(n: number): number {
  if (n === 0) {
    return 1;
  }
  return n * factorial([1]);
}

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

An + 1

B1

Cn - 1

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Using n + 1 causes infinite recursion.

Using n directly causes infinite recursion.

The recursive call must reduce the problem size by 1 each time, so n - 1 is correct.

2fill in blank

medium

Complete the code to calculate factorial using iteration.

DSA Typescript

function factorialIter(n: number): number {
  let result = 1;
  for (let i = 1; i <= [1]; i++) {
    result *= i;
  }
  return result;
}

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

Aresult

Bn

Ci

Dn - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using n - 1 excludes n from multiplication.

Using i or result in the condition causes errors.

The loop runs from 1 up to n, so the condition should be i <= n.

3fill in blank

hard

Fix the error in the recursive Fibonacci function to avoid infinite recursion.

DSA Typescript

function fib(n: number): number {
  if (n <= 1) {
    return n;
  }
  return fib([1]) + fib(n - 2);
}

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

A1

Bn + 1

Cn

Dn - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using n + 1 causes infinite recursion.

Using n directly causes infinite recursion.

The Fibonacci function calls fib(n-1) and fib(n-2) to reduce problem size correctly.

4fill in blank

hard

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

DSA Typescript

function sumToN(n: number): number {
  if (n === 0) {
    return 0;
  }
  return n [1] sumToN([2]);
}

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

A+

B-

Cn - 1

Dn + 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction instead of addition causes wrong results.

Using n + 1 causes infinite recursion.

To sum numbers from n down to 1, add n to sumToN(n - 1).

5fill in blank

hard

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

DSA Typescript

function reverseString(str: string): string {
  let reversed = '';
  for (let i = [1]; i [2] -1; i[3]) {
    reversed += str[i];
  }
  return reversed;
}

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

Astr.length - 1

B>

C--

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Starting from 0 and incrementing causes no reversal.

Using '<' instead of '>' causes empty result.

The loop starts from the last index (length - 1), continues while i > -1, and decrements i each time.

Practice

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

easy

A. When the problem requires simple repeated loops

B. When you want to avoid function call overhead

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

D. When memory usage must be minimal

Solution

1. Step 1: Understand recursion vs iteration use cases

   Recursion works well when a problem can be broken down into smaller, similar subproblems, like tree traversals or factorial calculation. Iteration is better for simple repeated tasks without nested subproblems, and it avoids function call overhead.

2. Final Answer:

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

3. Quick Check:

   Recursion = divide and conquer [OK]

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

Common Mistakes:

• Thinking iteration is always faster
• Ignoring function call overhead in recursion
• Confusing recursion with simple loops

2. Which of the following is the correct syntax to write a recursive function in TypeScript?

easy

A. function recurse(n: number): number { if (n <= 1) return 1; return n * recurse(n - 1); }

B. function recurse(n: number): number { while (n > 1) { n--; } return n; }

C. function recurse(n: number): number { for (let i = 0; i < n; i++) { return i; } }

D. function recurse(n: number): number { if (n == 0) return 0; else return n + 1; }

Solution

1. Step 1: Identify recursive call and base case

   function recurse(n: number): number { if (n <= 1) return 1; return n * recurse(n - 1); }: function recurse(n: number): number { if (n <= 1) return 1; return n * recurse(n - 1); } calls itself inside the function with a smaller argument (n-1) and has a base case (n <= 1) to stop recursion.

2. Final Answer:

   function recurse(n: number): number { if (n <= 1) return 1; return n * recurse(n - 1); } -> Option A

3. Quick Check:

   Recursive function must call itself with smaller input [OK]

Hint: Look for function calling itself with smaller input [OK]

Common Mistakes:

• Missing base case causing infinite recursion
• Using loops instead of recursive calls
• Returning inside a loop without recursion

3. What will be the output of the following TypeScript code?

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

medium

A. 10

B. 24

C. 16

D. Error

Solution

1. Step 1: Trace recursive calls for factorial(4)

   factorial(4) calls factorial(3), which calls factorial(2), which calls factorial(1)=1. Then: factorial(2)=2*1=2, factorial(3)=3*2=6, factorial(4)=4*6=24. Output: 24.

2. Final Answer:

   24 -> Option B

3. Quick Check:

   4! = 24 [OK]

Hint: Factorial n! = n * (n-1)! [OK]

Common Mistakes:

• Confusing factorial with sum
• Forgetting base case returns 1
• Miscounting recursive calls

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

function sumToN(n: number): number {
  return n + sumToN(n - 1);
}

medium

A. Add a base case to stop recursion when n <= 0

B. Change return to console.log to print values

C. Replace recursion with a for loop

D. Remove the parameter n

Solution

1. Step 1: Identify and fix the missing base case

   The function calls itself without a stopping condition, causing infinite recursion and stack overflow. Add if (n <= 0) return 0; to stop recursion when n <= 0.

2. Final Answer:

   Add a base case to stop recursion when n <= 0 -> Option A

3. Quick Check:

   Base case prevents infinite recursion [OK]

Hint: Always add base case to recursive functions [OK]

Common Mistakes:

• Forgetting base case causes infinite recursion
• Trying to fix by removing parameters
• Confusing printing with returning

5. You need to process a large dataset with a depth of 10,000 levels. Which approach is better and why?

Options:
A) Use recursion because it is easier to write.
B) Use recursion with no base case.
C) Use iteration to avoid stack overflow errors.
D) Use iteration but with no loop control.

hard

A. Use recursion because it is easier to write.

B. Use recursion with no base case.

C. Use iteration but with no loop control.

D. Use iteration to avoid stack overflow errors.

Solution

1. Step 1: Analyze stack limits for deep recursion

   Recursion uses the call stack, which has limited size. Depth of 10,000 risks stack overflow. Iteration uses loops without adding to call stack, safely handling large depths.

2. Final Answer:

   Use iteration to avoid stack overflow errors. -> Option D

3. Quick Check:

   Deep tasks need iteration to prevent stack overflow [OK]

Hint: Deep recursion risks stack overflow; prefer iteration [OK]

Common Mistakes:

• Assuming recursion always better for readability
• Ignoring stack size limits
• Using recursion without base case