计算任意大数的阶乘，显示所有数字

时间：2009-12-27 14:33:17

标签： c++ factorial

我最近在一次采访中被要求描述一种计算任意大数的阶乘的方法;我们获得所有答案数字的方法。

我搜索了不同的地方，并在几个论坛上询问。但我想知道是否有任何方法可以在不使用像GMP这样的库的情况下实现这一目标。

谢谢。

11 个答案:

答案 0 :(得分：30)

GNU Multiprecision库是一个很好的库！但是，既然你说不允许使用外部库，那么我认为可能的方法是采用一个int数组，然后将数字乘以纸上的数字！

以下是我写回来的代码.. 

#include<iostream>
#include<cstring>

int max = 5000;

void display(int arr[]){
    int ctr = 0;
    for (int i=0; i<max; i++){
        if (!ctr && arr[i])         ctr = 1;
        if(ctr)
            std::cout<<arr[i];
    }
}


void factorial(int arr[], int n){
    if (!n) return;
    int carry = 0;
    for (int i=max-1; i>=0; --i){
        arr[i] = (arr[i] * n) + carry;
        carry = arr[i]/10;
        arr[i] %= 10;
    }
    factorial(arr,n-1);
}

int main(){
    int *arr = new int[max];
    std::memset(arr,0,max*sizeof(int));
    arr[max-1] = 1;
    int num;
    std::cout<<"Enter the number: ";
    std::cin>>num;
    std::cout<<"factorial of "<<num<<"is :\n";
    factorial(arr,num);
    display(arr);
    delete[] arr;
    return 0;
}

'arr'只是一个整数数组，factorial是一个简单的函数，它将给定的数字乘以'大数'。

希望这能解决您的疑问..

答案 1 :(得分：7)

接受的答案很好，但这是C ++;我们可以做得更好。让我们开始使用我们自己的Bignum类，其中包含完全无限的数字。

为了获得最高效率，我们将使用纯二进制数，使用尽可能多的位来打包每个数组元素。更简单的方法是在每个元素中存储一个十进制数字。在这里，我已经做了妥协，在每个uint32_t元素中存储9个十进制数字。

数据以little-endian存储，因为当我们需要更高阶元素时，最后扩展vector要容易得多。

一旦我们有了这个类，阶乘函数本身就是简单的。

#include <assert.h>
#include <iomanip>
#include <iostream>
#include <stdint.h>
#include <vector>

class Bignum
{
public:
    Bignum(int value)
    {
        assert(value >= 0 && value <= 999999999);
        parts.push_back(value);
    }

    Bignum& operator*=(int rhs)
    {
        assert(rhs >= 0 && rhs <= 999999999);
        uint32_t carry = 0;
        for (size_t i = 0; i < parts.size(); i++)
        {
            uint64_t product = (uint64_t)parts[i] * (uint64_t)rhs + carry;
            parts[i] = (uint32_t)(product % 1000000000LL);
            carry = (uint32_t)(product / 1000000000LL);
        }
        if (carry != 0)
            parts.push_back(carry);
        return *this;
    }

    friend std::ostream & operator<<(std::ostream& stream, const Bignum& num);

private:
    std::vector<uint32_t> parts;
};

inline std::ostream& operator<<(std::ostream& stream, const Bignum& num)
{
    char oldfill = stream.fill('0');
    for (std::vector<uint32_t>::const_reverse_iterator it = num.parts.rbegin(); it != num.parts.rend(); it++)
        stream << *it << std::setw(9);
    stream.fill(oldfill);
    stream.width(0);
    return stream;
}

Bignum factorial(int n)
{
    Bignum fac = 1;
    for (int i = 2; i <= n; i++)
        fac *= i;
    return fac;
}

int main(int argc, char* argv[])
{
    for (int n = 0; n <= 52; n++)
        std::cout << factorial(n) << std::endl;
    return 0;
}

答案 2 :(得分：4)

Srivatsan Iyer的好解决方案和我的建议是：

  1. 通过使用unsigned char数组而不是使用int数组来存储数字，仍然可以提高内存效率。 只需要25％的内存需要int数组。

  2. 为了获得最佳的内存优化，我们还可以使用单个字节来表示2位数。 因为只有4位足以表示从0到9的任何数字。 因此，我们可以使用按位运算在一个字节中打包两位数。 它将需要12.5％的内存需要到int数组。

