大量的阶乘

非负整数的阶乘是所有小于或等于n的整数的乘积。例如，阶乘6是6 * 5 * 4 * 3 * 2 * 1，即720。

我们已经讨论了析因的简单程序。
如何使用C / C++程序计算100的阶乘?
100的阶乘有158位数字。即使我们使用long long int，也无法存储许多数字。
例子 ：

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

Input :50
Output : 3041409320171337804361260816606476884-
         4377641568960512000000000000

以下是一个简单的解决方案，其中我们使用数组存储结果的各个数字。想法是使用基本数学进行乘法。

以下是查找阶乘的详细算法。
阶乘(n)
1)创建一个MAX大小的数组’res []’，其中MAX是输出中最大位数。
2)将存储在“ res []”中的值初始化为1，并将“ res_size”(“ res []”的大小)初始化为1。
3)对从x = 2到n的所有数字进行跟随。
……a)将x与res []相乘，并更新res []和res_size以存储相乘结果。
如何将数字“ x”与res []中存储的数字相乘?
这个想法是使用简单的学校数学。我们将res []的每一位数乘以x。这里要注意的重要一点是，数字是从最右边的数字乘以最左边的数字。如果我们以相同顺序将数字存储在res []中，那么在没有多余空间的情况下更新res []变得很困难。这就是为什么以相反的方式维护res []的原因，即，存储了从右到左的数字。
相乘(res []，x)
1)将进位初始化为0。
2)对i = 0到res_size – 1执行以下操作
….a)求出res [i] * x +进位的值。让这个值成为事实。
….b)通过将prod的最后一位存储在其中来更新res [i]。
….c)通过在进位中存储剩余数字来更新进位。
3)将进位的所有位数放入res []中，并按进位的位数增加res_size。

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[0]*x + carry = 9*10 + 0 = 90.
res[0] = 0, carry = 9

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

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

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

res[4] = carry = 5

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

下面是上述算法的实现。
注意：在下面的实现中，假定输出中的最大位数为500。要查找数量更大的阶乘(> 254)，请增加数组的大小或增加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[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);
 
    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[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);
 
        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
?>

Javascript

 
// Javascript program to compute factorial of big numbers
 
// This function finds factorial of large numbers
// and prints them
function factorial(n)
{
    let res = new Array(500);
 
    // Initialize result
    res[0] = 1;
    let res_size = 1;
 
    // Apply simple factorial formula n! = 1 * 2 * 3 * 4...*n
    for (let x=2; x<=n; x++)
        res_size = multiply(x, res, res_size);
 
    document.write("Factorial of given number is " + "<br>");
    for (let i=res_size-1; i>=0; i--)
        document.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
function multiply(x, res, res_size)
{
    let carry = 0; // Initialize carry
 
    // One by one multiply n with individual digits of res[]
    for (let i=0; i<res_size; i++)
    {
        let prod = res[i] * x + carry;
 
        // Store last digit of 'prod' in res[]
        res[i] = prod % 10;
 
        // Put rest in carry
        carry = Math.floor(prod/10);
    }
 
    // Put carry in res and increase result size
    while (carry)
    {
        res[res_size] = carry%10;
        carry = Math.floor(carry/10);
        res_size++;
    }
    return res_size;
}
 
// Driver program
    factorial(100);
 
// This is code is contributed by Mayank Tyagi
 

输出 ：

Factorial of given number is
9332621544394415268169923885626670049071596826438162146859296389
5217599993229915608941463976156518286253697920827223758251185210
916864000000000000000000000000

程序2：(BigInteger方法)

大整数也可以用于计算大数的阶乘。

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));
    }
}

输出

2432902008176640000