# Factorial of a large number

• Difficulty Level : Medium
• Last Updated : 19 Jan, 2022

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`

## Python3

 `# 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`

 `#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`
`2432902008176640000`