答案 3 :(得分：3)

好吧，你必须使用数组编写自己的数学例程。这很容易添加，乘法有点困难，但仍然可能。

编辑：想发布一个例子，但Srivatsan Iyer的例子很好。

答案 4 :(得分：3)

BigInteger类可以解决您的问题，上面的C实现让您了解如何实现BigInt，除了代码针对速度进行了优化并且仅针对计算阶乘而定制。

答案 5 :(得分：3)

我有一个计算阶乘的解决方案，它在至少n <= 15000时工作正常。可以在1秒内计算10000的因子，并且用于计算因子的因子花费不到2秒。 （当然，你的问题没有说明时间限制，这些时间完全取决于机器）。无论如何，这个概念很简单。我使用char数组。数组的第一个字符是＆＃39; 1＆＃39;。 LSB从以0开始的索引存储。变量（m根据我的程序）跟踪因子长度。 m的最终值是阶乘中的位数，char数组的第（m-1）个元素是阶乘的MSB。 当循环迭代时，字符将添加到数组的右侧。变量＆＃39; c＆＃39;跟踪携带情况。

使用数组的缺点留在未使用的字节块上。超出某一点，你不能为数组预留空间。除此之外，数组往往会变慢。

您可以在ideone上查看我的程序：http://ideone.com/K410n7

我相信我的解决方案仍然可以优化。请提出建议。

include<stdio.h> 

char res[200000];

inline int fact(int n)
{

    int i,j;

    register int m,c;

    m=1;

    res[0]='1';

    for(i=2;i<=n;i++)
    {

        c=0;

        for(j=0; j< m; j++){

            c =((res[j]-48)*i)+c;

            res[j]=(c%10)+48;

            c=c/10;

        }
        while(c>0){
            res[m]=(c%10)+48;

            c=c/10;

            m++;

        }

    }

    return m;

}

int main() {


    int n,i,d;

    scanf("%d",&n);


    d=fact(n);

    for(i=d-1;i>=0;i--)

        printf("%c",res[i]);


    return 0;
}

答案 6 :(得分：2)

#include <iostream>
using namespace std;
int main ()
{
    int i,n,p=1;
    cout<<"Enter a number: ";
    cin>>n;
    cout<<endl;

    for (i=1;i<=n; i++)
    {
        cout<<i<<" X "; 
        p=p*i;
    }
    cout<<endl<<endl<<p<<" factorial of "<<n;

    return 0;
}

答案 7 :(得分：1)

实际上很容易。这有两种方式。一个是精确的，一个是近似值。对于确切的数字，任何超过10,000的数字都需要花费几秒钟来计算。近似它需要几微秒，直到你进入数百万。如果有人感兴趣，这是斯特林的近似值。

10,000,000的因子是aprox 1.2024234127436e + 65657059这需要5.9秒查找确切的金额需要34天。

<?php
$test= 3579;

echo 'Factorial of '.$test.'<br><br>';

$tm= microtime( true);

echo 'Exact '.( $f= factorialexact( $test)).' e+'.(strlen( $f)-1).' missing decimal place after first digit<br>';

echo ( microtime( true) - $tm). ' seconds<br><br>';

$tm= microtime( true);

echo 'Aprox '.factorialapprox( $test).'<br>';

echo ( microtime( true) - $tm). ' seconds<br><br>';


function factorialexact( $n){
    $f= '1';
    for ( $i=$n; $i>1; $i--){
        $f= JL_bcmul( $f, (''.$i));
    }
    return $f;
}

function factorialapprox( $n){
    // Stirling's factorial approximation
    // aprox factorial n = sqrt( 2 * pi * n) * n^n / e^n
    // store in t the easy part, calc the first term easily
    $t= sqrt( 2 * 3.14159265358979 * $n);
    // things get tough from here because for large n
    // n^n can blow away floating point pachages 
    // declare exponent of the number
    $e= 0;
    // the remaining terms are n^n / e^n
    // both n and e (natural log) are raised to the same power
    // that is n, just negative of each other
    for ( $i=0; $i<$n; $i++){
        // loop to 
        // mulitply by n and divide by e for each iteration
        $t= $t * $n / 2.71828182845904;
        // exponents are going to get away from us 
        // so reduce or increase t
        while ( $t>1000){
            $t= $t/1000;
            $e= $e+3;
        } 
        while ( $t<0.001){
            $t= $t*1000;
            $e= $e-3;
        } 
    }
    // garentee the base number is between 1 and 10
    while ( $t>=10){
        $t= $t/10;
        $e= $e+1;
    } 
    while ( $t<1){
        $t= $t*10;
        $e= $e-1;
    } 
    // return at a floating string.
    // do not use parseFloat() or floatval() 
    // $v= explode( 'e', $result); $floatvalue= $v[0] * pow( 10, $v[1]);  
    // won't work either.  $v[1] is way too large
    // the exponent can easily be in the tens of thousands
    $p= '-';
    if ( $e>=0){ $p= '+'; }
    return $t.'e'.$p.$e;
}    

function JL_bcmul( $a, $b){
    if ( function_exists( 'bcmul')){
        return bcmul( ( ''.$a), (''.$b));
    }
    $s= array();
    for ($i=0; $i < count( $a) + count( $b); $i++){ $s[$i]= '0'; }
    $t= 0;
    for ($i=0; $i < strlen( $b); $i++){ 
        for ($j=0; $j < strlen( $a); $j++){
            $t= $s[$i+$j] + intval( $a[strlen( $a) - $j - 1]) * intval( $b[ strlen( $b) - $i - 1]); 
            $s[$i+$j]= $t % 10;
            $s[$i+$j+1]= $s[$i+$j+1] + floor( $t / 10);
        }
    }
    $s= array_reverse( $s);
    return trim( trim(( implode( '', $s).'_'), '0'), '_');
}

答案 8 :(得分：1)

#include<stdio.h>
#include<string.h>
char f[10000];
char factorial[1010][10000];
void multiply(int k){
    int ci,sum,i;
    int len = strlen(f);
    ci=0;
    i=0;
    while(i<len){
        sum=ci+(f[i] - '0') * k;
        f[i] = (sum % 10) + '0';
        i++;
        ci = sum/10;
    }
    while(ci>0){
        f[i++] = (ci%10) + '0';
        ci/=10;
    }
    f[i]='\0';
    for(int j=0;j<i;j++)factorial[k][j]=f[j];
    factorial[k][i]='\0';
}
void fac(){
    int k;
    strcpy(f,"1");
    for(k=2;k<=1000;k++)multiply(k);
}
void print(int n){
    int i;
    int len = strlen(factorial[n]);
    printf("%d!\n",n);
    for(i=len-1;i>=0;i--){
        printf("%c",factorial[n][i]);
    }
    printf("\n");
}
int main()
{
    int n;
    factorial[0][0]='1';
    factorial[1][0]='1';
    fac();
    while(scanf("%d",&n)==1){
        print(n);
    }
    return 0;
}

答案 9 :(得分：1)

下面显示的代码： 

#include<bits/stdc++.h>
using namespace std;
#define MAX 5000

void factorial(int n)
{
    int carry , res_size = 1, res[MAX];
    res[0] = 1;

    for(int x=2; x<=n; x++)
    {
        carry = 0;
        for(int i=0; i<res_size; i++)
        {
          int prod = res[i]*x + carry;
          res[i] = prod % 10;
          carry  = prod/10;
        }
        while (carry)
        {
          res[res_size++] = carry%10;
          carry = carry/10;
        }
     }
     for(int i=res_size-1; i >= 0; i--) 
     {
         cout<<res[i];
     }
}
int main()
{
      int n;
      cin>>n;
      factorial(n);
      cout<<endl;
      return 0;
}

答案 10 :(得分：-2)

由于每个人都投票支持Srivatsan，我只是怀疑这个问题。你需要存储所有数字吗？如果是的话，那么Srivatsan的解决方案就可以了。如果不是，为什么不在计算阶乘时只显示数字？我没有正确格式化输出，但这可以达到目的。

int factorial(int num)
{
   if (num <= 0)
      return 1;
   else
   {
      std::cout << num << std::endl;
      return num * factorial(num - 1);
   }
}

<强> 更新 对于所有的downvoters，虽然这个5岁的帖子，以及factorial(3);的输出

3
2
1
6 // this is the result of the factorial and the digits above are the ones all the digits in the calculation.

我认为这就是问。

相关问题
最新问题