Factorial Using Recursion in DSA Typescript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this factorial function call?

Consider the following TypeScript code that calculates factorial using recursion. What will be printed when calling factorial(4)?

DSA Typescript

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

console.log(factorial(4));

A 24

B 10

C 120

D 6

💡 Hint

Remember factorial of n is n * factorial of (n-1), and factorial of 0 is 1.

The factorial of 4 is 4 * 3 * 2 * 1 = 24. The function calls itself reducing n by 1 until it reaches 0, then returns 1.

❓ Predict Output

intermediate

What is the output of factorial(0)?

Using the same factorial function, what will be printed when calling factorial(0)?

DSA Typescript

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

console.log(factorial(0));

A Error

B 0

C undefined

D 1

💡 Hint

Factorial of zero is defined as 1.

The base case returns 1 when n is 0, so factorial(0) returns 1.

🔧 Debug

advanced

What error does this factorial function cause?

Examine this factorial function. What error will occur when calling factorial(0)?

DSA Typescript

function factorial(n: number): number {
  if (n === 1) {
    return 1;
  }
  return n * factorial(n - 1);
}

console.log(factorial(0));

A Returns 6

B Returns 0

C Stack overflow error

D Syntax error

💡 Hint

Check the base case condition and what happens when n reaches 0.

The base case stops recursion only when n is 1. When n reaches 0, the function calls factorial(-1), then factorial(-2), and so on, causing infinite recursion and stack overflow.

🧠 Conceptual

advanced

How many times is factorial called when factorial(5) is executed?

Using the standard recursive factorial function, how many total calls to factorial are made when calculating factorial(5)?

DSA Typescript

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

factorial(5);

A 5

B 6

C 4

D 1

💡 Hint

Count the initial call plus all recursive calls until base case.

The calls are factorial(5), factorial(4), factorial(3), factorial(2), factorial(1), factorial(0). Total 6 calls.

🚀 Application

expert

What is the output of this modified factorial function?

This factorial function prints the current value of n before the recursive call. What is the output when calling factorial(3)?

DSA Typescript

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

factorial(3);

A [3, 2, 1]

B [1, 2, 3]

C [3, 2, 1, 0]

D [0, 1, 2, 3]

💡 Hint

The function prints before calling itself with n-1.

The function prints n starting from 3 down to 1 before reaching base case 0 which does not print.

Practice

1. What does the factorial of a number represent in mathematics?

easy

A. The product of all positive integers up to that number

B. The sum of all positive integers up to that number

C. The number multiplied by 2

D. The number divided by 2

Solution

1. Step 1: Understand factorial definition

   Factorial of a number n (written as n!) is the product of all positive integers from 1 to n.

2. Step 2: Compare options

   Only the product of all positive integers up to that number correctly describes factorial as a product, not sum or other operations.

3. Final Answer:

   The product of all positive integers up to that number -> Option A

4. Quick Check:

   Factorial = product of integers [OK]

Hint: Factorial means multiply all numbers down to 1 [OK]

Common Mistakes:

• Confusing factorial with sum
• Thinking factorial divides
• Mixing factorial with doubling

2. Which of the following is the correct base case for a recursive factorial function in TypeScript?

easy

A. if (n === 0) return 1;

B. if (n === 1) return 0;

C. if (n === 0) return 0;

D. if (n === 1) return n + 1;

Solution

1. Step 1: Identify factorial base case

   Factorial of 0 is defined as 1, so the base case should return 1 when n is 0.

2. Step 2: Check options

   Only if (n === 0) return 1; returns 1 when n is 0, which is correct base case for recursion.

3. Final Answer:

   if (n === 0) return 1; -> Option A

4. Quick Check:

   Base case: 0! = 1 [OK]

Hint: Base case for factorial is 0 returns 1 [OK]

Common Mistakes:

• Returning 0 for base case
• Using wrong base condition
• Returning n+1 incorrectly

3. What is the output of this TypeScript code?

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

medium

A. 120

B. 10

C. 16

D. 24

Solution

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

   factorial(4) = 4 * factorial(3) factorial(3) = 3 * factorial(2) factorial(2) = 2 * factorial(1) factorial(1) = 1 * factorial(0) factorial(0) = 1 (base case)

2. Step 2: Calculate values bottom-up

   factorial(1) = 1 * 1 = 1 factorial(2) = 2 * 1 = 2 factorial(3) = 3 * 2 = 6 factorial(4) = 4 * 6 = 24

3. Final Answer:

   24 -> Option D

4. Quick Check:

   4! = 24 [OK]

Hint: Multiply down from n to 1 recursively [OK]

Common Mistakes:

• Stopping recursion too early
• Adding instead of multiplying
• Wrong base case

4. Identify the error in this recursive factorial function:

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

medium

A. No error, output is 1

B. Infinite recursion for input 0

C. Syntax error due to missing semicolon

D. Returns 0 for input 0

Solution

1. Step 1: Analyze base case for input 0

   Base case triggers only when n === 1, so factorial(0) calls factorial(-1), then factorial(-2), and so on infinitely.

2. Step 2: Understand recursion behavior

   Without base case for 0, recursion never stops for input 0, causing infinite recursion (stack overflow).

3. Final Answer:

   Infinite recursion for input 0 -> Option B

4. Quick Check:

   Missing base case for 0 causes infinite recursion [OK]

Hint: Always include base case for 0 in factorial [OK]

Common Mistakes:

• Missing base case for 0
• Assuming 1 covers 0
• Ignoring negative inputs

5. How can you modify the recursive factorial function to handle negative inputs gracefully in TypeScript?

hard

A. Return 0 for all negative inputs inside recursion

B. Remove the base case and let recursion handle negatives

C. Add a check to return -1 for negative inputs before recursion

D. Use a loop instead of recursion for negatives

Solution

1. Step 1: Understand factorial domain

   Factorial is not defined for negative numbers, so function should handle negatives before recursion.

2. Step 2: Add input validation

   Adding a condition to return -1 (or error) for negative inputs prevents invalid recursion calls.

3. Final Answer:

   Add a check to return -1 for negative inputs before recursion -> Option C

4. Quick Check:

   Validate input before recursion to handle negatives [OK]

Hint: Check negatives first, return error code [OK]

Common Mistakes:

• Ignoring negative inputs
• Letting recursion run on negatives
• Returning wrong values for negatives