Factorial Using Recursion in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this factorial recursion code?

Consider the following C code that calculates factorial using recursion. What will be printed when n = 4?

DSA C

int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int n = 4;
    int result = factorial(n);
    printf("%d", result);
    return 0;
}

A 120

B 10

C 24

D 1

💡 Hint

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

The factorial function multiplies n by factorial of n-1 until n is 0, where it returns 1. So factorial(4) = 4*3*2*1 = 24.

❓ Predict Output

intermediate

What is the output when factorial is called with n = 0?

Look at this factorial function. What will it print when n = 0?

DSA C

int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int n = 0;
    int result = factorial(n);
    printf("%d", result);
    return 0;
}

A 1

B 0

C Undefined behavior

D Error at runtime

💡 Hint

Factorial of zero is defined as 1.

By definition, factorial(0) = 1. The base case returns 1 when n is 0.

🔧 Debug

advanced

What error occurs when calling factorial(-1)?

Consider this factorial function. What happens if we call factorial(-1)?

DSA C

int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int n = -1;
    int result = factorial(n);
    printf("%d", result);
    return 0;
}

A Compilation error

B Returns 1 immediately

C Returns 0

D Stack overflow due to infinite recursion

💡 Hint

Check if the base case handles negative numbers.

The base case only stops recursion when n == 0. For n = -1, it keeps calling factorial with decreasing n, causing infinite recursion and stack overflow.

❓ Predict Output

advanced

What is the output of this modified factorial function?

What will this code print when n = 3?

DSA C

int factorial(int n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int n = 3;
    int result = factorial(n);
    printf("%d", result);
    return 0;
}

A 3

B 6

C 1

D 0

💡 Hint

Factorial of 3 is 3 * 2 * 1.

The base case now stops recursion when n <= 1, so factorial(3) = 3 * factorial(2) = 3 * 2 = 6.

🧠 Conceptual

expert

Why is recursion not always the best choice for factorial calculation?

Which of the following is the main reason recursion might be less efficient than iteration for factorial calculation?

A Recursion uses more memory due to call stack overhead

B Recursion cannot handle large numbers

C Recursion always produces wrong results

D Recursion is slower because it uses loops internally

💡 Hint

Think about what happens each time a function calls itself.

Each recursive call adds a new frame to the call stack, using more memory. Iteration uses a single frame and is more memory efficient.