高精度算法(c语言版)

c 高精度加法C语言中的高精度加法是一种处理大数运算的方法，它可以实现超出标准整数范围的加法运算。

在日常的编程中，我们经常会遇到需要处理大数运算的情况，例如计算两个很大的整数的和，传统的整数运算方法已经无法满足需求。

本文将详细介绍C语言中的高精度加法的实现方法。

在C语言中，整数的表示范围是有限的，一般为-2^31到2^31-1。

超出这个范围的整数运算会导致溢出错误，得到错误的结果。

为了解决这个问题，我们可以使用字符串来表示大数，并通过模拟手工计算的方式进行加法运算。

我们需要将输入的两个大数转化为字符串，并计算出两个字符串的长度。

然后，我们可以从最低位开始，逐位相加，并将结果保存在一个新的字符串中。

需要注意的是，相加时要考虑进位的情况。

如果当前位的和大于等于10，那么进位为1，否则进位为0。

计算完当前位的和和进位后，将和的个位数添加到结果字符串中，并将进位保存起来。

接下来，我们继续处理下一位，直到两个大数的所有位都相加完毕。

最后，我们需要将结果字符串进行翻转，得到最终的结果。

下面是一个使用C语言实现的高精度加法的示例代码：```#include <stdio.h>#include <string.h>void reverse(char *str) {int i, j;char temp;int len = strlen(str);for (i = 0, j = len - 1; i < j; i++, j--) {temp = str[i];str[i] = str[j];str[j] = temp;}}void bigAddition(char *num1, char *num2, char *result) { int len1 = strlen(num1);int len2 = strlen(num2);int maxLen = len1 > len2 ? len1 : len2;int carry = 0;int sum;int i;for (i = 0; i < maxLen; i++) {int digit1 = i < len1 ? num1[i] - '0' : 0;int digit2 = i < len2 ? num2[i] - '0' : 0; sum = digit1 + digit2 + carry;result[i] = sum % 10 + '0';carry = sum / 10;}if (carry > 0) {result[maxLen] = carry + '0';result[maxLen + 1] = '\0';} else {result[maxLen] = '\0';}reverse(result);}int main() {char num1[] = "123456789012345678901234567890"; char num2[] = "987654321098765432109876543210"; char result[1000];bigAddition(num1, num2, result);printf("The sum is: %s\n", result);return 0;}```在上面的示例代码中，我们定义了一个 `bigAddition` 函数来实现高精度加法。

c语言高精度运算模板
好的，下面为你提供一个C语言高精度运算模板，包括高精度加法、减法和乘法：
高精度加法：直接对位相加，当某位超过10直接取模运算，然后下一位直接对加相应多出的数即可。

高精度减法：当输入的$ss1$小于$ss2$时，需要交换两者的顺序，并率先输出一个负号。

然后执行循环，在循环中如果$a(i)<b(i)$，则直接向下一位借位，然后本位加10，$a(i)$加10。

高精度乘法：使用双重循环，$c$下标对应关系为$i+j-1$（$i=j=1$开始）。

在循环中，将$a(i)$和$b(j)$相乘后的结果累加到$c(i+j-1)$中。

你可以根据实际需求对模板进行修改和调整，以满足不同的计算需求。

如果你还有其他问题，请随时向我提问。

高精度计算一．加法先判断出两个数哪个较长，两个数从个位对齐后，从个位数开始相加，先不考虑进位的问题，相加直到较短的数的最高位。

接着把较长的数未相加的部分进行赋值。

最后在处理进位问题（判断每位上的数是否大于等于10）。

其中要注意的是两数相加，得到的和的位数是否比较长的数的位数大1。

和进位问题的处理。

