How to Write a Factorial Program in C with Code Examples

Bottom Line: The factorial algorithm is direct: initialize, iterate, multiply sequentially, and print the result.

A crucial part of any C program is handling user input and displaying output. In factorial programs, this means prompting the user to enter the number whose factorial is to be calculated, reading that input, and then printing the result.

To achieve this, the program typically starts in the main() function, where you declare variables to store the user's input and the factorial result. For example, you might declare an int variable for the input number and an unsigned long long variable for the result, especially if you expect large outputs.

The printf() function is used to display a prompt message to the user, such as "Enter a number:". To read the user's input, the scanf() function is used, which takes the value entered and stores it in the declared variable.

It's important to include error handling, especially to check if the user enters a negative integer. Since the factorial of a negative number doesn't exist, you can use an if statement to print an error message and avoid further calculation.

After calculating the factorial—often using a for loop or another iterative method—the program prints the result using another printf() statement. This printing result step ensures the program output is clear and user-friendly.

Example snippet:

#include <stdio.h>


int main() {
    int n;
    unsigned long long factorial = 1;


    printf("Enter an integer: "); // prompt message
    scanf("%d", &n); // reading input


    // error handling for negative integer
    if (n < 0)
        printf("Error! Factorial of a negative number doesn't exist.");
    else {
        for (int i = 1; i <= n; ++i) {
            // for loop
            factorial *= i;
        }
        printf("Factorial of %d = %llu", n, factorial); // printing result
    }


    return 0;
}

This approach ensures users receive clear instructions, invalid inputs are handled gracefully, and results are displayed in a readable format.

Key Takeaways So Far:

• printf() displays messages; scanf() reads user input safely into variables.
• Negative number inputs trigger error handling conditions within factorial logic.
• Displaying results clearly improves program readability and user interaction quality.

The 'for' loop is a frequently used method in C for calculating a number's factorial. The program runs a block of code repeatedly and multiples the result variable by the loop counter at each step. This process continues from 1 to the input number until it produces the factorial value. 

The program for factorial in C language using For loop looks like this:

// C program to Find the Factorial Using for Loop
#include <stdio.h>

unsigned int factorial(unsigned int N) {
    int fact = 1, i;

    // Loop from 1 to N to get the factorial
    for (i = 1; i <= N; i++) {
        fact *= i;
    }

    return fact;
}

int main() {
    int N = 5;
    int fact = factorial(N);
    printf("Factorial of %d is %d", N, fact);
    return 0;
}

OutPut:

Factorial of 5 is 120

A factorial program in C uses a while loop to repeatedly multiply numbers from 1 up to the given input. The loop then runs as long as the counter is less than or equal to the input number. Each iteration updates the factorial result, which makes it an effective way to calculate factorials iteratively. 

The C factorial program using a while loop looks like this:

#include<stdio.h>

int main() {
    int number, factorial = 1;

    printf("Enter a number: ");
    scanf("%d", &number);

    while(number > 1) {
        factorial = factorial * number;
        number--;
    }

    printf("Factorial is: %d", factorial);
    return 0;
}

In the recursive approach, a function calls itself to solve smaller subproblems of the original problem. Each recursive call breaks the problem into simpler parts and works towards a base case. This base case defines the stopping condition. 

The flow chart below describes how it works:

In the recursive factorial C program below, the factorial function keeps calling itself with a number - 1 as long as the number is 1 or greater. Each recursive call multiplies the current number by factorial (number - 1). When the number becomes less than 1, the function stops and returns 1, which is the base case for the calculation.

#include<stdio.h>

long int factorial(int number) {
   if(number >= 1)
       return number*factorial(number-1);
   else
       return 1;
}

int main() {
    int number;

    printf("Enter a number: ");
    scanf("%d", &number);

    printf("Factorial of %d is: %ld", number,
 factorial(number));
    return 0;
}

Besides,​‍​‌‍​‍‌​‍​‌‍​‍‌ a factorial program in C can use arrays to cope with big numbers. The arrays keep separate digits of the factorial result. In this way, calculations can be done which go beyond the usual integer limits. Multiplication is done digit by digit, and the results are saved in the array. This method is efficient for calculating factorials of extremely large ​‍​‌‍​‍‌​‍​‌‍​‍‌numbers.

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

// Function to multiply a string (representing a number)
// by an integer
void multiplyString(char num[], int factor) {
    int len = strlen(num);
    int carry = 0;

    for (int i = len - 1; i >= 0; i--) {
        int digit = num[i] - '0';
        int product = digit * factor + carry;
        num[i] = (product % 10) + '0';
        carry = product / 10;
    }

    // Handling the carry by adding digits to the front
      // of the number
    while (carry) {
        for (int i = strlen(num); i >= 0; i--) {
            num[i + 1] = num[i];
        }
        num[0] = (carry % 10) + '0';
        carry /= 10;
    }
}
// Function to find factorial using a string
void factorialString(int N) {
  
    // Use a large enough buffer
    char fact[1000];
  
    // Initialize result as "1"
    strcpy(fact, "1");

    for (int i = 2; i <= N; i++) {
      
        // Multiply the string in each iteration
        multiplyString(fact, i);
    }

    printf("Factorial of %d is %s", N, fact);
}

int main() {
    int N = 5;
    factorialString(N);
    return 0;
}

Key Takeaways So Far:

• Arrays store digits to represent extremely large factorial numbers efficiently.
• Multiplication performed digit-by-digit prevents overflow errors in computation.
• Ideal for scenarios requiring high-precision or big-number factorial calculations.

A factorial program in C can be designed within a minimum number of statements by using the ternary operator. The ternary operator actually behaves as a least one function checking whether the number is less than or equal to one, in which the base case is 1. Otherwise, known as recurrence, it multiplies the number by the factorial of one less number recursively. 

Here is an example code:

#include<stdio.h>

long int factorial(int number) {
   return (number >= 1) ? number*factorial(number-1) : 1;
}

int main() {
    int number;

    printf("Enter a number: ");
    scanf("%d", &number);

    printf("Factorial of %d is: %ld", number,
 factorial(number));
    return 0;
}

Bottom Line: The ternary operator provides concise, elegant syntax for recursive factorial implementation.

The factorial series program calculates the factorials of given numbers up to 1. Within the program another loop or recursion is used to calculate the factorials of the numbers and then store them into a sequence. 

The code is as follows:

#include<stdio.h>

long int factorial(int number) {
   long int fact = 1;
   
   for(int i = 1; i <= number; i++) {
      fact = fact * i;
   }
   
   return fact;
}

int main() {
    int number;

    printf("Enter a number: ");
    scanf("%d", &number);

    for(int i = 0; i <= number; i++) {
        printf("Factorial of %d is: %ld\n", i, factorial(i));
    }

    return 0;
}

Key Takeaways So Far:

• Iterates from 0 up to user-defined input number inclusively.
• Calls factorial function repeatedly for every integer within range.
• Displays sequential results forming a complete factorial series output.

Writing a program in C for factoring a number is as useful as any initial program that an applicant tries to tackle in an interview; it provides good knowledge and strengthens problem-solving skills. It is easy to use to appreciate various control structures such as conditional statements, loops, and recursive functions. You can make errors here and learn from them to advance to higher-level code. Moreover, understanding factorial logic builds a foundation for tackling more advanced algorithms and mathematical problems in programming. 

Why It Matters?

Understanding​‍​‌‍​‍‌​‍​‌‍​‍‌ factorial programs is a great way for learners to build their confidence in problem-solving and computational thinking skills. It is a connection between mathematical reasoning and the structure of programming, thus demonstrating how iterative and recursive logic can be used to solve complex problems efficiently. Proficiency in factorials is essentially the starting point for dealing with algorithms that include elements of probability, combinatorics, and numerical ​‍​‌‍​‍‌​‍​‌‍​‍‌computation.

Practical Advice for Learners

• Practice factorials using both loops and recursion to compare performance.
• Experiment with large numbers using array-based solutions.
• Add error handling for invalid or negative inputs.
• Try optimizing recursive versions to reduce memory usage.
• Study how factorial logic applies to permutations and combinations.

1. What is a factorial?

A factorial of a number is the result of multiplying all positive whole numbers from 1 up to that number. For example, 5! = 5 × 4 × 3 × 2 × 1 = 120.

2. How does recursion work in calculating factorials?

Recursion involves a function calling itself with a reduced number. It multiplies the result until it reaches the base case, which is usually 1. The recursion ends once it reaches that base case.

3. How to calculate large factorials in C?

For very large factorials, you can use arrays. Arrays can store individual digits or libraries designed for big-number calculations and get the results.

4. What is the difference between a loop and recursion for factorial calculation?

A loop repeatedly executes a block of code until the factorial is arrived at. The recursion calls the function within itself. Both methods yield the same result but use different approaches.

5. How do I improve the efficiency of my factorial program?

If you are looking for efficiency, using iterative methods like loops is more memory-efficient than recursion. Additionally, storing previously computed results can speed up the process for large numbers.