Stack Overflow Prevention - Problem

Write a recursive function that calculates the factorial of a number with a built-in depth limit to prevent stack overflow. The function should throw a custom error when the recursion depth exceeds the specified limit.

Requirements:

Implement a recursive factorial function with a depth counter
Throw a custom error message when depth limit is exceeded
Return the factorial result if computation succeeds within the limit

Custom Error Format: "Error: Recursion depth limit exceeded"

Input & Output

Example 1 — Successful Calculation

$ Input: n = 5, maxDepth = 10

› Output: 120

💡 Note: Factorial of 5 is 5! = 5 × 4 × 3 × 2 × 1 = 120. Recursion depth is 5, which is less than maxDepth of 10, so calculation succeeds.

Example 2 — Depth Limit Exceeded

$ Input: n = 8, maxDepth = 5

› Output: Error: Recursion depth limit exceeded

💡 Note: Calculating 8! would require 8 recursive calls, but maxDepth is only 5, so the function throws an error before stack overflow occurs.

Example 3 — Edge Case at Limit

$ Input: n = 3, maxDepth = 3

› Output: 6

💡 Note: Factorial of 3 requires exactly 3 recursive calls, which matches maxDepth of 3. This is the boundary case where calculation just succeeds.

Constraints

1 ≤ n ≤ 20
1 ≤ maxDepth ≤ 100
Function must track recursion depth accurately
Error message must match exactly: "Error: Recursion depth limit exceeded"

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to track recursion depth at each function call and compare it against a maximum limit before proceeding. The recursive approach demonstrates proper depth tracking with error handling, while the iterative approach provides an alternative that validates depth requirements upfront. Best approach depends on learning goals: recursive for understanding stack overflow prevention, iterative for production efficiency. Time: O(n), Space: O(n) for recursive, O(1) for iterative.

Common Approaches

✓ Iterative with Validation

⏱️ Time: O(n) Space: O(1)

Implement factorial using a loop instead of recursion, but still validate that the input wouldn't exceed the depth limit if it were recursive. This provides the same safety guarantee without using the call stack.

Recursive with Depth Tracking

⏱️ Time: O(n) Space: O(n)

Implement factorial recursively while tracking the current depth. At each recursive call, increment the depth counter and check if it exceeds the maximum allowed depth before proceeding.

Iterative with Validation — Algorithm Steps

Check if n would exceed maxDepth (n > maxDepth means too deep)
If depth check fails, return error message
Use iterative loop to calculate factorial from 1 to n
Return the calculated result

Visualization

Tap to expand

Step-by-Step Walkthrough

Validate

Check if n > maxDepth before starting

Loop

Use for-loop to multiply 1 * 2 * 3 * ... * n

Result

Return calculated factorial or error message

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void solution(int n, int maxDepth, char* result) {
    // Check if recursive version would exceed depth limit
    if (n > maxDepth) {
        strcpy(result, "Error: Recursion depth limit exceeded");
        return;
    }
    
    // Calculate factorial iteratively
    long long factorial = 1;
    for (int i = 1; i <= n; i++) {
        factorial *= i;
    }
    sprintf(result, "%lld", factorial);
}

int main() {
    int n, maxDepth;
    char result[100];
    
    scanf("%d", &n);
    scanf("%d", &maxDepth);
    
    solution(n, maxDepth, result);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single loop from 1 to n to calculate factorial

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables, no recursion stack

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~15 min Avg. Time

450 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Stack Overflow Prevention - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Iterative with Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler