# Factorial of a large number

Factorial of a non-negative integer, is 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.

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

The following is 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 above algorithm.

NOTE : In the below implementation, maximum digits in the output are assumed as 500. To find factorial of much larger number ( > 254), increase the size of array or increase 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[] ` `        ``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` `        ``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 isc ontributed by chandan_jnu ` `?> `

Output :

```Factorial of given number is
9332621544394415268169923885626670049071596826438162146859296389
5217599993229915608941463976156518286253697920827223758251185210
916864000000000000000000000000```

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

My Personal Notes arrow_drop_up

Improved By : jit_t, Chandan_Kumar, pubg_wala

Article Tags :

51

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.