代码：# include<stdio.h># include<string.h># include<malloc.h>void add(char* a,char* b,char* c){int i,j,k,max,min,n,temp;char *s,*pmax,*pmin;max=strlen(a);min=strlen(b);if (max<min){temp=max;max=min;min=temp;pmax=b;pmin=a;}else{pmax=a;pmin=b;}s=(char*)malloc(sizeof(char)*(max+1));s[0]='0';for (i=min-1,j=max-1,k=max;i>=0;i--,j--,k--) s[k]=pmin[i]-'0'+pmax[j];for (;j>=0;j--,k--)s[k]=pmax[j];for (i=max;i>=0;i--)if (s[i]>'9'){s[i]-=10;s[i-1]++;}if (s[0]=='0'){for (i=0;i<=max;i++)c[i-1]=s[i];c[i-1]='\0';}else{for (i=0;i<=max;i++)c[i]=s[i];c[i]='\0';}free(s);}二．减法先考虑减数大于被减数的情况。

高精度加法 - C语言1. 任务背景在计算机科学中，整数可以使用有限位数的二进制表示。

但是在实际应用中，有时候需要处理非常大的整数，超过了计算机所能表示的范围。

这就导致了高精度整数的问题。

高精度整数指的是可以表示和计算任意位数的整数。

在处理大整数的加法运算时，需要设计算法来实现高精度加法。

C语言是一种被广泛使用的编程语言，具有高效、灵活和广泛的应用领域。

本文将介绍如何使用C语言实现高精度加法的算法和相关的注意事项。

2. 高精度加法算法实现对于两个大整数的加法，常用的算法是逐位相加，并考虑进位。

以下是一种高精度加法算法的实现步骤：1.从个位开始，逐位相加两个大整数的对应位，并考虑上一位的进位。

2.如果相加的结果大于等于10，则需要向下一位产生进位。

3.将相加的结果保存到结果数组中的对应位置。

4.对两个大整数的所有位数都进行相加操作，直到最高位。

5.最后，将结果数组转换为字符串表示，即为高精度整数的和。

以下是一个示例的C语言代码实现：#include <stdio.h>#define MAX_SIZE 1000void reverse(char *str) {int i = 0;int j = strlen(str) - 1;while (j > i) {char temp = str[j];str[j] = str[i];str[i] = temp;i++;j--;}}char* add(char *num1, char *num2) {int len1 = strlen(num1);int len2 = strlen(num2);int len = (len1 > len2) ? len1 : len2;int carry = 0;int sum[MAX_SIZE] = {0};reverse(num1);reverse(num2);for (int i = 0; i < len; i++) {int digit1 = (i < len1) ? (num1[i] - '0') : 0;int digit2 = (i < len2) ? (num2[i] - '0') : 0;int tempSum = digit1 + digit2 + carry;carry = tempSum / 10;sum[i] = tempSum % 10;}if (carry > 0) {sum[len] = carry;}int resultLen = carry > 0 ? len + 1 : len;char *result = (char *) malloc((resultLen + 1) * sizeof(char));for (int i = 0; i < resultLen; i++) {result[i] = sum[i] + '0';}result[resultLen] = '\0';reverse(result);return result;}int main() {char num1[MAX_SIZE];char num2[MAX_SIZE];printf("Enter first number: ");scanf("%s", num1);printf("Enter second number: ");scanf("%s", num2);char *result = add(num1, num2);printf("Sum: %s\n", result);free(result);return 0;}此示例程序通过逐位相加来计算两个大整数的和，并将结果以字符串的形式输出。

c语言高精度计算n的阶乘高精度计算是指在计算机中进行大数运算时，能够精确表示和计算超过计算机位数范围的整数或小数。

在计算n的阶乘时，如果n很大，传统的计算方法可能会导致溢出或精度丢失，因此需要使用高精度计算的方法。

C语言是一种广泛应用于系统软件和应用软件开发的高级程序设计语言。

它支持对内存的直接访问，并提供了丰富的库函数，可以方便地进行高精度计算。

本文将介绍如何使用C语言实现高精度计算n的阶乘。

我们需要明确阶乘的定义。

阶乘是指从1到n的连续整数的乘积，表示为n!。

例如，5的阶乘为5! = 5 ×4 × 3 × 2 × 1 = 120。

传统的计算n的阶乘的方法是使用循环结构，从1到n依次相乘。

但是，当n很大时，结果可能会超出计算机能够表示的范围。

