大整数阶乘程序设计_B09040121
大整数阶乘程序设计_B09040121
程序设计报告( 2010 / 2011学年第一学期)题目:大整数阶乘专业计算机科学与技术学生姓名张赛班级学号B09040121指导教师杨一涛指导单位计算机学院日期2010.9.30大整数阶乘一、课题内容和要求1、系统的基本功能及要求(1)写一个类BigInteger,并有如下成员函数operator+/ operator-/ operator*/ operator\,即整数的四则运算并重载运算符。
(2)用该大整数计算n的阶乘并显示出来。
(n∈[1,100])注:为了简化,可不考虑负数,则遇上形如“2-4”这样的表达式需要报错。
2、程序执行过程(1)系统从键盘读入自然数n,直到输入了合法的n为止。
(2)输出运算的结果,为便于观察结果,每输出四位中间插入空格,格式如下(例如,n=12):12!= 4790 0160 0(3)询问用户是否继续进行,用户选择“是”,直到输入合法为止,转(1),否则退出程序。
3、算法要求及提示(1)因为n较大时,n!的结果将超出长整形的保存范围,因此结果不能用long int型的变量来保存。
本算法要求用链表来存储。
(2)链表的每一个节点存储结果的一位数字,因此结果的输出实际上是链表的遍历问题,同时要先考虑用多少位来表示大整数。
4、其他要求(1)输入时具备一定的容错性判断,如输入的不是数字,或输入的数超过范围等等。
(2)变量、函数命名符合规范。
(3)注释详细:每个变量都要求有注释说明用途;函数有注释说明功能,对参数、返回值也要以注释的形式说明用途;关键的语句段要求有注释解释。
(4)程序的层次清晰,可读性强。
二、需求分析1)课题要求已说明结果不能用long int型的变量来保存,要求用链表来存储。
,首先要定义一个节点类,在这里定义一个双向节点类。
2)定义一个BigInteger大整数类,使其能够存放大数阶乘,并实现其的四则运算。
3)对输入整数的合法性进行检查,必须考虑用户各种输入情况。
c语言阶乘循环结构
c语言阶乘循环结构阶乘是数学中的一个概念,指一个正整数n与小于等于n的所有正整数的积,通常用n!表示。
例如,5! = 5 × 4 × 3 × 2 × 1 = 120。
在计算机编程中,阶乘是一个常见的问题,也是循环结构的一个经典案例。
在C语言中,我们可以使用循环结构来计算阶乘。
具体来说,我们可以使用for循环或while循环来实现。
下面是使用for循环计算阶乘的代码:```#include <stdio.h>int main() {int n, i, fact = 1;printf("请输入一个正整数:");scanf("%d", &n);for (i = 1; i <= n; i++) {fact *= i;}printf("%d的阶乘是%d\n", n, fact);return 0;}```在上面的代码中,我们首先定义了三个变量n、i和fact,其中n 表示要计算阶乘的正整数,i表示循环变量,fact表示阶乘的结果。
然后,我们使用for循环从1到n遍历所有的正整数,并将它们的乘积累加到fact中。
最后,我们输出计算结果。
除了使用for循环,我们还可以使用while循环来计算阶乘。
下面是使用while循环计算阶乘的代码:```#include <stdio.h>int main() {int n, i = 1, fact = 1;printf("请输入一个正整数:");scanf("%d", &n);while (i <= n) {fact *= i;i++;}printf("%d的阶乘是%d\n", n, fact);return 0;}```在上面的代码中,我们首先定义了三个变量n、i和fact,其中n 表示要计算阶乘的正整数,i表示循环变量,fact表示阶乘的结果。
长整数四则运算+阶乘+乘方=数据结构课程设计(保证原创性)
数据结构课程设计报告题目:长整数四则运算学院计算机学院专业计算机科学与技术年级班别2010级四班学号3110006015学生姓名张法光指导教师张巍成绩____________________2012年6月一、需求分析1、设计一个实现任意长的整数进行四则运算的程序。
2、利用双向循环链表实现长整数的存储,每个结点含一个整型变量。
3、输入和输出形式是按中国对于长整数的表示习惯,每四位一组,组间用逗号隔开,长整数位数没有上限,以分号结束长整型数据的输入。
4、实现长整数四则运算、阶乘和乘方运算。
4、测试数据:(以加法为例)(1)、0;0;+;应输出“0”。
(2)、-2345,6789;-7654,3211;+;应输出“-1,0000,0000”。
(3)、-9999,9999;1,0000,0000,0000;+;应输出“9999,0000,0001”.(4)、1,0001,0001;-1,0001,0001;+;应输出“0”.(5)、1,0001,0001;-1,0001,0000;+;应输出“1”。
(6)、-9999,9999,9999;-9999,9999,9999;+;应输出“-1,9999,9999,9998”.(7)1,0000,9999,9999;1;+;应输出“1,0001,0000,0000”.二、概要设计为了实现上述功能,采取双向循环链表表示长整数,每个结点含一个整型变量,且仅绝对值不超过9999的整数,整个链表用十进制数表示。
利用头结点数据域的符号表示长整数的符号,相加过程不破坏两个操作数链表,对长整数位数不作上限。
为此需要两个结构数据类型:双向循环链表和长整数,两个类型采用相同的结构,只是双向循环链表用来存储数据,长整型用表示数据的运算。
1、双向循环链表的数据结构及操作定义如下:typedef int Status;typedef int ElemType;typedef struct DuLNode //双向循环链表结点{ElemType data;struct DuLNode * prior;struct DuLNode * next;}DuLNode,* DuLinkList;typedef struct //双向循环链表{DuLinkList head; //双向循环链表头结点,不存放数据int len; //双向循环链表中的结点个数,头结点不计}LinkList;基本操作:Status InitList(LinkList &L);//构造一个空的线性链表void ClearList(LinkList &L);//将线性链表L重置为空表,并释放原链表的结点空间Status HeadInser(LinkList &L,ElemType e);//在线性链表的头结点后插入数据元素为e的新结点Status TailInser(LinkList &L,ElemType e);//在线性链表的头结点前插入数据元素为e的新结点Status HeadDelete(LinkList &L);//删除头结点后的第一个结点Status ListCopy(LinkList &L,LinkList L1);//将L1复制给L,保持L1不变2、长整数的数据类型和和操作定义为:void ScanNum(LinkList &L);//从键盘输入一个长整数,存至L;void PrintNum(LinkList L);//在屏幕打印长整数Lvoid NumChange(LinkList &L);//将长整数L还原成一般格式Status NumLarger(LinkList L1,LinkList L2);//比较正数L1与正数L2的大小,若L1大于或等于L2,返回TRUE,否则返回FALSE void NumPlus(LinkList L1,LinkList L2,LinkList &L3);//将L1与L2相加,结果存至L3; 即C=A+B;void NumMinus(LinkList L1,LinkList L2,LinkList &L3);//计算L1减去L2的值,结果存至L3;即C=A-B;void NumMul(LinkList L1,LinkList L2,LinkList &L3);//将L1与L2相乘,结果存至L3;即C=A*B;Status NumDiv(LinkList L1,LinkList L2,LinkList &L3,LinkList &L4);即C=A/B;//计算L1除以L2,商存至L3,余数存至L4,若L2为零,返回ERROR,否则返回OKStatus jiecheng(LinkList L1,LinkList &L2)即C=A!;//求L1的阶乘L2;若L1小于零,返还ERROR;否则返回OK;Status chengfang(LinkList L1,LinkList L2,LinkList &L3) 即C=A^B;//求L1的L2次方的结果,若L2小于零,返还ERROR;否则返回OK;3、本程序包含四个模块:1)主程序模块:void main( ) //main.c{初始化;do{接受命令;处理命令;}while(“命令”=“结束”)}2)双向循环链表处理模块//LinkList.h;3)长整数运算模块//LongNum.h ,jiecheng.h , chengfang.h;4)界面模块 //Interface.h各模块之间的调用关系如下:主程序模块==========================================长整数运算模块界面模块======================双向循环链表处理模块=======================三、详细设计1、主要函数主程序模块//main.c双向循环链表处理模块//LinkList.h长整数四则运算模块//LongNum.h阶乘运算模块//jiecheng.h乘方运算模块//chengfang.h界面模块//Interface.hchar ShowMenu() //界面菜单显示char ShowPlus() //加法运算显示char ShowMinus() //减法运算显示char ShowMul() //乘法运算显示char ShowDiv() //除法运算显示char Showchengfang()//乘方运算显示char Showjiecheng() //阶乘运算显示2、函数的主要调用关系图InitList ClearList Interface=============================ShowScanNumJiecheng chengfang NumMinus NumChange======================================================================四、调试分析及编程心得体会刚开始使用C指针有偏颇,通过逐步调试修正错误。
c语言计算阶乘
c语言计算阶乘C语言是一门广泛应用于各类编程领域的编程语言。
在数学计算中,阶乘是一个重要的概念,指从1开始连乘到某个正整数n。
本文将介绍C语言如何计算阶乘,并为读者展示如何编写阶乘计算程序。
1. 什么是阶乘?阶乘是一个数列,它的每一个元素是对应正整数的阶乘结果。
例如:5!=5×4×3×2×1=120。
阶乘在计算组合、排列等问题时具有重要的应用。
C语言可以通过循环方式来计算阶乘。
2. 用C语言计算阶乘在C语言中,我们可以使用for循环和while循环两种方式来实现阶乘计算。
下面是使用for循环实现阶乘计算的代码:#include <stdio.h>int main(){int num, fact = 1, i;printf("请输入一个正整数:");scanf("%d", &num);for(i=1; i<=num; i++){fact = fact * i;}printf("%d的阶乘为:%d\n", num, fact);return 0;}在这段代码中,我们首先定义了三个变量:一个用于存储用户输入的正整数,一个用于存储阶乘结果的变量fact,以及一个用于循环计算的变量i。
然后通过scanf()函数从用户输入中获取需要计算阶乘的正整数。
接下来使用for循环对正整数进行循环,计算阶乘结果。
最后使用printf()函数输出计算结果。
注意,这里使用%d 格式符来输出整型变量。
3. 计算阶乘的局限性在实际使用中,计算阶乘可能会遇到计算结果溢出的问题。
因为阶乘的结果往往非常大,可能会超出C语言的数据类型能够表示的范围。
此时,我们可以使用高精度计算的方法来解决这个问题。
通过定义一个结构体变量来存储阶乘计算的结果,可以避免溢出问题。
4. 总结在本文中,我们介绍了C语言计算阶乘的方法,以及如何避免计算结果溢出的问题。
c语言大数加法、阶乘和乘法
c语⾔⼤数加法、阶乘和乘法⼀.⼤数加法定义两个⾜够⼤的数字,其数值远超过long的取值范围,设该⼤数的位数有两百位,求其相加所得⼤数加法的核⼼思想详见此链接,内有详细的动画演⽰,这⾥不再赘述直接上代码:#include<string.h>#include<stdio.h>#define N 10//定义当前⼀个⾜够⼤的数字为10位,可任意更改void print_num(int a[],int n){int i=n-1;//从逆序数组的最后⼀项开始查找,进⾏反逆序while(a[i]==0)//由于规定的数组⽐真实计算的数字⼤,所以数组最后⼏位必定存在0的情况--i;//这种情况下⼀定要将0舍去,否则会抬⾼数组的位数for(;i>=0;i--)//找到⾮零的数组,进⾏反逆序输出printf("%d",a[i]);}void plus(int num1[],int num2[],int n){//尤其注意!由于数组是逆序的,所以num[0]是个位,num[1]是⼗位,num[2]是百位for(int i=0,up=0;i<n;i++)//算法参考⼩学加法,这⾥定义⼀个up进位标记{int temp=num1[i]+num2[i]+up;//up最开始设为0,因为在个位⽆法获取进位num1[i]=temp%10;//若产⽣进位⾏为,则选取个位部分赋给num1up=temp/10;//在个位上,若个位相加产⽣进位,则⽤temp/10取整加到下⼀次的⼗位上}print_num(num1, n);}int main(){char buffer1[]="123456";//缓冲数组,将当前数组倒序写⼊num1中char buffer2[]="78951234";//同上,写⼊num2中int num1[N]={0};//将num1,2全部置为0,⽤来将缓冲数组写⼊到num数组当中int num2[N]={0};int n=N;//定义上述两个数组的长度为10for(int i=0,temp=(int)strlen(buffer1)-1;temp>=0;temp--)num1[i++]=buffer1[temp]-'0';//⽤倒序的⽅式将缓冲数组写⼊num中,意味着num的第⼀位是个位,第⼆位是⼗位,三是百位...for(int i=0,temp=(int)strlen(buffer2)-1;temp>=0;temp--)num2[i++]=buffer2[temp]-'0';plus(num1, num2, n);//将两数字相加printf("\n");}⼆.⼤数阶乘⼤数阶乘的中⼼思想参考上述视频和⼀篇博客,博客详情:但是,这⾥需要说明⼀个点:1*2=2,将2存到a[0]中,接下来是⽤a[0]*3;2*3=6,将6储存在a[0]中,接下来是⽤a[0]*4;6*4=24,是两位数,那么24%10==4存到a[0]中,24/10==2存到a[1]中,接下来是⽤a[0]*5;a[1]*5+num(如果前⼀位相乘结果位数是两位数,那么num就等于⼗位上的那个数字;如果是⼀位数,num==0)24*5=120,是三位数,那么120%10==0存到a[0]中,120/10%10==2存到a[1]中,120/100==1存到a[2]中由于上述博客存在某些地⽅没有说清楚的情况,这⾥解释⼀下关于上述博客的Q&A:1.这⾥的num指的是什么?答:这⾥的num指的是前⾯两数值相乘后进位数位多少:例如6*4得24,这⾥的num值的是24/10=2,进位数为2,num=22.下⾯代码为什么要充i=2开始?答:如果这⾥看懂了代码其实理解2不是很难,但是没有看懂是真的难懂:⾸先明确⼀点:5的阶乘是1*2*3*4*5,我定义的value数组的第⼀位为1,⽽我的i是从2起的,这样以来不就直接凑出了1*2了吗?当我的i⾃增到3,我直接在value数组中找出1*2的值,拿他们去和3相乘,也就凑成了1*2*3了3.如何在代码当中表现出进位的思想?答:我们以5!为例,当计算到1*2*3*4的时候,value当中的表现形式是42000000,从左到右依次是个位,⼗位,百位,千位...etc(value表⽰的是24这个数字)我们在关于j的循环当中拿i=5去和value数组求乘积:5先和位于个位的4求积得20:20%10得0,0放⼊个位中;20/10得2,进位为2,up=2。
vb课程设计报告阶乘
vb课程设计报告阶乘一、教学目标本章节的教学目标是让学生掌握阶乘的概念,理解阶乘的计算方法,能够运用阶乘解决相关问题。
具体分为以下三个部分:1.知识目标:使学生了解阶乘的定义,掌握阶乘的计算规则,能够准确地计算任意正整数的阶乘。
2.技能目标:培养学生运用阶乘解决实际问题的能力,能够运用编程语言(如VB)实现阶乘的计算。
3.情感态度价值观目标:培养学生对数学的兴趣,激发学生探究数学问题的热情,培养学生的团队合作精神。
二、教学内容本章节的教学内容主要包括阶乘的定义、阶乘的计算方法以及运用阶乘解决实际问题。
具体分为以下三个部分:1.阶乘的定义:介绍阶乘的概念,解释阶乘的计算规则。
2.阶乘的计算方法:教授如何利用递归法、循环法等方法计算阶乘。
3.运用阶乘解决实际问题:通过编程语言(如VB)实现阶乘的计算,让学生学会运用阶乘解决相关问题。
三、教学方法为了达到本章节的教学目标,将采用以下教学方法:1.讲授法:教师讲解阶乘的定义、计算方法以及运用阶乘解决实际问题。
2.讨论法:学生分组讨论,分享各自的解题思路和编程方法。
3.案例分析法:分析典型的阶乘问题,引导学生运用阶乘解决实际问题。
4.实验法:学生动手实践,利用编程语言(如VB)实现阶乘的计算。
四、教学资源为了支持本章节的教学内容和教学方法,将准备以下教学资源:1.教材:提供相关章节,介绍阶乘的定义、计算方法以及运用阶乘解决实际问题。
2.参考书:提供数学及相关领域的参考书籍,丰富学生的知识体系。
3.多媒体资料:制作PPT、视频等资料,帮助学生更好地理解阶乘的概念和计算方法。
4.实验设备:提供计算机等设备,让学生动手实践,利用编程语言(如VB)实现阶乘的计算。
五、教学评估本章节的评估方式将包括以下几个部分:1.平时表现:评估学生在课堂上的参与程度、提问回答情况以及小组合作的表现。
2.作业:评估学生提交的阶乘相关练习题,包括计算题和编程题。
3.考试:设计一份包含阶乘知识点的考试,评估学生对阶乘的理解和应用能力。
大数阶乘c语言程序
大数阶乘c语言程序下面是一个计算大数阶乘的C 语言程序:c#include <stdio.h>#include <stdlib.h>/* 定义一个结构体来表示大数*/typedef struct {unsigned int digits[1000]; 数字数组int length; 数字长度} BigNum;/* 初始化大数为1 */void init(BigNum *p) {int i;for (i = 0; i < 1000; i++) {p->digits[i] = 0;}p->digits[0] = 1;p->length = 1;}/* 大数乘法*/void multiply(BigNum *p, int n) {int i, carry = 0;for (i = 0; i < p->length; i++) {int value = p->digits[i] * n + carry;p->digits[i] = value % 10;carry = value / 10;}while (carry > 0) {p->digits[p->length] = carry % 10;p->length++;carry /= 10;}}/* 计算阶乘*/void factorial(int n) {BigNum result;init(&result);int i;for (i = 1; i <= n; i++) {multiply(&result, i);}printf("%d! = ", n);for (i = result.length - 1; i >= 0; i) {printf("%d", result.digits[i]);}printf("\n");}int main() {int n;printf("请输入要计算的阶乘:");scanf("%d", &n);if (n < 0) {printf("错误:阶乘不能为负数!\n");return 0;}if (n > 1000) {printf("错误:阶乘过大!\n");return 0;}factorial(n);return 0;}这个程序使用一个自定义的`BigNum` 结构体来表示大数,其中`digits` 数组存储数位,`length` 表示数字的长度(即数位数)。
python计算阶乘
python计算阶乘Python作为一种跨平台的编程语言,不仅具有简单易学、可读性好等特点,在解决复杂计算问题上也表现出了较强的能力。
本文将介绍如何使用Python语言来计算阶乘。
首先,我们来解释下什么是阶乘。
阶乘的定义是:任意一个正整数的阶乘,即从1乘以该正整数至本身之积,符号表示为:n!,其结果可以表示为:n!=1*2*3*…*n。
下面我们就来演示如何使用Python来计算阶乘。
首先,我们定义一个函数,带有一个参数n,表示要进行计算的数字。
def factorial(n):#来保存计算结果result = 1#环,从1乘以nfor i in range(1,n+1):# 依次将结果乘以1,2,3,…,nresult *= ireturn result# 使用函数print(factorial(5))上面的代码,我们定义了一个factorial函数,该函数接受一个参数n,表示要计算的阶乘数字,然后在函数内部使用一个for循环,从1乘以n,依次将结果乘以1,2,3,…,n,最终将计算结果返回。
最后,我们可以把该函数用在多种场景中,例如,计算5!,我们只需要调用factorial(5),就可以得到答案120。
但是,有时候,我们可能需要计算更大的数字,此时,我们可以通过定义一个较大的数来进行计算。
例如,当计算1000的阶乘,我们可以定义MAXNUMBER = 1000,然后使用for循环,将MAXNUMBER 乘以1,2,3,…,1000,最终得出计算结果。
与其他语言相比,Python语言计算阶乘更加简单,可读性更强,在计算阶乘时,可以很快捷地实现。
上面的示例代码表明,通过定义一个函数,使用for循环,就可以实现阶乘的计算。
这种方法有利于快速计算阶乘,也可以减少代码的复杂度。
此外,在Python中,还有一些模块可以提供更高级的计算功能,比如math模块,可以用来计算大数的阶乘,该模块中提供了一个factorial函数:from math import factorial# 使用函数print(factorial(1000))上面代码中,我们使用了math模块中的factorial函数,可以非常容易地实现对大数的阶乘计算,在实际应用中,可以根据计算阶乘的实际需求,选择适当的计算方法。
n的阶乘程序设计
n的阶乘程序设计n的阶乘是一个在计算机编程中常见的问题,它指的是一个正整数n的连乘积,通常表示为n!。
例如,5! = 5 × 4 × 3 × 2 × 1 = 120。
阶乘程序设计可以采用多种不同的方法,包括递归、迭代、尾递归优化等。
下面将详细介绍几种常见的阶乘程序设计方法。
1. 迭代法迭代法是一种使用循环来计算阶乘的方法。
它从1开始,逐步乘以2、3、...直到n。
这种方法的优点是简单易懂,且在计算过程中不需要额外的内存空间。
```pythondef factorial_iterative(n):result = 1for i in range(1, n + 1):result *= ireturn result```2. 递归法递归法是一种通过函数自我调用来解决问题的方法。
在阶乘问题中,递归函数可以定义为`n! = n * (n-1)!`,当n为1时,递归终止。
```pythondef factorial_recursive(n):if n == 1:return 1else:return n * factorial_recursive(n - 1)```递归方法虽然简洁,但当n较大时,可能会导致栈溢出错误。
3. 尾递归优化尾递归是一种特殊的递归形式,它可以被编译器优化以减少内存使用。
在尾递归中,递归调用是函数体中的最后一个操作。
```pythondef factorial_tail_recursive(n, accumulator=1):if n == 1:return accumulatorelse:return factorial_tail_recursive(n - 1, n * accumulator)```尾递归优化可以减少递归调用的内存消耗,但并非所有编译器都支持这种优化。
4. 动态规划动态规划是一种通过存储中间结果来避免重复计算的方法。
在阶乘问题中,可以预先计算较小的阶乘值,并用它们来构建较大的阶乘值。
C语言课程设计大整数运算
C语⾔课程设计⼤整数运算明⼈不说暗话,直接上,输⼊提取码baxj即可下载。
该⼤整数运算系统⽤于对有符号的位数不超过500位的⼤整数进⾏加、减、乘、除四则运算和计算N(0<=N<=10000)的阶乘。
注意事项:1、操作期间,进⾏四则运算时若⼤整数为正数请直接省略‘+ ’号。
\n");2、该⼤整数运算系统设定处理位数不超过500位的⼤整数四则运算和计算N(0<=N<=10000)的阶乘,可根据情况调整相关程序参数,进⾏位数更⼤的四则运算和N值更⼤的阶乘计算。
3、为了保证程序设计流程的简捷性,该系统没有很⾼的操作容错性能,所以欲执⾏某项功能,请务必根据提⽰输⼊正确的选项值进⾏操作。
课程设计中包含程序,程序运⾏所需⽂件,设计报告(电⼦版和打印版),应有尽有,欢迎⼩伙伴们在本博客的⽂件中下载使⽤。
下⾯的程序正常运⾏需要在百度⽹盘中下在相应输出⽂件,否则⽆法正常使⽤哦。
1 #include<stdio.h>2 #include<string.h>3 #include<stdlib.h>4 #include<ctype.h>5 #include <conio.h>6const int N1=40000;7const int N2=510;89void Display(); //显⽰主菜单10char* Input(char str[]); //输⼊11void Output(int result[],int j); //输出12int Add(char str1[],char str2[],int result[]); //相加13int Sub(char str1[],char str2[],int result[]); //相减14int Mul(char str1[],char str2[],int result[]); //相乘15int Div(char str1[],char str2[],int result[]); //相除16int Fac(int n,int result[]); //计算阶乘17int Substract(int *bjs,int *js,int Num_len1,int Num_len2); //计算差的位数18//以上函数返回值为int类型的均是结果的⾸位⾮零数字在数组中的下标,⼩于0表⽰⽆结果不输出19int IsBig_num(char str1[],char str2[]); //⽐较2021int main()22 {23int select,op,n,rs=-1,result[N1];24//rs表⽰该数的⾸位⾮零数字在数组中的下标,⼩于0表⽰⽆结果不输出25char str1[N2],str2[N2],*Fir_num,*Sec_num;26while(1)27 {28 Display();29 printf("\n请输⼊欲执⾏功能的选项值(0-4): ");30 scanf("%d",&select);31switch(select)32 {33case1:34 printf("\n\t\t1 加法运算\n");35 printf("\n\t\t2 减法运算\n");36 printf("\n\t\t3 乘法乘法\n");37 printf("\n\t\t4 除法运算\n");38 printf("\n请输⼊对应运算的选项值(1-4): ");39 scanf("%d",&op);40 memset(result,0,sizeof(result));41switch(op)42 {43case1:44 printf("\n请输⼊⼀个不超过500位的⼤整数作为⼀个加数\n");45 Fir_num=Input(str1);46 printf("\n请输⼊另⼀个不超过500位的⼤整数作为另⼀个加数\n");47 Sec_num=Input(str2);48 printf("\n两数之和为\n");49 rs=Add(Fir_num,Sec_num,result);50break;51case2:52 printf("\n请输⼊⼀个不超过500位的⼤整数作为被减数\n");53 Fir_num=Input(str1);54 printf("\n请输⼊另⼀个不超过500位的⼤整数作为减数\n");55 Sec_num=Input(str2);56 printf("\n两数之差为\n");57 rs=Sub(Fir_num,Sec_num,result);58break;59case3:60 printf("\n请输⼊⼀个不超过500位的⼤整数作为⼀个因数\n");61 Fir_num=Input(str1);66break;67case4:68 printf("\n请输⼊⼀个不超过500位的⼤整数作为被除数\n");69 Fir_num=Input(str1);70 printf("\n请输⼊另⼀个不超过500位的⼤整数作为除数\n");71 Sec_num=Input(str2);72 printf("\n两数之商为\n");73 rs=Div(Fir_num,Sec_num,result);74break;75default:76 printf("\n⽆效输⼊\n");77 }78break;79case2:80 printf("\n请输⼊N(0<=N<=10000)\n");81 scanf("%d",&n);82if(n>10000||n<0)83 printf("\n错误输⼊(0<=N<=10000)\n");84else85 {86 memset(result,0,sizeof(result));87 rs=Fac(n,result);88 printf("\n%d!为\n",n);89 }90break;91case3:92 FILE *fp;93if(NULL==(fp=fopen("系统简介.txt","r")))94 printf("⽂件打开失败!\n");95char ch1;96while(EOF != (ch1=fgetc(fp)))97 {98 printf("%c",ch1);99 }100 fclose(fp);101break;102case4:103 FILE *fq;104if(NULL==(fq=fopen("开发⼈员.txt","r")))105 printf("⽂件打开失败!\n");106char ch2;107while(EOF != (ch2=fgetc(fq)))108 {109 printf("%c",ch2);110 }111 fclose(fq);112break;113case0:114return0;115default:116 printf("\n⽆效输⼊\n");117 }118if(rs >= 0)119 {120 Output(result,rs);121 rs=-1;122 }123 printf("\n__________________________________________\n"); 124 printf("\n按任意键继续 . . . ");125 getch();126 system("cls");127 }128 }129//主菜单130void Display(void)131 {132 printf("\n* * * * * * * * * * * * * * * * * * * * *\n");133 printf("\t ⼤整数运算系统 \n");134 printf("* * * * * * * * * * * * * * * * * * * * *\n");135 printf("\t\t1 四则运算\t \t\n");136 printf("\t\t2 计算N! \t\t\n");137 printf("\t\t3 系统简介 \t\t\n");138 printf("\t\t4 开发⼈员 \t\t\n");139 printf("\t\t0 退出 \t\t\n");140 printf("* * * * * * * * * * * * * * * * * * * * *\n");141 }142//输⼊函数143char* Input(char str[])144 {145 scanf("%s",str);150 p--;151return p;152 }153//输出函数154void Output(int result[],int j)155 {156int i;157for(i=j;i>=0;i--)158 printf("%d",result[i]);159 printf("\n");160 }161//加法函数162int Add(char str1[],char str2[],int result[])163 {164int Num_len1,Num_len2,l,i,j;165if(str1[0]=='-'||str2[0]=='-')166 {167if(str1[0]=='-'&&str2[0]=='-')168 {169 printf("-");170 str1++;171 str2++;172 }173else174 {175if(str1[0]=='-')176 {177if(IsBig_num(str1+1,str2)==0)178return0;179else if(IsBig_num(str1+1,str2)<0)180return Sub(str2,str1+1,result);181else182 {183 printf("-");184return Sub(str1+1,str2,result);185 }186 }187else188 {189if(IsBig_num(str1,str2+1)==0)190return0;191else if(IsBig_num(str1,str2+1)>0)192return Sub(str1,str2+1,result);193else194 {195 printf("-");196return Sub(str2+1,str1,result);197 }198 }199 }200 }201 strrev(str1);202 strrev(str2);203 Num_len1=strlen(str1);204 Num_len2=strlen(str2);205if(Num_len1>=Num_len2) {//按较⼤数的位数将⼩数⾼位⽤0补齐206 l=Num_len1;207for(i=Num_len2;i<l;i++)208 str2[i]='0';209 }210else{211 l=Num_len2;212for(i=Num_len1;i<l;i++)213 str1[i]='0';214 }215for(i=0;i<l;i++){216 result[i] += str1[i]-'0'+str2[i]-'0';//⼀⼀对应-'0'217if(result[i] > 9)218 {219 result[i] %= 10;220 result[i+1]++;//进位221 }222 }223for(j=i;j>=0;j--)224if(result[j])//返回结果的⾮零⾸位在数组中的下标225return j;226return0;227 }228//减法函数229int Sub(char str1[],char str2[],int result[])234 {235if(str1[0]=='-'&&str2[0]=='-')236 {237if(IsBig_num(str1+1,str2+1)==0)238return0;239else if(IsBig_num(str1+1,str2+1)<0) 240 {241 temp=str2++;242 str2=str1++;243 str1=temp;244 }245else246 {247 printf("-");248 str1++;249 str2++;250 }251 }252else253 {254if(str1[0]=='-')255 {256 printf("-");257return Add(str1+1,str2,result);258 }259else260return Add(str1,str2+1,result);261 }262 }263else264 {265if(IsBig_num(str1,str2)==0)266return0;267else if(IsBig_num(str1,str2)<0)268 {269 printf("-");270 temp=str2;271 str2=str1;272 str1=temp;273 }274 }275 Num_len1=strlen(str1);276 Num_len2=strlen(str2);277 strrev(str1);278 strrev(str2);279if(Num_len1>Num_len2){//⾼位补零280for(i=Num_len2;i<Num_len1;i++)281 str2[i]='0';282 }283for(i=0;i<Num_len1;i++) {284 result[i] += (str1[i]-'0') - (str2[i]-'0');285if(result[i] < 0){286 result[i] += 10;287 result[i+1]--;288 }289 }290for(i=Num_len1-1;i>=0;i--)291if(result[i])292return i;293return0;294 }295//乘法函数296int Mul(char str1[],char str2[],int result[])297 {298int i,j,Num_len1,Num_len2;299if(str1[0]=='-'||str2[0]=='-')300 {301if(str1[0]=='-'&&str2[0]=='-')302 {303 str1++;304 str2++;305 }306else307 {308 printf("-");309if(str1[0]=='-')310 str1++;311if(str2[0]=='-')312 str2++;313 }318 strrev(str2);319//乘积320for(i=0;i<Num_len1;i++)321for(j=0;j<Num_len2;j++)322 result[i+j] += (str1[i]-'0')*(str2[j]-'0');323//处理进位324for(i=0;i<N2*2;i++) {325if(result[i] > 9)//先计算进位,否则前⾯的值先改变,不能进位326 {327 result[i+1] += result[i] / 10 ;328 result[i] %= 10;329 }330 }331//输出332for(i=2*N2;i>=0;i--)333if(result[i])334return i;335return0;336 }337//除法函数338int Div(char str1[],char str2[],int result[])339 {340int a[N2],b[N2];341int i,j,k,Num_len1,Num_len2,n;342if(str1[0]=='-'||str2[0]=='-')343 {344if(str1[0]=='-'&&str2[0]=='-')345 {346 str1++;347 str2++;348 }349else350 {351 printf("-");352if(str1[0]=='-')353 str1++;354if(str2[0]=='-')355 str2++;356 }357 }358 Num_len1=strlen(str1);359 Num_len2=strlen(str2);360if(Num_len2==1 && str2[0]=='0'){361 printf("错误输⼊(除数不能为零)\n");362return -1;363 }364 memset(a,0,sizeof(a));//数组初始化365 memset(b,0,sizeof(b));366for(j=0,i=Num_len1-1;i>=0;i--)367 a[j++]=str1[i]-'0';368for(j=0,i=Num_len2-1;i>=0;i--)369 b[j++]=str2[i]-'0';370371 Num_len1=Substract(a,b,Num_len1,Num_len2);372if(Num_len1<=0){373if(Num_len1<0) {374return0;//第⼀次减时不够减为375 }376else {377 result[0]=1;//正好够减商为378return0;379 }380 }381 result[0]++;382 n=Num_len1-Num_len2;383if(n<0) {384 result[0]=1; //减过⼀次不够减商为385return0 ;386 }387else if(n>0) {388for(i=Num_len1-1;i>=0;i--) {//将减数逆置389if(i>=n)//倒着存储当i⼤于等于n时,将i的位置存i-n的值,否则存0 390 b[i]=b[i-n];391else392 b[i]=0;393 }394 }395 Num_len2=Num_len1;396for(j=0;j<=n;j++) {397while( (k=Substract(a,b+j,Num_len1,Num_len2-j)) >= 0)//传递对应的参数403for(i=0;i<N2;i++){404if(result[i]>=10)405 result[i+1] += result[i]/10;//先进位再处理本位406 result[i] %= 10;407 }408for(i=N2;i>=0;i--)409if(result[i])410return i;411return0;412 }413//计算差的长度函数414int Substract(int *bjs,int *js,int Num_len1,int Num_len2)415 {416int i;417if(Num_len1<Num_len2)418return -1;419bool bLarge=false;//长度相等的⼩于420if(Num_len1==Num_len2) {421for(i=Num_len1-1;i>=0;i--) {422if(bjs[i]>js[i])423 bLarge=true;424else if(bjs[i]<js[i]) {425if(!bLarge)426return -1;427 }428 }429 }430for(i=0;i<Num_len1;i++) {431 bjs[i] -= js[i];432if(bjs[i]<0) {433 bjs[i] += 10;434 bjs[i+1]--;435 }436 }437for(i=Num_len1-1;i>=0;i--)438if(bjs[i])439return i+1;//返回长度加1440return0;441 }442//计算阶乘函数443int Fac(int n,int result[])444 {445int i,j,k,jw,t;446 result[0]=1;447for(k=1, i=1;i<=n;i++){448for(jw=0, j=0;j<k;j++){449 t = result[j]*i + jw;450 result[j] = t%10;451 jw = t/10;452 }453while(jw)//直到上⼀个阶乘结果处理完后,将结果数组扩⼤,存进进位数即可454 {455 result[++k -1]= jw%10;456 jw /= 10;457 }458 }459return k-1;460 }461//⽐较函数462int IsBig_num(char str1[],char str2[])463 {464int Num_len1,Num_len2;465 Num_len1=strlen(str1);466 Num_len2=strlen(str2);467if(Num_len1<Num_len2)468return -1;469else470 {471if(Num_len1==Num_len2)472 {473if(strcmp(str1,str2)==0)474return0;475else476 {477if(strcmp(str1,str2)<0)478return -1;479else480return1;481 }。
阶乘的计算和处理程序设计
阶乘的计算及处理程序设计一、问题描述要求输入一个自然数n,求n!,同时统计结果中有几个0。
二、课题分析1)计算n!。
2)统计0的个数。
三、数据结构的设计x:输入的数ni:n!b:储存数据i上的各位上的数,从而判断b是否为0j:统计0的个数四、处理结构的设计建立两个函数f1和f2,使f1函数起到求阶乘的作用,f2函数起到求0个数的作用。
求阶乘流程图计算0的个数流程五、源程序1)主要结构体:f1函数:long int f1(int x){long int i; //声明长整型变量iif (x==0||x==1) //采用递归函数f1求阶乘i=1;elsei=f1(x-1)*x;return (i);}f2函数:int f2(int i){int j=0;int b=0;while(i>=10) //循环结构,判断末位是否为零,再去末位{b=i %10;if(b==0)j++;i=i/10;}return (j);}2)整体:#include <stdio.h>long int f1(int x){long int i;if (x==0||x==1)i=1;elsei=f1(x-1)*x;return (i);}int f2(int i){int j=0;int b=0;while(i>=10){b=i %10;if(b==0)j++;i=i/10;}return (j);}void main(){long int f1(int x);int f2(int x);long int k;int n,i;printf("please input n:");scanf("%d",&n);k=f1 (n);i=f2 (k);printf("%d! is %ld\nthere are %d zero!\n",n,k,i);六、调试记录1)所遇问题:在调用两个函数的时候采用k=f1 (n);i=f2 (n);使得输出的时候,界面显示是please input n:8! is 40320there are 0 zeroplease any key to continue而后才发现是因为传递的是n的值,改成k(即n!)后,程序运行正确。
c语言1到20的阶乘求和结果
C语言是一种广泛应用的计算机编程语言,其语法简单、程序结构清晰,因此备受程序员们的青睐。
在C语言的学习过程中,阶乘和求和是其中的基础知识之一,本文将介绍C语言中1到20的阶乘求和结果。
1. 阶乘的概念阶乘是指从1到某个正整数 n 的所有整数相乘的结果,用符号 n! 表示,其中0的阶乘定义为1。
5的阶乘为5! = 5 * 4 * 3 * 2 * 1 = 120。
2. C语言实现阶乘求和在C语言中,我们可以使用循环结构来实现求阶乘和求和的操作。
下面是求1到20的阶乘和的C语言代码示例:```c#include <stdio.h>int m本人n() {int i, j;long long sum = 0; // 使用长整型变量存储求和结果long long fact = 1; // 使用长整型变量存储阶乘结果for (i = 1; i <= 20; i++) {fact = 1; // 每次循环开始时,将阶乘结果重置为1for (j = 1; j <= i; j++) {fact *= j; // 求阶乘}sum += fact; // 将当前阶乘结果累加到求和中}printf("1到20的阶乘求和结果为:lld\n", sum);return 0;}```3. 代码分析上述代码首先定义了两个整型变量 i 和 j,以及两个长整型变量 sum 和 fact,其中 sum 用于存储求和结果,fact 用于存储阶乘结果。
然后使用嵌套的两层循环来分别计算每个数的阶乘并累加到求和中,最终打印出1到20的阶乘求和结果。
4. 运行结果将上述代码保存为factorial.c 文件并使用C语言编译器进行编译后,运行得到的结果为:```1到20的阶乘求和结果为:xxx```可以看到,1到20的阶乘求和结果是一个很大的数,超出了普通整型变量的表示范围,因此在代码中使用了长整型变量来存储结果,确保计算的准确性。
C++与python的大数阶乘
如何用C++和python解决大数阶乘问题1000!是个很大的数,C++中没有能储存这么多位数精确数的数据类型,那么如何解决这个问题呢?可以用字符数组来解决,把每次相乘的结果作为字符数组储存,再分别对每一个字符进行处理,大于等于10的进行进位。
由于字符数组可以有很大的长度,因此可以计算出1000!的精确值。
实际操作中为了方便,把每次相乘的结果到过来存,例如:4!=[4,2,0,0 0C++程序如下:#include<iostream>using namespace std;#define N 1000static int a[N*3];int main(){int i,j;int len=1; //每次得到的阶乘的长度int tem,carry; //临时变量,进位int count=0; //最终结果中1的个数a[1]=1;for(i=2;i<=N;i++){carry=0;for(j=1;j<=len;j++){tem=a[j]*i+carry;a[j]=tem;carry=tem/10;if(j==len&&carry!=0){len++;}}}for(i=len;i>=1;i--){cout<<a[i];if(a[i]==1)count++;}cout<<endl;cout<<len<<endl; //输出最终结果的长度cout<<count<<endl;return 0;}运行结果如下:402387260077093773543702433923003985719374864210714632543799910429938512398629 020592044208486969404800479988610197196058631666872994808558901323829669944590 997424504087073759918823627727188732519779505950995276120874975462497043601418 278094646496291056393887437886487337119181045825783647849977012476632889835955 735432513185323958463075557409114262417474349347553428646576611667797396668820 291207379143853719588249808126867838374559731746136085379534524221586593201928 090878297308431392844403281231558611036976801357304216168747609675871348312025 478589320767169132448426236131412508780208000261683151027341827977704784635868 170164365024153691398281264810213092761244896359928705114964975419909342221566 832572080821333186116811553615836546984046708975602900950537616475847728421889 679646244945160765353408198901385442487984959953319101723355556602139450399736 280750137837615307127761926849034352625200015888535147331611702103968175921510 907788019393178114194545257223865541461062892187960223838971476088506276862967 146674697562911234082439208160153780889893964518263243671616762179168909779911 903754031274622289988005195444414282012187361745992642956581746628302955570299 024324153181617210465832036786906117260158783520751516284225540265170483304226 143974286933061690897968482590125458327168226458066526769958652682272807075781 391858178889652208164348344825993266043367660176999612831860788386150279465955 131156552036093988180612138558600301435694527224206344631797460594682573103790 084024432438465657245014402821885252470935190620929023136493273497565513958720 559654228749774011413346962715422845862377387538230483865688976461927383814900 140767310446640259899490222221765904339901886018566526485061799702356193897017 860040811889729918311021171229845901641921068884387121855646124960798722908519 296819372388642614839657382291123125024186649353143970137428531926649875337218 940694281434118520158014123344828015051399694290153483077644569099073152433278 288269864602789864321139083506217095002597389863554277196742822248757586765752 344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254 742173582401063677404595741785160829230135358081840096996372524230560855903700 624271243416909004153690105933983835777939410970027753472000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000002568239如果用python则很容易实现,实现过程如下:Python 3.2.2 (default, Sep 4 2011, 09:51:08) [MSC v.1500 32 bit (Intel)] on win32Type "copyright", "credits" or "license()" for more information.>>> import math>>> a=str(math.factorial(1000))>>> len(a)2568>>> a.count('1')239>>>。
阶乘程序修改(100以内的阶乘及1000的阶乘)
阶乘程序修改(100以内的阶乘及1000的阶乘)阶乘程序修改以下程序是对50的阶乘的程序的⼀种修改!说明程序经过修改后,能够计算出更⼤的数的阶乘!⽽修改程序的部分,只需要稍微修改⼀个地⽅,程序的主体是没有太多的变化的!说明程序的通⽤性还是⽐较⾼的!//经粗略计算,知100的阶乘不会超过200位,所以⽤200代!#include#define N 200void fun(int);int main(){int i;// int n;//以下三⾏是计算输⼊⼀个数的阶乘// printf("input the number:");// scanf("%d",&n);for(i=1;i<=100;i++) fun(i);//此循环是通过调⽤函数,计算1到100的阶乘return 0;}void fun(int n){int a[N]={1}; //初始化数组,将第⼀个初始化为1,其余为0int i,j,m,b=0,t;for(i=2;i<=n; i++)//⽤循环实现阶乘的累乘{t=2*i;for(j=0; j{m=a[j]*i+b;//⽤⼀个数去乘数组的⼀个元素,得到的结果加上上次剩余的数ba[j]=m%10;//取个位保存到当前位置b=m/10;//去掉个位,保留余下的部分,作为下次累加}//以上三⾏是算法的核⼼}for(i=N-1; i>0; i--) if(a[i]!=0) break; //从后⾯往前⾯查找,直到第⼀个不为零的数printf("%d!=",n);for(j=i; j>=0; j--) //对数组元素进⾏逆序输出,因为存放的时候是从⼩位到⾼位printf("%d",a[j]); printf("\n");}运⾏结果:1!=12!=23!=64!=245!=1206!=7207!=50408!=403209!=36288010!=362880011!=3991680012!=47900160013!=622702080014!=8717829120015!=130767436800016!=2092278988800017!=35568742809600018!=640237370572800019!=12164510040883200020!=243290200817664000021!=5109094217170944000022!=112400072777760768000023!=2585201673888497664000024!=62044840173323943936000025!=1551121004333098598400000026!=40329146112660563558400000027!=1088886945041835216076800000028!=30488834461171386050150400000029!=884176199373970195454361600000030!=26525285981219105863630848000000031!=822283865417792281772556288000000032!=26313083693369353016721801216000000033!=868331761881188649551819440128000000034!=29523279903960414084761860964352000000035!=1033314796638614492966665133752320000000036!=37199332678990121746799944815083520000000037!=1376375309122634504631597958158090240000000038!=52302261746660111176000722410007429120000000039!=2039788208119744335864028173990289735680000000040!=81591528324789773434561126959611589427200000000041!=3345252661316380710817006205344075166515200000000042!=140500611775287989854314260624451156993638400000000043!=6041526306337383563735513206851399750726451200000000044!=265827157478844876804362581101461589031963852800000000045!=11962222086548019456196316149565771506438373376000000000046!=550262215981208894985030542880025489296165175296000000000047!=25862324151116818064296435515361197996919763238912000000000048!=1241391559253607267086228904737337503852148635467776000000000049!=60828186403426756087225216332129537688755283137921024000000000050!=3041409320171337804361260816606476884437764156896051200000000000051!=155111875328738228022424301646930321106325972001698611200000000000052!=8065817517094387857166063685640376697528950544088327782400000000000053!=427488328406002556429801375338939964969034378836681372467200000000000054!=23084369733924138047209274268302758108327856457180794113228800000000000055!=1269640335365827592596510084756651695958032105144943676227584000000000000056!=71099858780486345185404564746372494973649797888116845868744704000000000000057!=405269195048772167556806019054323221349803847962266021451844812800000000000 0058!=235056133128287857182947491051507468382886231818114292442069991424000000000 000059!=138683118545689835737939019720389406345902876772687432540821294940160000000 00000060!=832098711274139014427634118322336438075417260636124595244927769640960000000 000000061!=507580213877224798800856812176625227226004528988036003099405939480985600000 00000000062!=314699732603879375256531223549507640880122807972582321921631682478211072000 0000000000063!=198260831540444006411614670836189813754477369022726862810627959961272975360 000000000000064!=126886932185884164103433389335161480802865516174545192198801894375214704230 40000000000000065!=824765059208247066672317030678549625218625855134543749292212313438895577497 6000000000000000 66!=544344939077443064003729240247842752644293064388798874532860126869671081148 416000000000000000 67!=364711109181886852882498590966054644271676353140495245937016285002679624369 4387200000000000000068!=248003554243683059960099041856917158104739920135536767237171073801822144571 218329600000000000000069!=171122452428141311372468338881272839092270544893520369393648040923257279754 14064742400000000000000070!=119785716699698917960727837216890987364589381425464258575553628646280095827 8984531968000000000000000071!=850478588567862317521167644239926010288584608120796235886430763388588680378 07901769728000000000000000072!=612344583768860868615240703852746727407780917846973289838230149639783849872 2168927420416000000000000000073!=447011546151268434089125713812505111007680070028290501581908009237042210406 718331701690368000000000000000074!=330788544151938641225953028221253782145683251820934971170611926835411235700 97156545925087232000000000000000075!=248091408113953980919464771165940336609262438865701228377958945126558426775 7286740944381542400000000000000000076!=188549470166605025498793226086114655823039453537932933567248798296184404349 553792311772997222400000000000000000077!=145183092028285869634070784086308284983740379224208358846781574688061991349 15642008006520786124800000000000000000078!=113242811782062978314575211587320462287317495794882519900489628256688353252 3420076624508621317734400000000000000000079!=894618213078297528685144171539831652069808216779571907213868063227837990693 50186053336181084101017600000000000000000080!=715694570462638022948115337231865321655846573423657525771094450582270392554 8014884266894486728081408000000000000000000081!=579712602074736798587973423157810910541235724473162595874586504971639017969 389205625618453424974594048000000000000000000082!=475364333701284174842138206989404946643813294067993328617160934076743994734 89914861300713180847916711936000000000000000000083!=394552396972065865118974711801206105714365034076434462752243575283697515629 9662933487959194010377087090688000000000000000000084!=331424013456535326699938757913013128800066628624204948711884603238305913129 171686412988572296871675315617792000000000000000000085!=281710411438055027694947944226061159480056634330574206405101912752560026159 79593345104028645234092401827512320000000000000000000086!=242270953836727323817655232034412597152848705524293817508387644967201622497 4245027678946463490131946557166059520000000000000000000087!=210775729837952771721360051869938959522978373806135621232297251121465411572 759317408068342323641479350473447178240000000000000000000088!=185482642257398439114796845645546284380220968949399346684421580986889562184 02819931910014124480450182841663351685120000000000000000000089!=165079551609084610812169192624536193098396662364965418549135207078331710343 7850973939991257078760066272908038299975680000000000000000000090!=148571596448176149730952273362082573788556996128468876694221686370498539309 406587654599213137088405964561723446997811200000000000000000000091!=135200152767840296255166568759495142147586866476906677791741734597153670771 55999476568528395475044942775116833676800819200000000000000000000092!=124384140546413072554753243258735530775779917158754143568402395829381377109 8351951844304612383704134735310748698265675366400000000000000000000093!=115677250708164157475920516230624043621475322957641353518614228121324680712 146731521520328951684484530383899628938707809075200000000000000000000094!=108736615665674308027365285256786601004186803580182872307497374434045199869 41792763022910921458341545856086565120238534053068800000000000000000000095!=103299784882390592625997020993947270953977463401173728692122505712342939875 9470312487176537538542446856328223686422660735041536000000000000000000000096!=99167793487094968920957140154189380115818364865126779544437605483849222280909149998768947603700074898207509473896575430563987456000000000000000000000097!=961927596824821198533284259495636987123438139191729761581044773193337456124 8187549880587917558907265126128418967967816764706783232000000000000000000000098!=942689044888324774562618574305724247380969376407895166349423877729470707002 322379888297615920772911982360585058860846042941264756736000000000000000000000099!=933262154439441526816992388562667004907159682643816214685929638952175999932 2991560894146397615651828625369792082722375825118521091686400000000000000000000 00100!=93326215443944152681699238856266700490715968264381621468592963895217599993 2299156089414639761565182862536979208272237582511852109168640000000000000000000 00000Process returned 0 (0x0) execution time : 0.641 sPress any key to continue.//稍微做了⼀下修改,1000的阶乘也算出来了,共2568位,后⾯有249个0!^-^#include//经调整得到,1000的阶乘有2568位,为了⽅便书写,设置为3000#define N 3000void fun(int);int main(){fun(1000);//此函数计算1000的阶乘return 0;}void fun(int n){int a[N]={1}; //初始化数组,将第⼀个初始化为1,其余为0int i,j,m,b=0,t;for(i=2;i<=n; i++)//⽤循环实现阶乘的累乘{t=3*i;for(j=0; j{m=a[j]*i+b;//⽤⼀个数去乘数组的⼀个元素,得到的结果加上上次剩余的数ba[j]=m%10;//取个位保存到当前位置b=m/10;//去掉个位,保留余下的部分,作为下次累加}//以上三⾏是算法的核⼼}for(i=N-1; i>0; i--) if(a[i]!=0) break; //从后⾯往前⾯查找,直到第⼀个不为零的数printf("%d!=",n);for(j=i; j>=0; j--) //对数组元素进⾏逆序输出,因为存放的时候是从⼩位到⾼位printf("%d",a[j]);printf("\n");}运⾏结果:1000!=4023872600770937735437024339230039857193748642107146325437999104299385123 9 8629020592044208486969404800479988610197196058631666872994808558901323829669944 5 9099742450408707375991882362772718873251977950595099527612087497546249704360141 8 2780946464962910563938874378864873371191810458257836478499770124766328898359557 3 5432513185323958463075557409114262417474349347553428646576611667797396668820291 2 0737914385371958824980812686783837455973174613608537953452422158659320192809087 8 2973084313928444032812315586110369768013573042161687476096758713483120254785893 2 0767169132448426236131412508780208000261683151027341827977704784635868170164365 0 2415369139828126481021309276124489635992870511496497541990934222156683257208082 1 3331861168115536158365469840467089756029009505376164758477284218896796462449451 6 0765353408198901385442487984959953319101723355556602139450399736280750137837615 3 0712776192684903435262520001588853514733161170210396817592151090778801939317811 4 1945452572238655414610628921879602238389714760885062768629671466746975629112340 8 2439208160153780889893964518263243671616762179168909779911903754031274622289988 0 0519544441428201218736174599264295658174662830295557029902432415318161721046583 2 0367869061172601587835207515162842255402651704833042261439742869330616908979684 8 2590125458327168226458066526769958652682272807075781391858178889652208164348344 8 2599326604336766017699961283186078838615027946595513115655203609398818061213855 8 6003014356945272242063446317974605946825731037900840244324384656572450144028218 8 5252470935190620929023136493273497565513958720559654228749774011413346962715422 8 4586237738753823048386568897646192738381490014076731044664025989949022222176590 4 3399018860185665264850617997023561938970178600408118897299183110211712298459016 4 1921068884387121855646124960798722908519296819372388642614839657382291123125024 1 8664935314397013742853192664987533721894069428143411852015801412334482801505139 9 6942901534830776445690990731524332782882698646027898643211390835062170950025973 8 9863554277196742822248757586765752344220207573630569498825087968928162753848863 3 9690995982628095612145099487170124451646126037902930912088908694202851064018215 4 3994571568059418727489980942547421735824010636774045957417851608292301353580818 4 0096996372524230560855903700624271243416909004153690105933983835777939410970027 7 5347200000000000000000000000000000000000000000000000000000000000000000000000000 0 0000000000000000000000000000000000000000000000000000000000000000000000000000000 0 0000000000000000000000000000000000000000000000000000000000000000000000000000000 0 00000000000000Process returned 0 (0x0) execution time : 0.391 s Press any key to continue.。
【C语言】编写C代码求100的阶乘进行高精度计算
【C语言】编写C代码求100的阶乘进行高精度计算在计算机科学领域中,高精度计算是指对于超过所用数据类型所能表示的数值进行计算,常用于科学计算、密码学等领域。
而本文将介绍如何使用C语言进行高精度计算,并以求100的阶乘为例进行示范。
一、数据结构定义首先,我们需要定义一种能够存储大整数的数据结构。
在本文中,我们使用结构体来定义这个数据类型,它包含一个整数数组(用于存储每位数字),以及一个整数表示该数的位数。
typedef struct {int len; // 数字的位数int num[MAX]; // 数字数组}BigInt;其中,MAX为定义的数组最大长度。
二、初始化函数接着,我们需要定义一个函数来初始化这个数据类型。
由于每个数据类型都有一个初始值,我们可以将其初始化为0,其具体实现如下:void init(BigInt *p){p->num[0] = 0;p->len = 1;memset(p->num, 0, sizeof(p->num));}三、高精度乘法接下来,我们需要实现高精度乘法。
具体实现方法是模仿手算的乘法过程,从右往左遍历两个数的每一位,然后计算出各位上的乘积、进位和当前位的结果。
void mul(BigInt *p, int n){int i, t = 0;for (i = 0; i < p->len; ++i){t += n * p->num[i];p->num[i] = t % 10;t /= 10;}while (t > 0){p->num[p->len++] = t % 10;t /= 10;}}四、求阶乘有了高精度乘法之后,我们就可以使用循环来对100进行阶乘运算。
具体实现如下:void factorial(BigInt *p, int n){int i;for (i = 2; i <= n; ++i)mul(p, i);}五、完整代码#include <stdio.h>#include <stdlib.h>#include <string.h>#define MAX 1000typedef struct {int len;int num[MAX];}BigInt;void init(BigInt *p){p->num[0] = 0;p->len = 1;memset(p->num, 0, sizeof(p->num)); }void mul(BigInt *p, int n){int i, t = 0;for (i = 0; i < p->len; ++i){t += n * p->num[i];p->num[i] = t % 10;t /= 10;}while (t > 0){p->num[p->len++] = t % 10;t /= 10;}}void factorial(BigInt *p, int n){int i;for (i = 2; i <= n; ++i)mul(p, i);}void print(BigInt *p){int i;for (i = p->len - 1; i >= 0; --i)printf("%d", p->num[i]);printf("\n");}int main(){BigInt res;init(&res);factorial(&res, 100);printf("100! = ");print(&res);return 0;}六、总结高精度计算作为计算机科学中的重要应用之一,为许多计算机算法和应用提供了强大的支持。
关于大数阶乘的程序编写
大数阶乘序大数阶乘的计算是一个有趣的话题,从中学生到大学教授,许多人都投入到这个问题的探索和研究之中,并发表了他们自己的研究成果。
如果你用阶乘作关键字在google上搜索,会找到许多此类文章,另外,如果你使用google学术搜索,也能找到一些计算大数阶乘的学术论文。
但这些文章和论文的深度有限,并没有给出一个高速的算法和程序。
我和许多对大数阶乘感兴趣的人一样,很早就开始编制大数阶乘的程序。
从2000年开始写第一个大数阶乘程序算起,到现在大约己有6-7年的时光,期间我写了多个版本的阶乘计算器,在阶乘计算器的算法探讨和程序的编写和优化上,我花费了很大的时间和精力,品尝了这一过程中的种种甘苦,我曾因一个新算法的实现而带来速度的提升而兴奋,也曾因费了九牛二虎之力但速度反而不及旧的版本而懊恼,也有过因解一个bug而通宵敖夜的情形。
我写的大数阶乘的一些代码片段散见于互联网络,而算法和构想则常常萦绕在我的脑海。
自以为,我对大数阶乘计算器的算法探索在深度和广度上均居于先进水平。
我常常想,应该写一个关于大数阶乘计算的系列文章,一为整理自己的劳动成果,更重要的是可以让同行分享我的知识和经验,也算为IT界做一点儿贡献吧。
我的第一个大数阶乘计算器始于2000年,那年夏天,我买了一台电脑,开始在家专心学习VC,同时写了我的第一个VC程序,一个仿制windows界面的计算器。
该计算器的特点是高精度和高速度,它可以将四则运算的结果精确到6万位以内,将三角、对数和指数函数的结果精确到300位以内,也可以计算开方和阶乘等。
当时,我碰巧看到一个叫做实用计器的软件。
值得称颂的是,该计算器的作者姜边竟是一个高中生,他的这个计算器功能强大,获得了各方很高的评价。
该计算的功能之一是可以计算9000以内阶乘的精确值,且速度很快。
在佩服之余,也激起我写一个更好更快的程序的决心,经过几次改进,终于使我的计算器在做阶乘的精确计算时 (以9000!为例),可比实用计算器快10倍。
c++中阶乘运算
c++中阶乘运算摘要:1.阶乘的概念2.C++中阶乘的计算方法3.使用C++编写阶乘函数的两种方法4.阶乘函数的性能优化5.总结正文:1.阶乘的概念阶乘是一个数学概念,表示一个正整数n,与小于等于它的所有正整数相乘的积。
例如,4!(读作“4 阶乘”)等于4 × 3 × 2 × 1 = 24。
在计算机编程中,我们经常需要计算阶乘,以实现一些功能。
2.C++中阶乘的计算方法在C++中,我们可以通过编写函数来计算阶乘。
有多种方法可以实现这个功能,包括递归方法和循环方法。
3.使用C++编写阶乘函数的两种方法方法一:递归法我们可以使用递归来计算阶乘。
递归法的优点是代码简单,易于理解,但缺点是效率较低,因为存在大量的重复计算。
```cppint factorial_recursive(int n) {if (n == 0 || n == 1) {return 1;} else {return n * factorial_recursive(n - 1);}}```方法二:循环法我们可以使用循环来计算阶乘。
循环法的优点是效率高,避免了重复计算,但代码相对较复杂。
```cppint factorial_iterative(int n) {int result = 1;for (int i = 1; i <= n; ++i) {result *= i;}return result;}```4.阶乘函数的性能优化为了提高阶乘函数的性能,我们可以使用以下方法:- 对于递归方法,可以考虑尾递归优化,以减少函数调用的开销。
- 对于循环方法,可以使用并行计算或多线程技术,以加速计算过程。
5.总结C++中阶乘运算可以通过递归法和循环法实现。
递归法代码简单,易于理解,但效率较低;循环法效率高,避免了重复计算,但代码相对较复杂。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
程序设计报告( 2010 / 2011学年第一学期 ) 题目:大整数阶乘专业计算机科学与技术学生姓名张赛班级学号B09040121指导教师杨一涛指导单位计算机学院日期2010、9、30大整数阶乘一、课题内容与要求1、系统的基本功能及要求(1)写一个类BigInteger,并有如下成员函数operator+/ operator-/ operator*/ operator\,即整数的四则运算并重载运算符。
(2)用该大整数计算n的阶乘并显示出来。
(n∈[1,100])注:为了简化,可不考虑负数,则遇上形如“2-4”这样的表达式需要报错。
2、程序执行过程(1)系统从键盘读入自然数n,直到输入了合法的n为止。
(2)输出运算的结果,为便于观察结果,每输出四位中间插入空格,格式如下(例如,n=12):12!= 4790 0160 0(3)询问用户就是否继续进行,用户选择“就是”,直到输入合法为止,转(1),否则退出程序。
3、算法要求及提示(1)因为n较大时,n!的结果将超出长整形的保存范围,因此结果不能用long int 型的变量来保存。
本算法要求用链表来存储。
(2)链表的每一个节点存储结果的一位数字,因此结果的输出实际上就是链表的遍历问题,同时要先考虑用多少位来表示大整数。
4、其她要求(1)输入时具备一定的容错性判断,如输入的不就是数字,或输入的数超过范围等等。
(2)变量、函数命名符合规范。
(3)注释详细:每个变量都要求有注释说明用途;函数有注释说明功能,对参数、返回值也要以注释的形式说明用途;关键的语句段要求有注释解释。
(4)程序的层次清晰,可读性强。
二、需求分析1)课题要求已说明结果不能用long int型的变量来保存,要求用链表来存储。
,首先要定义一个节点类,在这里定义一个双向节点类。
2)定义一个BigInteger大整数类,使其能够存放大数阶乘,并实现其的四则运算。
3)对输入整数的合法性进行检查,必须考虑用户各种输入情况。
三、概要设计1.使用单链表存储数据,结点类定义如下:class Node{int data;Node* next;//指向大数的高位Node* pre;//指向大数的低位friend class BigInteger;};2、使用大整数类来进行大整数四则算法的重载,在主函数中通过定义大整数对象调用,大整数类定义如下:class BigInteger//定义大整数类{public:Node *head,*head1;int n,temp,i,jinwei;BigInteger();//无参构造函数~BigInteger();//析构函数void jiecheng();//阶乘函数void operator +( BigInteger p1);//加法运算重载声明void operator -( BigInteger p1);//减法运算重载声明void operator *( BigInteger p1);//乘法运算重载声明void operator /( BigInteger p1);//除法运算重载声明};3、算法设计说明:因为n较大时,n!的结果将超出长整形的保存范围,因此结果不能用long int型的变量来保存。
本算法数据用单链表来存储。
链表的每一个节点存储结果的一位数字,因此结果的输出实际上就是链表的遍历问题,同时要先考虑用多少位来表示大整数。
首先申请一个结点类并赋数据域初值1,然后遍历单链表逐个的数据域与i(1到n)相乘;乘完后重新遍历,对每个结点的数据域处理,若小于10则跳过;否则,判断下一结点就是否存在,若存在则该数据域除10取余,下一结点的数据域加上该数据域除10的结果,若不存在则申请新结点空间,处理同上;全部乘完并处理完后,遍历单链表并输出各自的数据域即可,注意每四个输出一个空格。
4、流程图就是四、详细设计1、阶乘函数作为BigInteger类中的函数,在主函数通过定义大整数类对象调用,阶乘函数的定义如下:void BigInteger::jiecheng(){Node *cur,*cc;Node *head=new Node;//存放第一个节点,值为1head->data=1;head->pre=head->next=NULL;for(i=2;i<=n;i++)//从2开始连乘到n{cur=head;jinwei=0;while(1){temp=i*(cur->data)+jinwei;cur->data=temp%10;//取个位存下来,如91*2=182,取2存储jinwei=temp/10;//十位与百位作为进位,取18为进位if(cur->next==NULL)break;cur=cur->next;}while(jinwei!=0)//如果乘完一个i发现还有进位,就必须新增结点,由于进位可能就是多位数,所以必须用//while{cc=new Node;cc->data=jinwei%10;cc->pre=cur;cc->next=NULL;cur->next=cc;cur=cc;jinwei/=10;}}cout<<n<<"!= ";cur=head,i=0;while(cur->next)cur=cur->next;//遍历到最高位while(cur)//从最高位到最低位打印{cc=cur;if(i==4){i=0;cout<<' ';}cout<<cur->data;cur=cur->pre;i++;delete cc;}}2.阶乘加法函数的重载定义:void BigInteger::operator +( BigInteger p1) {Node *cur,*cc,*cur1,*cc1;head=new Node;//存放第一个节点,值为1head->data=1;head->pre=head->next=NULL;for(i=2;i<=n;i++)//从2开始连乘到n{cur=head;jinwei=0;while(1){temp=i*(cur->data)+jinwei;cur->data=temp%10;//取个位存下来,如91*2=182,取2存储jinwei=temp/10;//十位与百位作为进位,取18为进位if(cur->next==NULL)break;cur=cur->next;}while(jinwei!=0)//如果乘完一个i发现还有进位,就必须新增结点,由于进位可能就是多位数,所以必须用//while{cc=new Node;cc->data=jinwei%10;cc->pre=cur;cc->next=NULL;cur->next=cc;cur=cc;jinwei/=10;}}head1=new Node;//存放第一个节点,值为1head1->data=1;head1->pre=head1->next=NULL;for(i=2;i<=p1、n;i++)//从2开始连乘到n{cur1=head1;jinwei=0;while(1){temp=i*(cur1->data)+jinwei;cur1->data=temp%10;//取个位存下来,如91*2=182,取2存储jinwei=temp/10;//十位与百位作为进位,取18为进位if(cur1->next==NULL)break;cur1=cur1->next;}while(jinwei!=0)//如果乘完一个i发现还有进位,就必须新增结点,由于进位可能就是多位数,所以必须用//while{cc1=new Node;cc1->data=jinwei%10;cc1->pre=cur1;cc1->next=NULL;cur1->next=cc1;cur1=cc1;jinwei/=10;}}if(n>p1、n)//若this、n大于等于p1、n{cur=head;cur1=head1;while(cur&&cur1)//同时遍历两个单链表,其中有一个结束就停止遍历{cur->data+=cur1->data;//cur的数据域等于cur的数据域与cur1的数据域的与cur=cur->next;cur1=cur1->next;}cur=head;//cur指向头结点do//利用阶乘函数中的算法处理单链表各个节点的数据域{if(cur->data<10)continue;if(cur->data>=10){if(cur->next){ cur->next->data+=cur->data/10;cur->data=cur->data%10;}else{Node *q=new Node;q->next=cur->next;cur->next=q;q->data+=cur->data/10;cur->data=cur->data%10;}}}while(cur=cur->next);cur=head,i=0;while(cur->next)cur=cur->next;//遍历到最高位while(cur)//从最高位到最低位打印{cc=cur;if(i==4) //每输出四个空一格{i=0;cout<<' ';}cout<<cur->data;cur=cur->pre;i++;delete cc;}}else{cur=head;cur1=head1;while(cur&&cur1)//同时遍历两个单链表,其中有一个结束就停止遍历{cur1->data+=cur->data;//cur1的数据域等于cur1的数据域与m的数据域的与cur1=cur1->next;cur=cur->next;}cur1=head1;do//利用阶乘函数中的算法处理单链表各个节点的数据域{if(cur1->data<10)continue;if(cur1->data>=10){if(cur1->next){cur1->next->data+=cur1->data/10;cur1->data=cur1->data%10;}else{Node *q=new Node;q->data=0;q->next=cur1->next;cur1->next=q;q->pre=cur1;q->data+=cur1->data/10;cur1->data=cur1->data%10;}}}while(cur1=cur1->next);cur1=head1,i=0;while(cur1->next)cur1=cur1->next;//遍历到最高位while(cur1)//从最高位到最低位打印{cc=cur1;if(i==4) //每输出四个空一格{i=0;cout<<' ';}cout<<cur1->data;cur1=cur1->pre;i++; delete cc;}}}3.阶乘减法函数的重载定义:void BigInteger::operator -( BigInteger p1){if(n==p1、n)//若this、n等于p1、n{cout<<"0";}else//若this、n不等于p1、n{Node *cur,*cc,*cur1,*cc1;head=new Node;//存放第一个节点,值为1head->data=1;head->pre=head->next=NULL;for(i=2;i<=n;i++)//从2开始连乘到n{cur=head;jinwei=0;while(1){temp=i*(cur->data)+jinwei;cur->data=temp%10;//取个位存下来,如91*2=182,取2存储jinwei=temp/10;//十位与百位作为进位,取18为进位if(cur->next==NULL)break;cur=cur->next;}while(jinwei!=0)//如果乘完一个i发现还有进位,就必须新增结点,由于进位可能就是多位数,所以必须用//while{cc=new Node;cc->data=jinwei%10;cc->pre=cur;cc->next=NULL;cur->next=cc;cur=cc;jinwei/=10;}}head1=new Node;//存放第一个节点,值为1head1->data=1;head1->pre=head1->next=NULL;for(i=2;i<=p1、n;i++)//从2开始连乘到n{cur1=head1;jinwei=0;while(1){temp=i*(cur1->data)+jinwei;cur1->data=temp%10;//取个位存下来,如91*2=182,取2存储jinwei=temp/10;//十位与百位作为进位,取18为进位if(cur1->next==NULL)break;cur1=cur1->next;}while(jinwei!=0)//如果乘完一个i发现还有进位,就必须新增结点,由于进位可能就是多位数,所以必须用//while{cc1=new Node;cc1->data=jinwei%10;cc1->pre=cur1;cc1->next=NULL;cur1->next=cc1;cur1=cc1;jinwei/=10;}}if(n>p1、n)//若this、n大于p1、n{cur=head;cur1=head1;while(cur&&cur1)//同时遍历两个单链表,其中有一个结束就停止遍历{cur->data-=cur1->data;cur=cur->next;cur1=cur1->next;}cur=head;do//遍历单链表{if(cur->data<0)//若p的数据域小于0{cur->next->data-=1;//p的后继结点的数据域减1cur->data+=10;//p的数据域加10}}while(cur=cur->next);cur=head,i=0;while(cur->next)cur=cur->next;//遍历到最高位while(cur)//从最高位到最低位打印{cc=cur;if(i==4) //每输出四个空一格{i=0;cout<<' ';}cout<<cur->data;cur=cur->pre;i++;delete cc;}}else{cur=head;cur1=head1;while(cur&&cur1)//同时遍历两个单链表,其中有一个结束就停止遍历{cur1->data-=cur->data;cur1=cur1->next;cur=cur->next;}cur1=head1;do//遍历单链表{if(cur1->data<0&&cur1->next)//若cur1的数据域小于0{cur1->next->data-=1;//cur1的后继结点的数据域减1cur1->data+=10;//cur1的数据域加10}}while(cur1=cur1->next);cur1=head1,i=0;while(cur1->next)cur1=cur1->next;//遍历到最高位cout<<"-";while(cur1)//从最高位到最低位打印{cc1=cur1;if(i==4) //每输出四个空一格{i=0;cout<<' ';} cout<<cur1->data;cur1=cur1->pre;i++;delete cc1;}}}}4.阶乘乘法函数重载的定义:void BigInteger::operator *( BigInteger p1){Node *cur,*cur1,*cc,*cc1;head=new Node;//存放第一个节点,值为1head->data=1;head->pre=head->next=NULL;for(i=2;i<=n;i++)//从2开始连乘到n{cur=head;jinwei=0;while(1){temp=i*(cur->data)+jinwei;cur->data=temp%10;//取个位存下来,如91*2=182,取2存储jinwei=temp/10;//十位与百位作为进位,取18为进位if(cur->next==NULL)break;cur=cur->next;}while(jinwei!=0)//如果乘完一个i发现还有进位,就必须新增结点,由于进位可能就是多位数,所以必须用//while{cc=new Node;cc->data=jinwei%10;cc->pre=cur;cc->next=NULL;cur->next=cc;cur=cc;jinwei/=10;}}for(i=1;i<=p1、n;i++)//从2开始连乘到n{cur1=head;jinwei=0;while(1){temp=i*(cur1->data)+jinwei;cur1->data=temp%10;//取个位存下来,如91*2=182,取2存储jinwei=temp/10;//十位与百位作为进位,取18为进位if(cur1->next==NULL)break;cur1=cur1->next;}while(jinwei!=0)//如果乘完一个i发现还有进位,就必须新增结点,由于进位可能就是多位数,所以必须用//while{cc1=new Node;cc1->data=jinwei%10;cc1->pre=cur1;cc1->next=NULL;cur1->next=cc1;cur1=cc1;jinwei/=10;}}cur1=head,i=0;while(cur1->next)cur1=cur1->next;//遍历到最高位while(cur1)//从最高位到最低位打印{cc1=cur1;if(i==4) //每输出四个空一格{i=0;cout<<' ';}cout<<cur1->data;cur1=cur1->pre;i++;delete cc1;}}5.阶乘除法函数重载的定义:void BigInteger::operator/(BigInteger p1){if(n==p1、n)//若this、n等于p1、n{cout<<"1"<<endl;}elseif(n<p1、n){cout<<"0"<<endl;}if(n>p1、n){Node *cur,*cc;head=new Node;//存放第一个节点,值为1head->data=1;head->pre=head->next=NULL;for(i=p1、n+1;i<=n;i++)//从p1、n开始连乘到n{cur=head;jinwei=0;while(1){temp=i*(cur->data)+jinwei;cur->data=temp%10;//取个位存下来,如91*2=182,取2存储jinwei=temp/10;//十位与百位作为进位,取18为进位if(cur->next==NULL)break;cur=cur->next;}while(jinwei!=0)//如果乘完一个i发现还有进位,就必须新增结点,由于进位可能就是多位数,所以必须用//while{cc=new Node;cc->data=jinwei%10;cc->pre=cur;cc->next=NULL;cur->next=cc;cur=cc;jinwei/=10;}}cur=head,i=0;while(cur->next)cur=cur->next;//遍历到最高位while(cur)//从最高位到最低位打印{cc=cur;if(i==4) //每输出四个空一格{i=0;cout<<' ';}cout<<cur->data;cur=cur->pre;i++; delete cc;}}}五、数据测试及其结果分析1.数据测试测试界面:输入错误整数: 123输入正确整数: 12接着输入y接着输入5接着输入n接着输入6接着输入52、结果分析:刚开始运行,程序首先提示用户程序就是计算大整数的阶乘及其四则运算的功能,并提示用户按照输入一个自然数;如果输入的数大于100或小于1,则提示用户输入错误;若输入正确,则进行阶乘运算,输出结果,然后提示用户就是否继续,若继续,则提示用户输入自然数n,继续进行阶乘运算,否则,则以下进入大整数阶乘的四则运算,提示输入第一运算对象的n值;若输入不正确,则提示用户重新输入,直至正确为止,然后提示用户输入第二运算对象的n值,若输入不正确,则提示用户重新输入,直至正确为止,然后则输出四则运算的结果。