挑战C版所有人，1000！ - C语言论坛

第 81 楼

得分:0

回复 78楼 xzlxzlxzl

继续回复78楼,其实我知道具体原因了,不要说我说我把你的具体代码细节出来,下面两个代码,第一个是我原来那个,第二个是按你那个思路翻译出来的,结果发现第二个代码执行时间和你差不多甚至比你的还慢了一点,嗯,可以比对看看

程序代码：

  for (i=1;i!=len;++i)
    {
        for (j=1;j!=count;++j) 
            a[j]=GET_LOW(a[j])*i+GET_HIGH(a[j-1]);
        
        if (GET_HIGH(a[count-1]))
            a[count++]=GET_HIGH(a[j-1]);
    }

程序代码：

for (i=1;i!=len;++i)
{
    unsigned t=0;
    for (j=1;j!=count;++j) 
    {
        t=GET_HIGH(a[j-1]);
        a[j]=GET_LOW(a[j])*i+t;
    }
        
    if (GET_HIGH(a[count-1]))
        a[count++]=t;
}

[此贴子已经被作者于2018-6-7 22:15编辑过]

[code]/*~个性签名:bug是什么意思?bug是看上去没有可能的东西实际上是有可能做到的就是这样~2018-08-08更~*/[/code]

第 82 楼

得分:0

循环结构其实还可以优化,达夫设备~
这个,笑笑就好了~

程序代码：

#include<stdio.h>
#include<time.h>

#define GET_LOW( s )    \
    ((s)&0x0000ffff)
        
#define GET_HIGH( s )    \
    (((s)&0xffff0000)>>16)

unsigned fun( unsigned[],unsigned );

void print( const unsigned[],unsigned );

int main( void )
{
   unsigned a[3000];
   unsigned count;
   unsigned i;

   time_t t=clock();

   for (i=0;i!=100;++i)
       count=fun(a,1001);

   print(a,count);

   printf("用时%ldms\n",clock()-t);
        
    return 0;
}

unsigned fun( unsigned a[],unsigned len )
{

/*****达夫设备*****/
#ifndef DUFF_DECIVE
#define DUFF_DECIVE(NUM,E)    \
    do    \
    {    \
        size_t _Duff_Decive_Time=(NUM-1)>>3;    \
        \
        if (NUM>0)    \
            switch (NUM&7)    \
            {    \
                do    \
                {    \
                    case 0:    E    \
                    case 7:    E    \
                    case 6:    E    \
                    case 5:    E    \
                    case 4:    E    \
                    case 3:    E    \
                    case 2:    E    \
                    case 1:    E    \
                }while     \
                (    \
                    _Duff_Decive_Time-->0    \
                );    \
            }    \
    }while (0)
#endif

    unsigned i;
    unsigned j;
    unsigned count=3;
        
    a[1]=1;
    a[0]=0;
    a[2]=0;

 
    for (i=1;i!=len;++i)
    {
        j=1;
        DUFF_DECIVE(count-1,a[j]=GET_LOW(a[j])*i+GET_HIGH(a[j++-1]););
        
        if (GET_HIGH(a[count-1]))
            a[count++]=GET_HIGH(a[j-1]);
    }
    
    return count;

#undef DUFF_DECIVE
}

void print( const unsigned a[],unsigned len)
{
    while (--len)
        printf("%04x",GET_LOW(a[len]));
        
    puts("");
}

这个是用两种方法执行1000次1000!的时间比照,看出来达夫设备的确是有点效果的

程序代码：

#include<stdio.h>
#include<time.h>

#define GET_LOW( s )    \
    ((s)&0x0000ffff)
        
#define GET_HIGH( s )    \
    (((s)&0xffff0000)>>16)

unsigned fun1( unsigned[],unsigned );
unsigned fun2( unsigned[],unsigned );

void print( const unsigned[],unsigned );

int main( void )
{
   unsigned a[3000];
   unsigned count;
   unsigned i;

   time_t t=clock();

   for (i=0;i!=1000;++i)
       count=fun1(a,1001);

   print(a,count);

   printf("\nfun1用时%ldms\n\n",clock()-t);

   t=clock();

   
   for (i=0;i!=1000;++i)
       count=fun2(a,1001);

   print(a,count);

   printf("\nfun2用时%ldms\n",clock()-t);

        
    return 0;
}

unsigned fun1( unsigned a[],unsigned len )
{
    unsigned i;
    unsigned j;
    unsigned count=3;
        
    a[1]=1;
    a[0]=0;
    a[2]=0;

 
    for (i=1;i!=len;++i)
    {
        for (j=1;j!=count;++j) 
            a[j]=GET_LOW(a[j])*i+GET_HIGH(a[j-1]);
        
        if (GET_HIGH(a[count-1]))
            a[count++]=GET_HIGH(a[j-1]);
    }
    
    return count;
}

unsigned fun2( unsigned a[],unsigned len )
{

/*****达夫设备*****/
#ifndef DUFF_DECIVE
#define DUFF_DECIVE(NUM,E)    \
    do    \
    {    \
        size_t _Duff_Decive_Time=(NUM-1)>>3;    \
        \
        if (NUM>0)    \
            switch (NUM&7)    \
            {    \
                do    \
                {    \
                    case 0:    E    \
                    case 7:    E    \
                    case 6:    E    \
                    case 5:    E    \
                    case 4:    E    \
                    case 3:    E    \
                    case 2:    E    \
                    case 1:    E    \
                }while     \
                (    \
                    _Duff_Decive_Time-->0    \
                );    \
            }    \
    }while (0)
#endif

    unsigned i;
    unsigned j;
    unsigned count=3;
        
    a[1]=1;
    a[0]=0;
    a[2]=0;

 
    for (i=1;i!=len;++i)
    {
        j=1;
        DUFF_DECIVE(count-1,a[j]=GET_LOW(a[j])*i+GET_HIGH(a[j++-1]););
        
        if (GET_HIGH(a[count-1]))
            a[count++]=GET_HIGH(a[j-1]);
    }
    
    return count;

#undef DUFF_DECIVE
}


void print( const unsigned a[],unsigned len)
{
    while (--len)
        printf("%04x",GET_LOW(a[len]));
        
    puts("");
}

[此贴子已经被作者于2018-6-8 02:01编辑过]

[code]/*~个性签名:bug是什么意思?bug是看上去没有可能的东西实际上是有可能做到的就是这样~2018-08-08更~*/[/code]

第 83 楼

得分:0

还可以更进一步~最简单就是每次处理16位改成每次处理20位,也就是每次输出5位,的确又快了很多,最关键的是,代码把16位改成20位,这样还可以用16进制表示,与用16位处理的输出模式是一样的~

其实2^9<1000<2^10,也就是说最多可以放32-10=22个位,但22个位就只能用二进制或者4进制表示了,嗯,算是这样了

@xzlxzlxzl

用共用体我想不到怎么处理12个高位与20个低位的问题,这个虽然用点什么方法可以,但感觉不是那么便捷~
其实我还有感谢你呢,不然我都不管我自己弄的那个代码,也不知道那个代码是有bug的,然后就没有这么多后续的优化了

程序代码：

#include<stdio.h>
#include<time.h>

#define GET_LOW( s )    \
    ((s)&0x000fffff)
        
#define GET_HIGH( s )    \
    (((s)&0xfff00000)>>20)

unsigned fun1( unsigned[],unsigned );
unsigned fun2( unsigned[],unsigned );

void print( const unsigned[],unsigned );

int main( void )
{
   unsigned a[3000];
   unsigned count;
   unsigned i;

   time_t t=clock();

   for (i=0;i!=1000;++i)
       count=fun1(a,1001);

   print(a,count);

   printf("\nfun1用时%ldms\n\n",clock()-t);

   t=clock();

   
   for (i=0;i!=1000;++i)
       count=fun2(a,1001);

   print(a,count);

   printf("\nfun2用时%ldms\n",clock()-t);

        
    return 0;
}

unsigned fun1( unsigned a[],unsigned len )
{
    unsigned i;
    unsigned j;
    unsigned count=2;
        
    a[0]=0;
    a[1]=1;

 
    for (i=1;i!=len;++i)
    {
        for (j=1;j!=count;++j) 
            a[j]=GET_LOW(a[j])*i+GET_HIGH(a[j-1]);
        
        if (GET_HIGH(a[count-1]))
            a[count++]=GET_HIGH(a[j-1]);
    }
    
    return count;
}

unsigned fun2( unsigned a[],unsigned len )
{

/*****达夫设备*****/
#ifndef DUFF_DECIVE
#define DUFF_DECIVE(NUM,E)    \
    do    \
    {    \
        size_t _Duff_Decive_Time=(NUM-1)>>3;    \
        \
        if (NUM>0)    \
            switch (NUM&7)    \
            {    \
                do    \
                {    \
                    case 0:    E    \
                    case 7:    E    \
                    case 6:    E    \
                    case 5:    E    \
                    case 4:    E    \
                    case 3:    E    \
                    case 2:    E    \
                    case 1:    E    \
                }while     \
                (    \
                    _Duff_Decive_Time-->0    \
                );    \
            }    \
    }while (0)
#endif

    unsigned i;
    unsigned j;
    unsigned count=2;
    
    a[0]=0;
    a[1]=1;

 
    for (i=1;i!=len;++i)
    {
        j=1;
        DUFF_DECIVE(count-1,a[j]=GET_LOW(a[j])*i+GET_HIGH(a[j++-1]););
        
        if (GET_HIGH(a[count-1]))
            a[count++]=GET_HIGH(a[j-1]);
    }
    
    return count;

#undef DUFF_DECIVE
}


void print( const unsigned a[],unsigned len)
{
    while (--len)
        printf("%05x",GET_LOW(a[len]));
        
    puts("");
}

[此贴子已经被作者于2018-6-8 02:00编辑过]

[code]/*~个性签名:bug是什么意思?bug是看上去没有可能的东西实际上是有可能做到的就是这样~2018-08-08更~*/[/code]

第 84 楼

得分:0

然后还发现,原来83楼的代码还是输出后再停止计时的,现在在改成输出之前停止计时,加上了其实宏GET_HIGH(不用取位,直接右移20位就可以了)

附上一个终端版(或者暂时来说是这样~~~当然没有把16进制转换成10进制),嗯,这个可以看看了

程序代码：

#include<stdio.h>
#include<time.h>

#define GET_LOW( s )    \
    ((s)&0x000fffff)
        
#define GET_HIGH( s )    \
    ((s)>>20)

unsigned fun( unsigned[],unsigned );

void print( const unsigned[],unsigned );

int main( void )
{
   unsigned a[3000];
   unsigned count;
   unsigned i;

   time_t t=clock();

   for (i=0;i!=100;++i)
       count=fun(a,1001);

   t=clock()-t;

   print(a,count);

   printf("用时%ldms\n",t);
        
    return 0;
}

unsigned fun( unsigned a[],unsigned len )
{

/*****达夫设备*****/
#ifndef DUFF_DECIVE
#define DUFF_DECIVE(NUM,E)    \
    do    \
    {    \
        size_t _Duff_Decive_Time=(NUM-1)>>3;    \
        \
        if (NUM>0)    \
            switch (NUM&7)    \
            {    \
                do    \
                {    \
                    case 0:    E    \
                    case 7:    E    \
                    case 6:    E    \
                    case 5:    E    \
                    case 4:    E    \
                    case 3:    E    \
                    case 2:    E    \
                    case 1:    E    \
                }while     \
                (    \
                    _Duff_Decive_Time-->0    \
                );    \
            }    \
    }while (0)
#endif

    unsigned i;
    unsigned j;
    unsigned count=2;
        
    a[0]=0;
    a[1]=1;

 
    for (i=1;i!=len;++i)
    {
        j=1;
        DUFF_DECIVE(count-1,a[j]=GET_LOW(a[j])*i+GET_HIGH(a[j++-1]););
        
        if (GET_HIGH(a[count-1]))
            a[count++]=GET_HIGH(a[j-1]);
    }
    
    return count;

#undef DUFF_DECIVE
}

void print( const unsigned a[],unsigned len)
{
    while (--len)
        printf("%05x",GET_LOW(a[len]));
        
    puts("");
}

[此贴子已经被作者于2018-6-8 02:43编辑过]

[code]/*~个性签名:bug是什么意思?bug是看上去没有可能的东西实际上是有可能做到的就是这样~2018-08-08更~*/[/code]

第 85 楼

得分:0

回复 84楼九转星河

厉害！
虽然结果有点不正确，但可以克服（主要是把进位遗留到6到8位中，给转换为10进制显示造成麻烦），学到了“达夫设备”技术，其实就是以空间换速度技术，实现方法不一定非要用switch开关，还有好多手段的。
你的代码只空出3个16进制位，因此最多只能做4095的阶乘，经实验也的确如此。使用“达夫设备”后的确为你的代码提速不少，普遍比我的代码跑的快，但没有我优化编译后跑的快，比如，你代码做100次1000！，在我破电脑上基本能用103毫秒跑完，我优化前一般需要110毫秒，优化后就可以少于100毫秒了。我也仔细考虑了你的代码为什么快：不光是“达夫设备”的功劳，还有你数据空间富裕的功劳，由于你空出3位16进制位，所以你可一次性完成一个整形数的读写操作，而我的代码用了所有的16进制位，必须借助第三方变量完成腾挪，牺牲了一点效率，但我代码可以做所有整形数范围内阶乘（除非内存不够）。不过无所谓了，做100次1000！已毫无挑战性，我代码在一台I3的win7系统上16毫秒就能跑完，而我前几天惊叹别人100000！用9秒的，我今天在这个系统里居然只需要6秒，即使我现在这个破手提有时也能跑进20秒前。
不打算再在这上面下功夫了，附上刚刚的测试结果和优化编译后的可执行文件，有兴趣的可以检测，再就是根据你的数据结果帮你把大十六进制数十进制显示的函数写了，你只要覆盖自己的print函数即可，已验证可行（注意头文件加#include <stdlib.h>,print声明去掉const）！

程序代码：

void print( unsigned z[],unsigned len)
{
    int i,j,k,l,m,t;
    char *p;
    m=(len+1)*10;
    p=(char*)malloc(m+2);
    p[m--]=0;
    l=m;
    for(i=len-1;i>0;)
    {
        if(z[i])
        {
            for(j=i,k=0;j>0;j--)
            {
                t=k*0x100000+(z[j]&0xFFFFF);
                z[j]=t/10;
                k=t%10;
            }
            p[l--]=k+'0';
        }
        else i--;
    }
    printf("%s\n",p+l+1);
    free(p);
}

图片附件: 游客没有浏览图片的权限，请登录或注册

阶乘64.rar (39.07 KB)

第 86 楼

得分:0

回复 85楼 xzlxzlxzl

那个的确效率很高

,我打算看看那个具体是怎么实现的,x版还是一如既往地不放代码,嗯,和上次一样放在邮箱里面我看看能不能说点什么,或者还可以再改进也说不定呢

[code]/*~个性签名:bug是什么意思?bug是看上去没有可能的东西实际上是有可能做到的就是这样~2018-08-08更~*/[/code]

第 87 楼

得分:0

回复 82楼九转星河

程序代码：

#include <stdio.h>
#include <math.h>
#include <malloc.h>
#include <time.h>
#include <stdlib.h>

#define GET_LOW( s )    \
    ((s)&0x000fffff)

#define GET_HIGH( s )    \
    ((s)>>20)
union INFO
{
        unsigned int a;
        unsigned short int b[2];

};


int main(int argc, char *argv[])
{

     union INFO A;
     unsigned AA = 44345678;
     A.a=44345678;
     unsigned short int * p  = (unsigned short int *)&AA;
     
     printf("A.a = %u   A.b[0] = %u  A.b[1] = %u  \n",A.a,A.b[0],A.b[1]);
     printf("A.a = %u   A.a %% 65536  = %u   A.a / 65536 = %u \n\n",A.a, A.a%65536 ,A.a/65536 );

     printf("AA = %u   GET_LOW( AA )  = %u   GET_HIGH( AA ) = %u \n",AA,GET_LOW( AA) ,GET_HIGH( AA ));
     printf("AA = %u   AA %% 1048576  = %u    AA / 1048576 = %u \n\n",AA,AA%1048576 ,AA/1048576);
     
     printf("AA = %u   *p  = %u   *(p+1) = %u \n",AA,*p ,*(p+1));
     printf("AA = %u   AA %% 65536  = %u    AA / 65536 = %u \n\n",AA,AA%65536 ,AA/65536);
    return 0;
}

共用体相当65536进制，你的相当1048576进制，我采用的是第三种与共用体一样65536进制，但是速度没你的快而且相差比较大，我很是奇怪，这几天有个烦琐问题没解决没时间想这个问题

第 88 楼

得分:0

回复 87楼童生

既然你已经承认没有九版主速度快，那么可以认为此挑战贴正式结贴，算不算别人挑战你成功了呢？那我就公布我汇合的各求大数阶乘的代码及各算法速度比较结果（其中已经改进16进制大数10进制显示算法，应该是最优算法了，计算结果显示前面约70位数，其中计算1000至4000的阶乘按题主要求计算了100次），各位需要就拿去吧。
先总结下比较结果：本代码在vs2010下编译通过，测试机系统winxp，硬件环境为Intel(R) Core(TM)2 Quad CPU Q6600 2.4GHz，内存4G。
总体来说，64位16进制计算速度最快，计算阶乘数越大优势越明显，但16进制数显示速度慢，因此综合效率我觉得还是100000进制效率较高。九版主代码略优于我的32位16进制和16位16进制，在本机比64位16进制计算慢3倍，64位可计算10万以上的阶乘，其他的只能计算65536以下的数的阶乘。

先上比较结果：

输入要计算的阶乘数:
1000!=402387260077093773543702433923003985719374864210714632543
64位16进制计算1000!耗时110ms,使用了267个int,显示耗时15ms

1000!=402387260077093773543702433923003985719374864210714632543
64位16p进制计算1000!耗时125ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
32位16进制计算1000!耗时188ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
16位16进制计算1000!耗时187ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
九版主计算1000!耗时141ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
十亿进制计算1000!耗时547ms,使用了286个int,显示耗时0ms

1000!=40238726007709377354370243392300398571937486421071463254379991042993
十万进制计算1000!耗时344ms,使用了514个int,显示耗时0ms

输入要计算的阶乘数:
4000!=18288019515140650133147431755739190442173777107304392197
64位16进制计算4000!耗时2750ms,使用了1316个int,显示耗时31ms

4000!=18288019515140650133147431755739190442173777107304392197
64位16p进制计算4000!耗时2703ms,使用了1316个int,显示耗时63ms

4000!=18288019515140650133147431755739190442173777107304392197
32位16进制计算4000!耗时4187ms,使用了1316个int,显示耗时62ms

4000!=18288019515140650133147431755739190442173777107304392197
16位16进制计算4000!耗时4141ms,使用了1316个int,显示耗时47ms

4000!=18288019515140650133147431755739190442173777107304392197
九版主计算4000!耗时3094ms,使用了1316个int,显示耗时78ms

4000!=18288019515140650133147431755739190442173777107304392197
十亿进制计算4000!耗时12375ms,使用了1409个int,显示耗时0ms

4000!=182880195151406501331474317557391904421737771073043921970645269542089
十万进制计算4000!耗时8203ms,使用了2535个int,显示耗时0ms

输入要计算的阶乘数:
10000!=28462596809170545189064132121198688901480514017027992307
64位16进制计算10000!耗时203ms,使用了3702个int,显示耗时360ms

10000!=28462596809170545189064132121198688901480514017027992307
64位16p进制计算10000!耗时187ms,使用了3702个int,显示耗时391ms

10000!=28462596809170545189064132121198688901480514017027992307
32位16进制计算10000!耗时672ms,使用了3702个int,显示耗时375ms

10000!=28462596809170545189064132121198688901480514017027992307
16位16进制计算10000!耗时656ms,使用了3702个int,显示耗时344ms

10000!=28462596809170545189064132121198688901480514017027992307
九版主计算10000!耗时594ms,使用了3702个int,显示耗时375ms

10000!=28462596809170545189064132121198688901480514017027992307
十亿进制计算10000!耗时890ms,使用了3963个int,显示耗时0ms

10000!=2846259680917054518906413212119868890148051401702799230794179994274411
十万进制计算10000!耗时610ms,使用了7132个int,显示耗时0ms

输入要计算的阶乘数:
40000!=2091692422212132363320455256764327026488373544387534341830741
64位16进制计算40000!耗时3219ms,使用了17307个int,显示耗时7484ms

40000!=2091692422212132363320455256764327026488373544387534341830741
64位16p进制计算40000!耗时3406ms,使用了17307个int,显示耗时8266ms

40000!=2091692422212132363320455256764327026488373544387534341830741
32位16进制计算40000!耗时13765ms,使用了17307个int,显示耗时8218ms

40000!=2091692422212132363320455256764327026488373544387534341830741
16位16进制计算40000!耗时13907ms,使用了17307个int,显示耗时8360ms

40000!=2091692422212132363320455256764327026488373544387534341830741
九版主计算40000!耗时12203ms,使用了17307个int,显示耗时8188ms

40000!=2091692422212132363320455256764327026488373544387534341830741
十亿进制计算40000!耗时16344ms,使用了18524个int,显示耗时0ms

40000!=209169242221213236332045525676432702648837354438753434183074196798211
十万进制计算40000!耗时10281ms,使用了33343个int,显示耗时0ms

以下内容是在我二手笔记本上未做编译优化的测试结果：
编译环境：VC++ 6.0 操作系统：WinXP CPU:Dual T2370 1.73GHz 内存：2G 显卡：集成
测试总结：64位16进制计算速度始终领先，九版主速度中等

输入要计算的阶乘数:1000!=402387260077093773543702433923003985719374864210714632543
64位16进制计算1000!耗时188ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
64位16p进制计算1000!耗时250ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
32位16进制计算1000!耗时281ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
16位16进制计算1000!耗时656ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
九版主计算1000!耗时203ms,使用了267个int,显示耗时0ms

1000!=402387260077093773543702433923003985719374864210714632543
十亿进制计算1000!耗时1063ms,使用了286个int,显示耗时0ms

1000!=40238726007709377354370243392300398571937486421071463254379991042993
十万进制计算1000!耗时578ms,使用了514个int,显示耗时0ms

输入要计算的阶乘数:4000!=18288019515140650133147431755739190442173777107304392197
64位16进制计算4000!耗时4188ms,使用了1316个int,显示耗时78ms

4000!=18288019515140650133147431755739190442173777107304392197
64位16p进制计算4000!耗时4890ms,使用了1316个int,显示耗时94ms

4000!=18288019515140650133147431755739190442173777107304392197
32位16进制计算4000!耗时10797ms,使用了1316个int,显示耗时219ms

4000!=18288019515140650133147431755739190442173777107304392197
16位16进制计算4000!耗时14297ms,使用了1316个int,显示耗时94ms

4000!=18288019515140650133147431755739190442173777107304392197
九版主计算4000!耗时5594ms,使用了1316个int,显示耗时235ms

4000!=18288019515140650133147431755739190442173777107304392197
十亿进制计算4000!耗时38109ms,使用了1409个int,显示耗时0ms

4000!=182880195151406501331474317557391904421737771073043921970645269542089
十万进制计算4000!耗时25438ms,使用了2535个int,显示耗时0ms

输入要计算的阶乘数:10000!=28462596809170545189064132121198688901480514017027992307
64位16进制计算10000!耗时687ms,使用了3702个int,显示耗时1703ms

10000!=28462596809170545189064132121198688901480514017027992307
64位16p进制计算10000!耗时1094ms,使用了3702个int,显示耗时1984ms

10000!=28462596809170545189064132121198688901480514017027992307
32位16进制计算10000!耗时3125ms,使用了3702个int,显示耗时2078ms

10000!=28462596809170545189064132121198688901480514017027992307
16位16进制计算10000!耗时3188ms,使用了3702个int,显示耗时1469ms

10000!=28462596809170545189064132121198688901480514017027992307
九版主计算10000!耗时1031ms,使用了3702个int,显示耗时734ms

10000!=28462596809170545189064132121198688901480514017027992307
十亿进制计算10000!耗时1703ms,使用了3963个int,显示耗时0ms

10000!=2846259680917054518906413212119868890148051401702799230794179994274411
十万进制计算10000!耗时922ms,使用了7132个int,显示耗时0ms

输入要计算的阶乘数:40000!=2091692422212132363320455256764327026488373544387534341830741
64位16进制计算40000!耗时11266ms,使用了17307个int,显示耗时30406ms

40000!=2091692422212132363320455256764327026488373544387534341830741
64位16p进制计算40000!耗时14844ms,使用了17307个int,显示耗时28640ms

40000!=2091692422212132363320455256764327026488373544387534341830741
32位16进制计算40000!耗时53453ms,使用了17307个int,显示耗时36843ms

40000!=2091692422212132363320455256764327026488373544387534341830741
16位16进制计算40000!耗时59375ms,使用了17307个int,显示耗时36734ms

40000!=2091692422212132363320455256764327026488373544387534341830741
九版主计算40000!耗时43079ms,使用了17307个int,显示耗时35047ms

40000!=2091692422212132363320455256764327026488373544387534341830741
十亿进制计算40000!耗时59125ms,使用了18524个int,显示耗时0ms

40000!=209169242221213236332045525676432702648837354438753434183074196798211
十万进制计算40000!耗时41796ms,使用了33343个int,显示耗时0ms

输入要计算的阶乘数:Press any key to continue

[此贴子已经被作者于2018-6-15 06:50编辑过]

第 89 楼

得分:0

回复 88楼 xzlxzlxzl

明天早晨删代码，需要代码的速copy。
非vs系统的可注释掉“#include "StdAfx.h"”，vc6的应将“long long”替换为“_int64”

[此贴子已经被作者于2018-6-14 22:50编辑过]

第 90 楼

得分:0

回复 89楼 xzlxzlxzl

[code]/*~个性签名:bug是什么意思?bug是看上去没有可能的东西实际上是有可能做到的就是这样~2018-08-08更~*/[/code]