为了避免这个问题，我们可以使用数组来表示大数，并模拟手工计算的过程。

具体实现时，我们可以使用一个整型数组来存储大数的每一位。

数组的每个元素表示一个位数，例如，数组的第一个元素表示最低位，最后一个元素表示最高位。

为了方便计算，我们可以将大数按照逆序存储，即最低位存储在数组的最后一个元素中。

我们需要定义一个函数来实现大数的乘法。

该函数接受两个大数作为参数，并返回它们的乘积。

具体实现时，我们可以使用两层循环遍历两个大数的每一位，并将结果保存在一个新的大数中。

在计算过程中，需要注意进位的处理。

接下来，我们可以定义一个函数来计算n的阶乘。

该函数接受一个整数n作为参数，并返回n的阶乘。

具体实现时，我们可以使用一个循环从2到n，依次计算每个数的阶乘，并将结果与之前的乘积相乘。

在计算过程中，为了避免溢出，我们可以使用前面提到的大数乘法函数。

我们可以在主函数中调用阶乘函数，并输出结果。

为了方便观察，我们可以将大数按照正常顺序输出，即从最高位到最低位。

具体实现时，可以使用一个循环从最高位到最低位遍历大数数组，并将每一位转换为字符型后输出。

⾼精度c语⾔乘法,C语⾔⾼精度乘法的实现⽅法对于要求很搞的C语⾔⾼精度乘法，相信很多⼈还没有⽤到过，应为在常规的应⽤中⼀般精度的乘法就可以满⾜我们的计算要求，今天⼀起来看看⾼精度乘法的实现⽅法吧。

/*⾼精度乘法输⼊：两⾏，每⾏表⽰⼀个⾮负整数(不超过10000位)输出：两数的乘积。

*/#include#include#include#include#define MAX 10001int bigchenfa(int *sum,int *a,int *b,int lsum,int la,int lb){int i,j,k ;memset(sum,0,sizeof(sum));lsum = 0 ;for(i=1 ; i<= la ; i ) /*⽤数组模拟运算*/for(j=1,lsum=i-1; j<= lb ; j )sum[ lsum] = b[j] * a[i] ;for(i=1 ; i<= lsum ; i )/*进位处理*/if (sum[i] >= 10){if ( sum[lsum] >= 10)lsum ;sum[i 1] = sum[i] / 10 ;sum[i] %= 10 ;}return lsum ;}int main(void){int a[MAX]={0},b[MAX]={0},sum[MAX*2]={0} ;int la=0,lb=0,lsum=0;int i,j ;char sa[MAX],sb[MAX] ;scanf(\"%s %s\",sa,sb);la = strlen(sa);lb = strlen(sb);for(i=1,j=la-1; i<= la ; i ,j--)a[i] = sa[j] - ’0’ ;for(i=1,j=lb-1; i<= lb ; i ,j--)b[i] = sb[j] - ’0’ ;lsum = bigchenfa(sum,a,b,lsum,la,lb) ; for(i=lsum ; i>= 1 ; i--) [Page]printf(\"%d\",sum[i]);printf(\" \");system(\"pause\");return 0 ;}本⽂来源:搜集于⽹络。

c高精度除法C语言中的高精度除法是指在计算机程序中实现对两个大整数进行精确的除法运算。

在常规的整数除法运算中，如果被除数不能整除除数，结果会被截断为一个整数，而高精度除法可以保留小数部分，得到更精确的结果。

实现高精度除法的关键在于如何处理大整数的除法运算。

由于计算机内存的限制，无法直接存储和处理大整数，因此需要使用数组或链表等数据结构来表示大整数，并设计相应的算法来实现除法运算。

一种常见的实现方法是使用数组来表示大整数。

假设被除数为a，除数为b，结果为c。

首先需要将a和b转换为数组形式，数组的每个元素表示整数的一位。

然后从最高位开始，逐位进行除法运算，得到商和余数。

商的每一位作为结果数组c的相应位，余数作为下一位的被除数，继续进行除法运算，直到被除数的所有位都处理完毕。

最后得到的商就是除法的结果。

在进行除法运算时，需要注意处理特殊情况，如除数为0或被除数为0的情况。

此外，还需要考虑除法的精度问题。

由于计算机内部表示的数字精度是有限的，可能会出现舍入误差。

为了得到更精确的结果，可以使用更高精度的数据类型或增加运算的位数。

除法运算还需要考虑整除和非整除的情况。

对于整除的情况，结果是一个整数，可以直接输出。

对于非整除的情况，需要将商的小数部分计算出来。

一种常见的方法是使用长除法，将商的小数部分逐位计算，直到达到指定的精度或循环节。

实现高精度除法的算法需要考虑效率和复杂度。

可以使用优化的算法来减少不必要的运算。

例如，可以先判断除数是否大于被除数，如果是，则结果为0；如果不是，则可以先将除数左移，使得除数的位数尽量接近被除数的位数，然后再进行除法运算。

总结起来，C语言中的高精度除法是一种能够实现对大整数进行精确的除法运算的算法。

通过使用数组表示大整数，设计相应的除法运算算法，可以得到更精确的结果。

在实际应用中，需要考虑除法的特殊情况和精度问题，并使用优化的算法来提高效率。

C语⾔实现⾼精度加减法本⽂实例为⼤家分享了C语⾔实现⾼精度加减法的具体代码，供⼤家参考，具体内容如下⾸先，我们来看⼀下C语⾔中各类型的最值：unsigned int 0～4294967295int -2147483648～2147483647unsigned long 0～4294967295long -2147483648～2147483647long long的最⼤值：9223372036854775807long long的最⼩值：-9223372036854775808unsigned long long的最⼤值：1844674407370955161__int64的最⼤值：9223372036854775807__int64的最⼩值：-9223372036854775808unsigned __int64的最⼤值：18446744073709551615由于C语⾔所拥有的类型不能满⾜更⾼位数的运算，因此需要使⽤其他⽅法来实现更多位（⾼精度）的加减；下⾯我们使⽤代码实现⾼精度加减：1、⾼精度加法：#include<stdio.h>#include<string.h>int main(void){int len_max,i; //len_max⽤来记录最⼤字符串长度，以便相加、输出char m[999],n[999];int a[999]={0},b[999]={0},c[999]={0};//初始化为0，⽅便后续输出scanf("%s%s",m,n);if(strlen(m)>strlen(n))len_max=strlen(m);else len_max=strlen(n);for(i=0;i<strlen(m);i++){a[i]=m[strlen(m)-1-i]-'0';//将低位放前⾯，⾼位放后⾯，以便进位}for(i=0;i<strlen(n);i++){b[i]=n[strlen(n)-1-i]-'0';}int k=0; //⽤来进位for(i=0;i<=len_max;i++){ //不要忘了“=”c[i]=a[i]+b[i]+k;k=c[i]/10;c[i]%=10;}int flag=0; //使⽤flag判断最⾼位并实现输出for(i=len_max;i>=0;i--){ //倒序输出if(c[i])flag=1;if(flag)printf("%d",c[i]);}if(!flag) printf("0"); //特判 0；return 0;}2、⾼精度减法：#include<stdio.h>#include<string.h>int main(void){int len_max,i;char m[999],n[999],temp[999];int a[999]={0},b[999]={0},c[999]={0};scanf("%s%s",m,n);if(strlen(m)>strlen(n))len_max=strlen(m);elselen_max=strlen(n);if(strlen(n)>strlen(m)||(strlen(m)==strlen(n)&&strcmp(n,m)>0)){//使被减数⼤于减数，长度相同时需⽤函数strcmp判断⼤⼩strcpy(temp,m);strcpy(m,n);strcpy(n,temp);//交换数据printf("-"); //结果为负}for(i=0;i<strlen(m);i++){a[i]=m[strlen(m)-1-i]-'0';}for(i=0;i<strlen(n);i++){b[i]=n[strlen(n)-1-i]-'0';}for(i=0;i<=len_max;i++){c[i]=a[i]-b[i];if(c[i]<0){c[i]+=10; //向上借位a[i+1]--;}}int flag=0;for(i=len_max;i>=0;i--){ //逆序打印if(c[i])flag=1;if(flag)printf("%d",c[i]);}if(!flag) printf("0"); //特判！return 0;}以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。

