Related Articles

# Factorial of a large number

• Difficulty Level : Medium
• Last Updated : 31 Jul, 2021

Factorial of a non-negative integer, is the multiplication of all integers smaller than or equal to n. For example factorial of 6 is 6*5*4*3*2*1 which is 720. We have discussed simple program for factorial.

How to compute factorial of 100 using a C/C++ program?
Factorial of 100 has 158 digits. It is not possible to store these many digits even if we use long long int.

Examples :

```Input : 100
Output : 933262154439441526816992388562667004-
907159682643816214685929638952175999-
932299156089414639761565182862536979-
208272237582511852109168640000000000-
00000000000000

Input :50
Output : 3041409320171337804361260816606476884-
4377641568960512000000000000```

Following is a simple solution where we use an array to store individual digits of the result. The idea is to use basic mathematics for multiplication.

The following is a detailed algorithm for finding factorial.
factorial(n)
1) Create an array ‘res[]’ of MAX size where MAX is number of maximum digits in output.
2) Initialize value stored in ‘res[]’ as 1 and initialize ‘res_size’ (size of ‘res[]’) as 1.
3) Do following for all numbers from x = 2 to n.
……a) Multiply x with res[] and update res[] and res_size to store the multiplication result.

How to multiply a number ‘x’ with the number stored in res[]?
The idea is to use simple school mathematics. We one by one multiply x with every digit of res[]. The important point to note here is digits are multiplied from rightmost digit to leftmost digit. If we store digits in same order in res[], then it becomes difficult to update res[] without extra space. That is why res[] is maintained in reverse way, i.e., digits from right to left are stored.

multiply(res[], x)
1) Initialize carry as 0.
2) Do following for i = 0 to res_size – 1
….a) Find value of res[i] * x + carry. Let this value be prod.
….b) Update res[i] by storing last digit of prod in it.
….c) Update carry by storing remaining digits in carry.
3) Put all digits of carry in res[] and increase res_size by number of digits in carry.

```Example to show working of multiply(res[], x)
A number 5189 is stored in res[] as following.
res[] = {9, 8, 1, 5}
x = 10

Initialize carry = 0;

i = 0, prod = res*x + carry = 9*10 + 0 = 90.
res = 0, carry = 9

i = 1, prod = res*x + carry = 8*10 + 9 = 89
res = 9, carry = 8

i = 2, prod = res*x + carry = 1*10 + 8 = 18
res = 8, carry = 1

i = 3, prod = res*x + carry = 5*10 + 1 = 51
res = 1, carry = 5

res = carry = 5

res[] = {0, 9, 8, 1, 5} ```

Below is the implementation of the above algorithm.

NOTE : In the below implementation, maximum digits in the output are assumed as 500. To find a factorial of a much larger number ( > 254), increase the size of an array or increase the value of MAX.

## C++

 `// C++ program to compute factorial of big numbers``#include``using` `namespace` `std;` `// Maximum number of digits in output``#define MAX 500` `int` `multiply(``int` `x, ``int` `res[], ``int` `res_size);` `// This function finds factorial of large numbers``// and prints them``void` `factorial(``int` `n)``{``    ``int` `res[MAX];` `    ``// Initialize result``    ``res = 1;``    ``int` `res_size = 1;` `    ``// Apply simple factorial formula n! = 1 * 2 * 3 * 4...*n``    ``for` `(``int` `x=2; x<=n; x++)``        ``res_size = multiply(x, res, res_size);` `    ``cout << ``"Factorial of given number is \n"``;``    ``for` `(``int` `i=res_size-1; i>=0; i--)``        ``cout << res[i];``}` `// This function multiplies x with the number``// represented by res[].``// res_size is size of res[] or number of digits in the``// number represented by res[]. This function uses simple``// school mathematics for multiplication.``// This function may value of res_size and returns the``// new value of res_size``int` `multiply(``int` `x, ``int` `res[], ``int` `res_size)``{``    ``int` `carry = 0;  ``// Initialize carry` `    ``// One by one multiply n with individual digits of res[]``    ``for` `(``int` `i=0; i

## Java

 `// JAVA program to compute factorial``// of big numbers``class` `GFG {``    ` `    ``// This function finds factorial of``    ``// large numbers and prints them``    ``static` `void` `factorial(``int` `n)``    ``{``        ``int` `res[] = ``new` `int``[``500``];` `        ``// Initialize result``        ``res[``0``] = ``1``;``        ``int` `res_size = ``1``;` `        ``// Apply simple factorial formula``        ``// n! = 1 * 2 * 3 * 4...*n``        ``for` `(``int` `x = ``2``; x <= n; x++)``            ``res_size = multiply(x, res, res_size);` `        ``System.out.println(``"Factorial of given number is "``);``        ``for` `(``int` `i = res_size - ``1``; i >= ``0``; i--)``            ``System.out.print(res[i]);``    ``}``    ` `    ``// This function multiplies x with the number``    ``// represented by res[]. res_size is size of res[] or``    ``// number of digits in the number represented by res[].``    ``// This function uses simple school mathematics for``    ``// multiplication. This function may value of res_size``    ``// and returns the new value of res_size``    ``static` `int` `multiply(``int` `x, ``int` `res[], ``int` `res_size)``    ``{``        ``int` `carry = ``0``; ``// Initialize carry` `        ``// One by one multiply n with individual``        ``// digits of res[]``        ``for` `(``int` `i = ``0``; i < res_size; i++)``        ``{``            ``int` `prod = res[i] * x + carry;``            ``res[i] = prod % ``10``; ``// Store last digit of``                                ``// 'prod' in res[]``            ``carry = prod/``10``; ``// Put rest in carry``        ``}` `        ``// Put carry in res and increase result size``        ``while` `(carry!=``0``)``        ``{``            ``res[res_size] = carry % ``10``;``            ``carry = carry / ``10``;``            ``res_size++;``        ``}``        ``return` `res_size;``    ``}` `    ``// Driver program``    ``public` `static` `void` `main(String args[])``    ``{``        ``factorial(``100``);``    ``}``}``//This code is contributed by Nikita Tiwari`

## Python

 `# Python program to compute factorial``# of big numbers` `import` `sys` `# This function finds factorial of large``# numbers and prints them``def` `factorial( n) :``    ``res ``=` `[``None``]``*``500``    ``# Initialize result``    ``res[``0``] ``=` `1``    ``res_size ``=` `1` `    ``# Apply simple factorial formula``    ``# n! = 1 * 2 * 3 * 4...*n``    ``x ``=` `2``    ``while` `x <``=` `n :``        ``res_size ``=` `multiply(x, res, res_size)``        ``x ``=` `x ``+` `1``    ` `    ``print` `(``"Factorial of given number is"``)``    ``i ``=` `res_size``-``1``    ``while` `i >``=` `0` `:``        ``sys.stdout.write(``str``(res[i]))``        ``sys.stdout.flush()``        ``i ``=` `i ``-` `1``        `  `# This function multiplies x with the number``# represented by res[]. res_size is size of res[]``# or number of digits in the number represented``# by res[]. This function uses simple school``# mathematics for multiplication. This function``# may value of res_size and returns the new value``# of res_size``def` `multiply(x, res,res_size) :``    ` `    ``carry ``=` `0` `# Initialize carry` `    ``# One by one multiply n with individual``    ``# digits of res[]``    ``i ``=` `0``    ``while` `i < res_size :``        ``prod ``=` `res[i] ``*``x ``+` `carry``        ``res[i] ``=` `prod ``%` `10``; ``# Store last digit of``                            ``# 'prod' in res[]``        ``# make sure floor division is used``        ``carry ``=` `prod``/``/``10``; ``# Put rest in carry``        ``i ``=` `i ``+` `1` `    ``# Put carry in res and increase result size``    ``while` `(carry) :``        ``res[res_size] ``=` `carry ``%` `10``        ``# make sure floor division is used``        ``# to avoid floating value``        ``carry ``=` `carry ``/``/` `10``        ``res_size ``=` `res_size ``+` `1``        ` `    ``return` `res_size` `# Driver program``factorial(``100``)` `#This code is contributed by Nikita Tiwari.`

## C#

 `// C# program to compute``// factorial of big numbers``using` `System;` `class` `GFG``{``    ` `    ``// This function finds factorial``    ``// of large numbers and prints them``    ``static` `void` `factorial(``int` `n)``    ``{``        ``int` `[]res = ``new` `int``;` `        ``// Initialize result``        ``res = 1;``        ``int` `res_size = 1;` `        ``// Apply simple factorial formula``        ``// n! = 1 * 2 * 3 * 4...*n``        ``for` `(``int` `x = 2; x <= n; x++)``            ``res_size = multiply(x, res,``                                ``res_size);` `        ``Console.WriteLine(``"Factorial of "` `+``                       ``"given number is "``);``        ``for` `(``int` `i = res_size - 1; i >= 0; i--)``            ``Console.Write(res[i]);``    ``}``    ` `    ``// This function multiplies x``    ``// with the number represented``    ``// by res[]. res_size is size``    ``// of res[] or number of digits``    ``// in the number represented by``    ``// res[]. This function uses``    ``// simple school mathematics for``    ``// multiplication. This function``    ``// may value of res_size and``    ``// returns the new value of res_size``    ``static` `int` `multiply(``int` `x, ``int` `[]res,``                        ``int` `res_size)``    ``{``        ``int` `carry = 0; ``// Initialize carry` `        ``// One by one multiply n with``        ``// individual digits of res[]``        ``for` `(``int` `i = 0; i < res_size; i++)``        ``{``            ``int` `prod = res[i] * x + carry;``            ``res[i] = prod % 10; ``// Store last digit of``                                ``// 'prod' in res[]``            ``carry = prod / 10; ``// Put rest in carry``        ``}` `        ``// Put carry in res and``        ``// increase result size``        ``while` `(carry != 0)``        ``{``            ``res[res_size] = carry % 10;``            ``carry = carry / 10;``            ``res_size++;``        ``}``        ``return` `res_size;``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main ()``    ``{``        ` `        ``factorial(100);``    ``}``}` `// This code is contributed by ajit`

## PHP

 `= 0; ``\$i``--)``        ``echo` `\$res``[``\$i``];``}` `// This function multiplies x with the number``// represented by res[].``// res_size is size of res[] or number of``// digits in the number represented by res[].``// This function uses simple school mathematics``// for multiplication. This function may value ``// of res_size and returns the new value of res_size``function` `multiply(``\$x``, &``\$res``, ``\$res_size``)``{``    ``\$carry` `= 0; ``// Initialize carry` `    ``// One by one multiply n with individual``    ``// digits of res[]``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$res_size``; ``\$i``++)``    ``{``        ``\$prod` `= ``\$res``[``\$i``] * ``\$x` `+ ``\$carry``;` `        ``// Store last digit of 'prod' in res[]``        ``\$res``[``\$i``] = ``\$prod` `% 10;` `        ``// Put rest in carry``        ``\$carry` `= (int)(``\$prod` `/ 10);``    ``}` `    ``// Put carry in res and increase``    ``// result size``    ``while` `(``\$carry``)``    ``{``        ``\$res``[``\$res_size``] = ``\$carry` `% 10;``        ``\$carry` `= (int)(``\$carry` `/ 10);``        ``\$res_size``++;``    ``}``    ``return` `\$res_size``;``}` `// Driver Code``factorial(100);``    ` `// This code is contributed by chandan_jnu``?>`

## Javascript

 ``
Output
```Factorial of given number is
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000```

The above approach can be optimized in many ways. We will soon be discussing an optimized solution for the same.

### Program 2: (BigInteger method)

Big Integer can also be used to calculate factorial of large numbers.

## Java

 `// Java program to find large``// factorials using BigInteger``import` `java.math.BigInteger;``import` `java.util.Scanner;` `public` `class` `Example {``    ` `    ``// Returns Factorial of N``    ``static` `BigInteger factorial(``int` `N)``    ``{``        ``// Initialize result``        ``BigInteger f``            ``= ``new` `BigInteger(``"1"``); ``// Or BigInteger.ONE` `        ``// Multiply f with 2, 3, ...N``        ``for` `(``int` `i = ``2``; i <= N; i++)``            ``f = f.multiply(BigInteger.valueOf(i));` `        ``return` `f;``    ``}` `    ``// Driver method``    ``public` `static` `void` `main(String args[]) ``throws` `Exception``    ``{``        ``int` `N = ``20``;``        ``System.out.println(factorial(N));``    ``}``}`
Output
`2432902008176640000`

Linked List can also be used, this approach will not waste any extra space.

## C++

 `#include ` `using` `namespace` `std;` `#define rep(i, a, b) for (int i = a; i <= b; i++)` `using` `namespace` `std;``// Made a class node containing data and previous pointer as``// we are using tail pointer``class` `Node {``public``:``    ``int` `data;``    ``Node* prev;``    ``Node(``int` `n)``    ``{``        ``data = n;``        ``prev = NULL;``    ``}``};` `void` `Multiply(Node* tail, ``int` `n)``{``    ``Node *temp = tail,``         ``*prevNode = tail; ``// Temp variable for keeping tail``    ``int` `carry = 0;``    ``while` `(temp != NULL) {``        ``int` `data = temp->data * n + carry;``        ``temp->data = data % 10; ``// stores the last digit``        ``carry = data / 10;``        ``prevNode = temp;``        ``temp = temp->prev; ``// Moving temp by 1 prevNode will``                           ``// now denote temp``    ``}``    ``// If carry is greater than 0 then we create another``    ``// node for it.``    ``while` `(carry != 0) {``        ``prevNode->prev = ``new` `Node((``int``)(carry % 10));``        ``carry /= 10;``        ``prevNode = prevNode->prev;``    ``}``}` `void` `print(Node* tail)``{``    ``if` `(tail == NULL) ``// Using tail recursion``        ``return``;``    ``print(tail->prev);``    ``cout``        ``<< tail->data; ``// Print linked list in reverse order``}` `// Driver code``int` `main()``{``    ``int` `n = 20;``    ``Node tail(1); ``// Create a node and initialise it by 1``    ``rep(i, 2, n)``        ``Multiply(&tail, i); ``// Run a loop from 2 to n and``                            ``// multiply with tail's i``    ``print(&tail); ``// Print the linked list``    ``cout << endl;``    ``return` `0;``}` `// This code is contributed by Kingshuk Deb`
Output
`2432902008176640000`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up