Stack overflow concept in Javascript - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this recursive function?

Consider this JavaScript function that calls itself recursively without a proper stop condition. What will happen when we run countdown(5)?

Javascript

function countdown(n) {
  console.log(n);
  countdown(n - 1);
}
countdown(5);

A Prints 5 once and stops

B Prints numbers 5 to 1 then stops

C Prints numbers 5 to 0 then stops

D Throws a RangeError: Maximum call stack size exceeded

💡 Hint

Think about what happens when the function never stops calling itself.

The function calls itself with decreasing numbers but never stops. Eventually, JavaScript runs out of space to keep track of calls and throws a RangeError due to stack overflow.

🧠 Conceptual

intermediate

What causes a stack overflow in JavaScript?

Which of the following best describes what causes a stack overflow error in JavaScript?

A Calling functions recursively without a base case

B Using asynchronous functions incorrectly

C Using too many global variables

D Declaring too many variables inside a function

💡 Hint

Think about what happens when functions keep calling themselves endlessly.

A stack overflow happens when the call stack grows too large, usually because functions call themselves without stopping, exhausting memory reserved for calls.

❓ Predict Output

advanced

What is the output of this recursive factorial function?

Look at this factorial function. What will factorial(5) return?

Javascript

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

A Throws RangeError: Maximum call stack size exceeded

B 24

C 120

D Undefined

💡 Hint

Factorial of 5 is 5 * 4 * 3 * 2 * 1.

The function correctly uses a base case (n === 0) to stop recursion. It calculates 5! = 120.

❓ Predict Output

advanced

What error does this code produce?

This function calls itself without a base case. What error will appear when running infinite()?

Javascript

function infinite() {
  return infinite();
}
infinite();

A RangeError: Maximum call stack size exceeded

B TypeError: infinite is not a function

C SyntaxError: Unexpected token

D No error, runs forever

💡 Hint

Think about what happens when a function calls itself endlessly without stopping.

The function calls itself endlessly without a base case, causing the call stack to overflow and throw a RangeError.

🧠 Conceptual

expert

How can you prevent stack overflow in recursive functions?

Which of these is the best way to avoid stack overflow errors in recursive JavaScript functions?

A Avoid using recursion and only use loops

B Use a base case to stop recursion and avoid infinite calls

C Use global variables to store intermediate results

D Declare all variables outside the function

💡 Hint

Think about what stops a recursive function from calling itself forever.

A base case is a condition that stops recursion. Without it, the function calls itself endlessly, causing stack overflow.

Practice

1. What causes a stack overflow error in JavaScript?

easy

A. Declaring global variables

B. Using too many variables in a function

C. Too many nested function calls without stopping

D. Calling a function only once

Solution

1. Step 1: Understand what the call stack is

   The call stack keeps track of function calls in JavaScript. Each call uses some memory.

2. Step 2: Identify what causes overflow

   If functions call themselves too many times without stopping, the stack runs out of memory, causing overflow.

3. Final Answer:

   Too many nested function calls without stopping -> Option C

4. Quick Check:

   Stack overflow = too many nested calls [OK]

Hint: Stack overflow = infinite or too deep recursion [OK]

Common Mistakes:

• Thinking global variables cause stack overflow
• Confusing variable count with call stack size
• Assuming single function call causes overflow

2. Which of the following JavaScript function definitions will cause a stack overflow when called?

easy

A. function infinite() { infinite(); }

B. function countDown(n) { if(n <= 0) return; countDown(n - 1); }

C. function greet() { console.log('Hello'); }

D. function add(a, b) { return a + b; }

Solution

1. Step 1: Check each function for recursion

   function countDown(n) { if(n <= 0) return; countDown(n - 1); } has a base case stopping recursion. function infinite() { infinite(); } calls itself endlessly without a base case. Options C and D are normal functions without recursion.

2. Step 2: Identify which causes stack overflow

   Only function infinite() { infinite(); } causes infinite recursion, leading to stack overflow error.

3. Final Answer:

   function infinite() { infinite(); } -> Option A

4. Quick Check:

   Infinite recursion = stack overflow [OK]

Hint: Infinite recursion without base case causes overflow [OK]

Common Mistakes:

• Assuming all recursive functions cause overflow
• Ignoring base case in recursion
• Confusing normal functions with recursive ones

3. What will be the output of this code?

function recurse(n) {
  if (n === 0) return 'Done';
  return recurse(n - 1);
}
console.log(recurse(3));

medium

A. 3

B. Stack overflow error

C. undefined

D. "Done"

Solution

1. Step 1: Trace the recursive calls

   recurse(3) calls recurse(2), then recurse(1), then recurse(0). At n=0, it returns 'Done'.

2. Step 2: Return values propagate back

   Each call returns the result of the next call, so finally recurse(3) returns 'Done'.

3. Final Answer:

   "Done" -> Option D

4. Quick Check:

   Base case stops recursion, returns 'Done' [OK]

Hint: Base case returns value, recursion unwinds safely [OK]

Common Mistakes:

• Expecting stack overflow without base case
• Thinking recursion returns input number
• Ignoring return propagation

4. Find the error in this recursive function that causes a stack overflow:

function factorial(n) {
  return n * factorial(n - 1);
}

medium

A. Wrong multiplication operator

B. Missing base case to stop recursion

C. Function name is incorrect

D. Should use addition instead of multiplication

Solution

1. Step 1: Check for base case in recursion

   The function calls itself without any condition to stop, so recursion never ends.

2. Step 2: Understand stack overflow cause

   Without a base case, calls pile up until memory runs out, causing stack overflow.

3. Final Answer:

   Missing base case to stop recursion -> Option B

4. Quick Check:

   Base case missing = infinite recursion [OK]

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

Common Mistakes:

• Assuming multiplication causes error
• Ignoring need for base case
• Thinking function name affects recursion

5. You want to safely calculate the sum of numbers from 1 to n using recursion without causing stack overflow. Which change should you make to this function?

function sum(n) {
  return n + sum(n - 1);
}

hard

A. Add a base case: if (n <= 0) return 0;

B. Change + to * operator

C. Call sum(n + 1) instead

D. Remove the recursive call

Solution

1. Step 1: Identify missing base case

   The function calls itself with n-1 but never stops, causing overflow.

2. Step 2: Add base case to stop recursion

   Adding if (n <= 0) return 0; stops recursion when n reaches 0 or less.

3. Step 3: Confirm safe recursion

   With base case, recursion ends properly and sum is calculated without overflow.

4. Final Answer:

   Add a base case: if (n <= 0) return 0; -> Option A

5. Quick Check:

   Base case stops recursion safely [OK]

Hint: Base case prevents infinite recursion and overflow [OK]

Common Mistakes:

• Changing operator instead of adding base case
• Increasing n causing infinite recursion
• Removing recursion loses function purpose