CC++⾼精度算法的实现做ACM题的时候，经常遇到⼤数的加减乘除，乘幂，阶乘的计算，这时给定的数据类型往往不够表⽰最后结果，这时就需要⽤到⾼精度算法。

⾼精度算法的本质是把⼤数拆成若⼲固定长度的块，然后对每⼀块进⾏相应的运算。

这⾥以考虑4位数字为⼀块为例，且输⼊的⼤数均为正整数（也可以考虑其他位，但要注意在每⼀块进⾏相应运算时不能超出数据类型的数值范围；有负整数的话读⼊时判断⼀下正负号在决定运算）。

1. ⾼精度加法以3479957928375817 + 897259321544245为例：3479957928375817+897+2593+2154+4245====437612172499110062进位0进位1进位0进位14377217249920062C语⾔实现代码如下：#include <stdio.h>#include <stdlib.h>#include <string.h>#define N 200//整数乘幂运算函数int Pow(int a, int b){int i = 0, result = 1;for(i = 0; i < b; ++i){result *= a;}return result;}//High Precision Of Additionint main(){char stra[N], strb[N]; //字符串数组，以字符形式储存两个⼤数；int i = 0, step = 4, carry = 0; //step表⽰块长，carry为进位位；int lengtha, lengthb, maxlength, resultsize; //maxlength表⽰stra和strb⼆者长度较⼤的那个；int numa[N], numb[N],numc[N]; //依次储存被加数，加数，和；memset(numa, 0, sizeof(numa));memset(numb, 0, sizeof(numb));memset(numc, 0, sizeof(numc)); //初始化为零；scanf("%s%s", stra, strb);lengtha = strlen(stra);lengthb = strlen(strb); //计算两个⼤数的长度//字符数字转为四位⼀块的整数数字for(i = lengtha-1; i >= 0; --i){numa[(lengtha-1-i)/step] += (stra[i]-'0')*Pow(10,(lengtha-1-i)%step);}for(i = lengthb-1; i >= 0; --i){numb[(lengthb-1-i)/step] += (strb[i]-'0')*Pow(10,(lengthb-1-i)%step);}maxlength = lengtha > lengthb ? lengtha : lengthb;//逐块相加，并进位for(i = 0; i <= maxlength/step; ++i){numc[i] = (numa[i] + numb[i])%Pow(10, step) + carry; //计算和carry = (numa[i] + numb[i])/Pow(10, step); //计算进位}//计算最后和的块的总数resultsize = numc[maxlength/step] > 0 ? maxlength/step : maxlength/step - 1;printf("%d", numc[resultsize]);for(i = resultsize-1; i >= 0; --i){printf("%04d", numc[i]); //右对齐，补零输出；}printf("\n");return 0;}2. ⾼精度减法与加法类似，不同的是要注意正负号和显⽰位数的变化。

C语言的高精度算法高精度算法是指用来处理大数运算的算法，它可以在计算机内存限制范围内实现对任意长度整数的高精度计算。

C语言是一种通用的、高效的编程语言，非常适合用来实现高精度算法。

一、基本思想高精度算法的基本思想是将大整数拆分成多个小整数进行运算，再通过运算规则将结果合并。

实现高精度算法的关键是对大数进行拆分、运算和合并。

二、大整数的表示在C语言中，大整数可以通过结构体、数组或字符串等方式进行表示。

其中，使用数组方式最为常见。

例如，可以使用一个字符数组来存储大整数的每一位数字，数组的每个元素都是一个字符，表示一个数字。

三、实现加法算法高精度加法算法的基本步骤如下：1.将两个大整数转换为数组，存储每一位的数字。

2.从最低位开始，按位进行相加。

同时考虑进位，如果有进位则在下一位相加时加13.将每一位的和保存到结果数组中。

4.最后，将结果数组合并成一个大整数。

四、实现减法算法高精度减法算法与加法算法类似，只是在相减时需要考虑借位的问题。

基本步骤如下：1.将两个大整数转换成数组，存储每一位的数字。

确保被减数大于减数。

2.从最低位开始，按位进行相减。

如果当前位不够减，则向高位借位。

3.将每一位的差保存到结果数组中。

4.最后，将结果数组合并成一个大整数。

五、实现乘法算法高精度乘法算法的基本思路是利用竖式乘法的方法，从最低位开始，按位相乘。

基本步骤如下：1.将被乘数和乘数转换为数组，存储每一位的数字。

2.从最低位开始，按位进行相乘，并将结果保存到一个临时数组中。

3.将各位的乘积进行合并，得到结果数组。

4.最后，将结果数组合并成一个大整数。

六、实现除法算法高精度除法算法的基本思路是利用竖式除法的方法，从最高位开始按位相除。

基本步骤如下：1.将被除数和除数转换为数组，存储每一位的数字。

2.初始化商数组为0。

3.从最高位开始，按位进行相除，并将商保存到商数组中。

4.对余数进行处理。

如果余数不为零，则在下一位相除时将余数带进去。

C语⾔⾼精度乘法对于C语⾔来说，int类型的范围是（-2^31 ~ 2^31-1），即便是64位操作系统的长整形long long，也只有64位⽤来存储数据。

这样的数据⼤⼩，对于简单的阶乘如5！、10！或简单的乘法⾜够了但是对于像50！、100！这样规模甚⾄更⼤的阶乘，使⽤基础数据类型存储显然不够，于是可以考虑使⽤乘法的位运算结合数组空间实现⾼精度乘法#include <stdio.h>void highPrecision (int N );// int* a = (int *)malloc(sizeof(int)*50000);// free(a);int a[50000] = {0, 1}, length = 1; //开辟⼀个⼤的数组，全局变量length记录长度int main() {int N;while( ~scanf("%d", &N) ) { //Ctrl + Z 结束输⼊highPrecision(N);}return0;}void highPrecision (int N) {int cat, mid; //lenth 数据长度， cat 进位， mid 取余cat = 0; //开始进位为 0for(int k = 1; k<= length; k++) {mid = a[k] * N + cat; //按位相乘的结果加进位a[k] = mid % 10;cat = mid / 10; //确定此次计算的进位if(k == length && cat != 0) //如果当前结果的最⾼位都需要进位的话，则总长度应增加length++;}for(int i = length; i>= 1; i--) //把记录的数据按逆顺序打印，且a[0]是多余的，不打印printf("%d", a[i]);printf("\n");}。

c语言高精度计算n的阶乘高精度计算是指对于超过计算机所能表示的数值范围的数字进行精确计算的方法。

在C语言中，常规的整型变量无法存储大数，因此需要使用其他方法来实现高精度计算。

本文将介绍如何使用C语言来计算一个数的阶乘，并实现高精度计算。

我们需要了解阶乘的概念。

阶乘是指从1到给定的数字n之间所有整数的乘积。

例如，5的阶乘表示为5!，计算方式为5 * 4 * 3 * 2 * 1 = 120。

对于较小的数，我们可以直接使用C语言中的循环来计算阶乘，但对于较大的数，我们需要使用高精度计算的方法。

在C语言中，我们可以使用数组来表示一个大数。

数组的每个元素存储大数的每一位。

例如，数字123456可以用数组arr表示为arr[] = {1, 2, 3, 4, 5, 6}。

这样，我们就可以通过数组来进行高精度计算。

我们需要定义一个数组来存储计算结果，并将其初始化为1。

然后，我们使用循环从2开始遍历到n，每次将当前数字与数组中的数相乘，并将结果存储到数组中。

具体的代码如下：```c#include <stdio.h>#define MAX_SIZE 1000void multiply(int result[], int num, int size) {int carry = 0; // 进位for (int i = 0; i < size; i++) {int product = result[i] * num + carry; // 计算乘积 result[i] = product % 10; // 保存当前位数carry = product / 10; // 计算进位}// 处理最高位的进位while (carry != 0) {result[size] = carry % 10;carry /= 10;size++;}}void factorial(int n) {int result[MAX_SIZE] = {1}; // 初始化结果为1int size = 1; // 数组大小for (int i = 2; i <= n; i++) {multiply(result, i, size);}// 逆序输出结果printf("%d的阶乘为：", n);for (int i = size - 1; i >= 0; i--) {printf("%d", result[i]);}printf("\n");}int main() {int n;printf("请输入一个正整数：");scanf("%d", &n);factorial(n);return 0;}```在上述代码中，我们定义了两个函数`multiply`和`factorial`。

高精度运算和简单优化方法（C语言）收藏先介绍一种高精度的优化方法，事实上这种优化没有改变算法的时间复杂度，也就是没有改变他的增长曲线但却使增长变慢了。

然后再介绍一下减法。

现在常用的高精度计算方法是把字符串中每个字符转化为一个数倒序存储在另一个数组中，这样做既浪费空间，又没有时效。

因为最简单的整型数char最大可以存储255，用它存储个位数浪费了很多空间。

而且逐位计算也花费很多时间。

不如让一个数存储尽可能多的位，这样对一个数组元素的计算只需要一次，那么总的循环次数相应的缩短为几分之一，比如让char存储两位数（它不可以存储三位数因为最大的三位数999超出了它的范围）那么计算12+34的运算也相应的成为一次普通的计算，而不需要向原始的方法那样循环两次。

我在下面这个程序中用了long，因为long可以存储最多10位的数，因此可以用它存储任意9 位数，处理的时候注意如果它的位数不是九的倍数那么会有多余，把多余的放到最高位。

这样做可以把循环次数缩小为1/9。

这相当于是一个1000000000进制的计算，用10进制显示它的每一位，发现这样一个1000000000进制的数它的显示与10进制完全一样的。

但要注意的是，它的每一位输出必须为9位。

如果10进制下小于九位则要在前面补零。

比如某一位是100，在1000000000进制的数中要输出为000000100，c 语言有该格式的应用，pascal 中MS要计算前补零了，如果是最高位的话当然可以把前面的零省掉了。

下面是该算法的程序#include<stdio.h>#include<string.h>int main(){char a1[100000],b1[100000];long a[10000]={0},b[10000]={0},c[10000]={0},sa,sb,la,lb,lena,lenb,p,i,j,k,x=0,lenc,l;gets(a1); //读入gets(b1);la=strlen(a1); //算长度lb=strlen(b1);sa=la%9; //计算每九位划分后的剩余位数sb=lb%9;lena=la/9; lenb=lb/9;k=1;for(p=sa-1;p>=0;p--){a[lena]+=(a1[p]-48)*k;k*=10;} //处理第一个加数，每九位划分后剩余的位数转化为一个数p=sa;for(i=lena-1;i>=0;i--) //每九个字符转换为一个九位数存储在a[i]中{k=100000000;for(j=1;j<=9;j++){a[i]+=(a1[p]-48)*k;k/=10;p+=1;}}k=1;for(p=sb-1;p>=0;p--){b[lenb]+=(b1[p]-48)*k;k*=10;} //处理第二个加数，同上p=sb;for(i=lenb-1;i>=0;i--){k=100000000;for(j=1;j<=9;j++){b[i]+=(b1[p]-48)*k;k/=10;p+=1;}}i=0;while ((i<=lena)||(i<=lenb)) //计算{c[i]=a[i]+b[i]+x;x=c[i]/1000000000;c[i]%=1000000000;i++;}if (x!=0){lenc=i;c[lenc]=x;} //计算结果有没有增位else lenc=i-1;for(i=lenc;i>=0;i--)if (i!=lenc)printf("%09ld",c[i]);else printf("%ld",c[i]); //出开头按九位数输出return 0;}以下是一个pascal的高精度的乘法，原理同上，我只做了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;}六、总结高精度计算作为计算机科学中的重要应用之一，为许多计算机算法和应用提供了强大的支持。