# Factorial of a large number

• Difficulty Level : Medium
• Last Updated : 21 Jun, 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```

Time Complexity: O(nlogn!) n for loop  and logn! for while loop

Auxiliary Space: O(MAX)

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`

Time Complexity: O(nlogn!)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :