设为首页收藏本站
切换到窄版

鱼C论坛

 找回密码
 立即注册
鱼C论坛»论坛 › 编程语言专区 › C\C++交流 › 高精度计算大数阶乘的c语言源代码和解释
返回列表 发新帖
查看: 1562|回复: 4

[技术交流] 高精度计算大数阶乘的c语言源代码和解释

[复制链接]
jhanker
发表于 2020-6-28 15:10:56 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能^_^

您需要 登录 才可以下载或查看，没有账号？立即注册

x
关键词：高精度,大数,阶乘,C, 输入的容错处理,
内容介绍：利用高精度计算n阶乘的c语言源代码及其解释，其中还包括一些在C语言中常用的简单编程习惯和技巧，非常适合C语言初学者借鉴，如果好好的把程序调试一遍会对初学者很大的启发。程序中没有用到指针，结构体，共用体等内容，但运用了预编译，头文件，数组等等知识，特别是对getchar()进行输入容错的运用，并有详细的解释！
算法简介：高精度计算n的阶乘其实是高精度大整数乘法的应用，其核心思想就是把计算结果每一位上的数字保存到一个数组成员中，例如：把567保存至数组中，保存结果应该是result[0] =7；result[1] =6；result[2] =5。把整个数组看成一个数字，这个数字和一个数相乘的时候，需要每一位都和这个乘数进行相乘运算还需要把前一位的进位加上。算法如下：int 结果 = result[x] * 乘数 + 进位;每一位的计算结果有了，把这个结果的个位数拿出来放到这个数组元素上：result[x] = 结果%10;接下来的工作就是计算出进位：进位 = 结果 / 10;这样一位一位的把整个数组计算一遍，最后可能还有进位，用同样的方法，把进位的数值拆成单个数字，放到相应的数组元素中。最后从后往前输出结果。
getchar()使用说明：getchar()有一个int型的返回值.当程序调用getchar()时.程序就等着用户按键.用户输入的字符被存放在键盘缓冲区中.直到用户按回车为止(回车字符也放在缓冲区中).当用户键入回车之后, getchar()才开始从stdio流中每次读入一个字符. getchar()函数的返回值是用户输入的第一个字符的ASCII码,如出错返回-1,且将用户输入的字符回显到屏幕.如用户在按回车之前输入了不止一个字符,其他字符会保留在键盘缓存区中,等待后续getchar()调用读取.也就是说,后续的getchar()调用不会等待用户按键,而直接读取缓冲区中的字符,直到缓冲区中的字符读完为后,才等待用户按键.
getch（）与getchar()基本功能相同,差别是getch（）直接从键盘获取键值,不等待用户按回车,只要用户按一个键, getch（）就立刻返回, getch（）返回值是用户输入的ASCII码,出错返回-1.输入的字符不会回显在屏幕上. getch（）函数常用于程序调试中,在调试时,在关键位置显示有关的结果以待查看,然后用getch（）函数暂停程序运行,当按任意键后程序继续运行.
下面是用高精度计算n阶乘的c语言源代码：（还附有正整数输入的容错处理函数）程序特点：程序使用了数组的方法，虽然效率不高，但适合初学者学习。程序在VC++6.0，VC++2010测试通过。程序1使用了一个大数组，程序2使用了4个数组组合在一起，其实程序2完全是锻炼初学者的程序分析能力而已。由于系统限制，程序1中当把HEAD_M 设为 250000（不能超过该数）时，可以计算不要大于50000的阶乘。程序2不能HEAD_M不能超过70000，由此可知其实用多数组是无意义的！
程序1：
  1. //本程序适合学习c语言的初学者调试学习，程序中没有用到指针，结构体，共用体等内容
  2. //本来下面的代码是一个头文件，文件名是：headself.h 里面只有一个输入正整数的函数。
  3. //把自己经常用的一些变量，函数等等放入自编的头文件是一个很好的习惯。
  4. /*begin包含头文件********************/
  5. #include   <stdio.h>
  6. #include   <stdlib.h>
  7. #include   <conio.h>
  8. #include   <math.h>
  9. /*end包含头文件**********************/

  11. /*begin宏定义************************/
  12. #define    DEBUG    1   //当程序在调试阶段时 DEBUG为 1,发布时改成0则可
  13. #define    HEAD_M   250000  // 存储阶乘运算结果的数组长度,该参数不要超过250000
  14. #define    HEAD_N   5  //限制输入的正整数位数，该参数不要超过5,如果是5，对应的 HEAD_M 要设为250000为 且输入的求阶乘的数也不能大于50000
  15. /*end宏定义**************************/

  17. /*begin函数声明**********************/
  18. int Input_uint(); //无符号整形输入函数
  19. /*end函数声明************************/

  21. /*begin自定义类型******************/
  22. /*end自定义类型********************/

  24. /*begin全局变量定义******************/
  25. /*end全局变量定义********************/

  27. /*begin函数定义*********************/
  28. int Input_uint() //无符号整形输入函数
  29. {
  30.      int count_a=0,ratio=1,count_c=0,number=0,judge=1;
  31. //count_a计数变量；ratio转换系数，1，10，100等；
  32. // count_c计数变量；number函数返回值；
  33. // judge输入判断变量，-1出错;
  34.          char str[HEAD_N];
  35.    
  36.          for (count_a=0;count_a<HEAD_N;count_a++)
  37.                  str[count_a]='0';

  39.      do
  40.          {
  41.              if (judge==1) ;
  42.              else
  43.             printf("\n输入错误。请输入一个大于等于零的整数:");
  44.          judge=1;

  46.          for(count_a=HEAD_N-1,count_c=HEAD_N-1;count_a>=0;count_a--,count_c--)
  47.                  {
  48.              str[count_a]=getchar();
  49.              if(!((str[count_a]>='0' && str[count_a]<='9') || (str[count_a]==10)))
  50.                           judge=-1;
  51.              if(str[count_a]==10 || count_a==0)
  52.                          {  
  53.                     if(str[count_a]==10)
  54.                                         break;
  55.                             if(str[count_a]!=10 && count_a==0)
  56.                                 {   
  57.                                 for(;;)
  58.                                         {
  59.                         count_a=getchar();
  60.                                     if(!((count_a>='0'&& count_a<='9') || (count_a==10)))
  61.                                     judge=-1;
  62.                                     if (count_a==10)
  63.                                        break;
  64.                                         }
  65.                                 }
  66.                     count_a=0;
  67.                          }
  68.                  }
  69.          if (judge>0)
  70.                  {
  71.               for(count_a=count_c+1;count_a<HEAD_N;count_a++)
  72.                           {   
  73.                       if (str[count_a]>='0' && str[count_a]<='9')
  74.                                   {
  75.                                   number+=(str[count_a]-'0')*ratio;
  76.                       ratio*=10;
  77.                                   }
  78.                   else
  79.                           break;
  80.                           }
  81.                  }
  82.          }while(judge<0);
  83.      return number;
  84. }
  85. /*end函数定义***********************/

  87. //下面的代码是计算n的阶乘的高精度算法，是个有趣的程序，初学者好好调试一下会学会不少的知识
  88. // #include   "headself.h" //如果把前面的代码写成头文件则不要屏蔽该行代码

  90. void main()
  91. {
  92.     int a[HEAD_M],i,n,n1=1,j,j1,flag=1;
  93.     for(i=0;i<HEAD_M;i++)
  94.                 a[i]=0;
  95.         printf("下面将为你列出阶乘表。输入的数太大结果会很大,如果超过五万系统将截取到五万\n");
  96.     printf("请输入一个整数（输入的数不要太大）：n=");
  97.     n=Input_uint();//调用自定义输入函数，用来屏蔽非数字字符的输入
  98.         if(n>50000)
  99.                 n=50000;
  100. #if (DEBUG==1)
  101.         printf("\n你输入的数是：%d",n);
  102. #else
  103.         printf("\n下面将计算0到%d的阶乘表！谢谢\n",n);
  104.         printf("\n0!=1");
  105.         if(n>0)
  106.             printf("\n1!=1");
  107. #endif
  108.     a[0] = 1;
  109.     for(j = 2; j <= n; j++)
  110.     {
  111.         for(i = 0; i < flag; i++) a[i] *= j;
  112.         for(i = 0; i < flag; i++)
  113.         if(a[i] >= 10)
  114.         {
  115.             a[i+1] += a[i]/10;
  116.             a[i] = a[i] % 10;
  117.             if(i == flag-1)  flag++;
  118.         }
  119. #if (DEBUG==0)
  120.             printf("\n%d!=",j);
  121.                 for(j1 = flag-1; j1 >= 0; j1--)
  122.             printf("%d", a[j1]);
  123.                         //printf("---(%d!的结果是%d位)",j,flag);
  124. #endif
  125.      }
  126. #if (DEBUG==1)
  127.        printf("\n%d!=",--j);
  128.            for(j1 = flag-1; j1 >= 0; j1--)
  129.        printf("%d", a[j1]);
  130. #endif
  131.         if (n>6900)
  132.                 printf("\n您输入的数也太大了吧，终于显示结束，您知道吗？%d!的结果是%d位,屏幕可能已显示不全了！！",n,flag);
  133.         else if(n>1000)
  134.                 printf("\n您输入的数也太大了吧，终于显示结束，您知道吗？%d!的结果是%d位,累不累啊你！！",n,flag);
  135.         else
  136.                 printf("\n您知道吗？%d!的结果是%d位.",n,flag);
  137.         printf("\n");
  138. // getch();//该语句可防止运行结束时退出程序，这样才能看到屏幕内容
  139.            system("pause");//该语句同样可防止运行结束时退出程序，但多了提示"请按任意键继续..."这样才能看到屏幕内容
  140. }       
复制代码

程序2：
  1. #include   <stdio.h>
  2. #include   <stdlib.h>
  3. #include   <conio.h>
  4. #include   <math.h>
  5. #define    DEBUG    1   //当程序在调试阶段时 DEBUG为 1
  6. #define    HEAD_M   70000  // 存储阶乘运算结果的数组长度,该参数不要超过70000
  7. #define    HEAD_N   5  
  8. int Input_uint(); //无符号整形输入函数

  10. int Input_uint() //无符号整形输入函数
  11. {
  12.      int count_a=0,ratio=1,count_c=0,number=0,judge=1;
  13. //count_a计数变量；ratio转换系数，1，10，100等；
  14. // count_c计数变量；number函数返回值；
  15. // judge输入判断变量，-1出错;
  16.          char str[HEAD_N];
  17.    
  18.          for (count_a=0;count_a<HEAD_N;count_a++)
  19.                  str[count_a]='0';

  21.      do
  22.          {
  23.              if (judge==1) ;
  24.              else
  25.             printf("\n输入错误。请输入一个大于等于零的整数:");
  26.          judge=1;

  28.          for(count_a=HEAD_N-1,count_c=HEAD_N-1;count_a>=0;count_a--,count_c--)
  29.                  {
  30.              str[count_a]=getchar();
  31.              if(!((str[count_a]>='0' && str[count_a]<='9') || (str[count_a]==10)))
  32.                           judge=-1;
  33.              if(str[count_a]==10 || count_a==0)
  34.                          {  
  35.                     if(str[count_a]==10)
  36.                                         break;
  37.                             if(str[count_a]!=10 && count_a==0)
  38.                                 {   
  39.                                 for(;;)
  40.                                         {
  41.                         count_a=getchar();
  42.                                     if(!((count_a>='0'&& count_a<='9') || (count_a==10)))
  43.                                     judge=-1;
  44.                                     if (count_a==10)
  45.                                        break;
  46.                                         }
  47.                                 }
  48.                     count_a=0;
  49.                          }
  50.                  }
  51.          if (judge>0)
  52.                  {
  53.               for(count_a=count_c+1;count_a<HEAD_N;count_a++)
  54.                           {   
  55.                       if (str[count_a]>='0' && str[count_a]<='9')
  56.                                   {
  57.                                   number+=(str[count_a]-'0')*ratio;
  58.                       ratio*=10;
  59.                                   }
  60.                   else
  61.                           break;
  62.                           }
  63.                  }
  64.          }while(judge<0);
  65.      return number;
  66. }

  68. void main()
  69. {
  70.     int a[HEAD_M],b[HEAD_M],c[HEAD_M],d[HEAD_M],i,n,n1=1,j,j1,flag=1;
  71.     for(i=0;i<HEAD_M;i++)
  72.         {
  73.                 a[i]=0;
  74.             b[i]=0;
  75.                 c[i]=0;
  76.                 d[i]=0;
  77.         }
  78.         printf("下面将为你列出阶乘表。输入的数太大结果会很大,如果超过四位系统将截取前四位数值\n");
  79.     printf("请输入一个整数（输入的数不要太大）：n=");
  80.     n=Input_uint();//调用自定义输入函数，用来屏蔽非数字字符的输入
  81. #if (DEBUG==1)
  82.         printf("\n你输入的数是：%d",n);
  83. #else
  84.         printf("\n下面将计算0到%d的阶乘表！谢谢\n",n);
  85.         printf("\n0!=1");
  86.         if(n>0)
  87.             printf("\n1!=1");
  88. #endif
  89.     a[0] = 1;
  90.     for(j = 2; j <= n; j++)
  91.     {
  92.         for(i = 0; i < flag; i++)
  93.                 {   
  94.                         if(i<1*HEAD_M)
  95.                             a[i-0*HEAD_M] *= j;
  96.                         else if(i<2*HEAD_M)
  97.                                 b[i-1*HEAD_M] *=j;
  98.                         else if(i<3*HEAD_M)
  99.                                 c[i-2*HEAD_M] *=j;
  100.                         else if(i<4*HEAD_M)
  101.                                 d[i-3*HEAD_M] *=j;
  102.                 }
  103.         for(i = 0; i < flag; i++)
  104.         if(i<1*HEAD_M)
  105.                 {
  106.             if(a[i-0*HEAD_M] >= 10)
  107.                         {
  108.                                 if(i==1*HEAD_M-1)
  109.                                         b[0] += a[i-0*HEAD_M]/10;
  110.                 else
  111.                                     a[i-0*HEAD_M+1] += a[i-0*HEAD_M]/10;
  112.                 a[i-0*HEAD_M] = a[i-0*HEAD_M] % 10;
  113.                 if(i == flag-1)  flag++;
  114.                         }
  115.                 }
  116.                 else if(i<2*HEAD_M)
  117.                 {
  118.                 if(b[i-1*HEAD_M] >= 10)
  119.                                 {
  120.                                         if(i==2*HEAD_M-1)
  121.                                                 c[0]+= b[i-1*HEAD_M]/10;
  122.                                         else
  123.                                             b[i-1*HEAD_M+1] += b[i-1*HEAD_M]/10;
  124.                     b[i-1*HEAD_M] = b[i-1*HEAD_M] % 10;
  125.                     if(i == flag-1)  flag++;
  126.                                 }
  127.                 }
  128.             else if(i<3*HEAD_M)
  129.                 {
  130.                 if(c[i-2*HEAD_M] >= 10)
  131.                                 {
  132.                                         if(i==3*HEAD_M-1)
  133.                                                 d[0]+= c[i-2*HEAD_M]/10;
  134.                                         else
  135.                                             c[i-2*HEAD_M+1] += c[i-2*HEAD_M]/10;
  136.                     c[i-2*HEAD_M] = c[i-2*HEAD_M] % 10;
  137.                     if(i == flag-1)  flag++;
  138.                                 }
  139.                 }
  140.                 else if(i<4*HEAD_M)
  141.                 {
  142.                 if(d[i-3*HEAD_M] >= 10)
  143.                                 {
  144.                                         if(i==4*HEAD_M-1)
  145.                                                 ;
  146.                                                 //e[0]+= d[i-3*HEAD_M]/10;
  147.                                         else
  148.                                             d[i-3*HEAD_M+1] += d[i-3*HEAD_M]/10;
  149.                     d[i-3*HEAD_M] = d[i-3*HEAD_M] % 10;
  150.                     if(i == flag-1)  flag++;
  151.                                 }
  152.                 }
  153.                
  154.                         
  155. #if (DEBUG==0)
  156.             printf("\n%d!=",j);
  157.                 for(j1 = flag-1; j1 >= 0; j1--)
  158.                         {
  159.                 if (j1>3*HEAD_M-1)
  160.                                         printf("%d", d[j1-3*HEAD_M]);
  161.                                 else if (j1>2*HEAD_M-1)
  162.                              printf("%d", c[j1-2*HEAD_M]);
  163.                                 else if(j1>1*HEAD_M-1)
  164.                              printf("%d", b[j1-1*HEAD_M]);
  165.                                 else
  166.                                          printf("%d", a[j1-0*HEAD_M]);
  167.                         }
  168.                        
  169.                         printf("--(%d位)",flag);
  170. #endif
  171.      }
  172. #if (DEBUG==1)
  173.             printf("\n%d!=",--j);
  174.                 for(j1 = flag-1; j1 >= 0; j1--)
  175.                         {
  176.                 if (j1>3*HEAD_M-1)
  177.                                         printf("%d", d[j1-3*HEAD_M]);
  178.                                 else if(j1>2*HEAD_M-1)
  179.                              printf("%d", c[j1-2*HEAD_M]);
  180.                                 else if(j1>HEAD_M-1)
  181.                              printf("%d", b[j1-1*HEAD_M]);
  182.                                 else
  183.                                          printf("%d", a[j1-0*HEAD_M]);
  184.                         }
  185. #endif
  186.         if (n>6900)
  187.                 printf("\n您输入的数也太大了吧，终于显示结束，您知道吗？%d!的结果是%d位,屏幕可能已显示不全了！！",n,flag);
  188.         else if(n>1000)
  189.                 printf("\n您输入的数也太大了吧，终于显示结束，您知道吗？%d!的结果是%d位,累不累啊你！！",n,flag);
  190.         else
  191.                 printf("\n您知道吗？%d!的结果是%d位.",n,flag);
  192.         printf("\n");
  193.     //getch();//该语句可防止运行结束时退出程序，这样才能看到屏幕内容
  194.         system("pause");//该语句同样可防止运行结束时退出程序，但多了提示“请按任意键继续...”这样才能看到屏幕内容
  195.        

  197. }
复制代码
小甲鱼最新课程 -> https://ilovefishc.com
回复

使用道具 举报

永恒的蓝色梦想
发表于 2020-6-28 15:39:28 | 显示全部楼层
这个难道不是网络文章么……
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

jhanker
 楼主| 发表于 2020-6-28 15:46:26 | 显示全部楼层
永恒的蓝色梦想 发表于 2020-6-28 15:39
这个难道不是网络文章么……

这是我在很早的时候，网上查了一下是2015年写的一篇小论文的初稿，后来修改了加入另外一些代码后，在《电脑编程与技巧》发表的。
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

jhanker
 楼主| 发表于 2020-6-28 15:47:20 | 显示全部楼层
永恒的蓝色梦想 发表于 2020-6-28 15:39
这个难道不是网络文章么……

现在看那时的文章，感觉挺搞笑的，很幼稚的感觉
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

jhanker
 楼主| 发表于 2020-6-28 15:49:23 | 显示全部楼层
永恒的蓝色梦想 发表于 2020-6-28 15:39
这个难道不是网络文章么……

今天积分到顶了，明天继续，争取早日能上传图片和附件。我一开始还以为充了鱼币就可以上传图片和附件的呢
小甲鱼最新课程 -> https://ilovefishc.com
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2025-6-21 12:40

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表