高精度加法
C++知识点高精度
C++知识点⾼精度⼀.⾼精度加法1.1 ⾼精度加法⾼精度运算的基本运算就是加和减。
和算数的加减规则⼀样,模拟竖式计算,考虑错位运算与进位处理。
#include <cstdio>#include <cstring>int main(){char a[202]={0}, b[202]={0};scanf("%s%s", a, b);int alen = strlen(a), blen = strlen(b), t = 0, i;int a1[202]={0}, b1[202]={0};for (i = 0; i < alen; i++) a1[i] = a[alen-1-i]-'0';for (i = 0; i < blen; i++) b1[i] = b[blen-1-i]-'0';alen = (alen > blen) ? alen : blen;for (i = 0; i <= alen; i++)t = a1[i]+b1[i], a1[i] = t%10, a1[i+1] += t/10;while (!a1[i] && i) i--;for(; i >= 0; i--) printf("%d", a1[i]);return0;}1.2 ⾼精度加法(压位)(清北学堂成果)int型可以存9位数字,⽽上述代码在数组的每个元素中只存了0-9中的⼀位数,可以说浪费了很多空间,⽽且计算机计算4+5和3333+4444⽤的时间是相同的,所以我们有时候⽤压位来节省空间和时间。
其原理如下:从键盘读⼊⼤整数并存放在字符数组中从后向前每⼋位数字存放在⼀个int型数组的⼀个元素中对两个数组的对应元素进⾏加减运算,有进位要进位,最后输出#include <iostream>#include <cstring>#include <cstdio>using namespace std;const int INF = 1E8;struct Data{int u[50], l;Data(){memset(u, 0, sizeof(u)), l = 0;}void change(string a){int len = a.size(), k = len / 8, i = 0;l = k + (len%8 > 0);for (len; len > 8; len -= 8)sscanf(a.substr(len-8, 8).c_str(), "%d", &u[i++]);if (len > 0) sscanf(a.substr(0, len).c_str(), "%d", &u[i]);}void print(){int k = l-1;printf("%d", u[k--]);while (k >= 0) printf("%8.8d", u[k--]);printf("\n");}}a, b;int main(){string aa, bb, ac;cin >> aa >> bb;int ka = 0, kb = 0, i;a.change(aa),b.change(bb);for (i = 0; i < 50; i++)a.u[i] +=b.u[i], a.u[i+1] += a.u[i] / INF, a.u[i] %= INF;for (i = 49; a.u[i]==0 && i>0; i--);a.l = i + 1;a.print();return0;}⼆.⾼精度减法2.1 ⾼精度减法原理和加法⼀样,需要不过考虑的不是进位,⽽是借位。
蓝桥杯高精度加法
蓝桥杯高精度加法
蓝桥杯是全国性的计算机科学比赛,其中高精度加法是其中一道经典题目。
高精度加法是指对于两个超过了计算机能够表示的整数,需要使用字符串或数组等数据类型进行计算,以获取准确的结果。
这种计算方法通常被用于大数据处理和密码学等领域。
在蓝桥杯中,高精度加法的题目通常要求实现一个函数,该函数接受两个字符串参数代表两个整数,然后返回对应的加法结果。
实现高精度加法的关键在于对于进位的处理。
在每一位上,如果当前两个数字相加后超过了10,就需要将进位加到下一位上。
同时,在最高位上,如果相加后超过了最大位数,需要在最高位上加上进位。
除了基本的加法,高精度加法还可以扩展到多个数字的加法。
在这种情况下,可以使用数组或链表等数据结构进行计算。
在蓝桥杯的高精度加法题目中,通常需要注意输入数据的格式和边界情况。
同时,为了确保程序的效率,需要使用高效的算法和数据结构进行计算。
- 1 -。
C语言实现高精度加法
C语⾔实现⾼精度加法本篇为⾼精度加法的计算,接下来我还会去写⾼精度乘法的计算。
⼀、⾼精度运算的概念⾼精度运算其实就是参与运算的数完全超出基本数据类型所能表⽰的范围的运算(例如int型范围就是 - 2147483648 ~+ 2147483647)所以如果想求较⼤数的话就要创建新的数据类型⼆、数据类型的选取我选择的是int型数组,这样⽐较便于计算和理解三、代码其中a和b我是通过随机数来赋值//author summer_awn//date 2017/6/20#include<iostream>#include<time.h>#define lenth_a 200#define lenth_b 200using namespace std;//计算a+bvoid main() {srand((unsigned)time(NULL));int * a = new int[lenth_a];//数组a ******for (int i = 0; i < lenth_a; ++i) {a[i] = rand() % 10;}cout << "a=";for (int i = lenth_a - 1; i >= 0; --i) {//输出acout << a[i];}cout << endl;cout << endl;int * b = new int[lenth_b];//数组b ******for (int i = 0; i < lenth_a; ++i) {b[i] = rand() % 10;}cout << "b=";for (int i = lenth_b - 1; i >= 0; --i) {//输出bcout << b[i];}cout << endl;cout << endl;int lenth_result;//结果的长度enif (lenth_a > lenth_b) lenth_result = lenth_a + 1;else lenth_result = lenth_b + 1;//通过⼀个判断来确定结果的长度int * a2 = new int[lenth_result];//a2***********int * b2 = new int[lenth_result];//b2***********memcpy(a2, a, sizeof(int)*lenth_a);//memset(a2 + lenth_a, 0, sizeof(int)*(lenth_result - lenth_a));memcpy(b2, b, sizeof(int)*lenth_b);memset(b2 + lenth_b, 0, sizeof(int)*(lenth_result - lenth_b));delete(a);delete(b);int * result = new int[lenth_result];//result*********result[0] = a2[0] + b2[0];for (int i = 1; i < lenth_result - 1; ++i) {result[i] = a2[i] + b2[i] + result[i - 1] / 10;result[i - 1] = result[i - 1] % 10;}result[lenth_result - 1] = result[lenth_result - 2] / 10;result[lenth_result - 2] = result[lenth_result - 2] % 10;delete(a2);delete(b2);cout << "结果=";for (int i = lenth_result - 1; i >= 0; --i) {cout << result[i];}cout << endl;system("pause");delete(result);}四、结果结果有截图,未验证(因为懒)以上就是本⽂的全部内容,希望对⼤家的学习有所帮助,也希望⼤家多多⽀持。
高精度加法
答案:12345678911233
133 div 10=13,即新的进位,留给百位
3、百位9+13=22
22 mod 10=2,即新的百位数字为2
22 div 10=2,即新的进位,留给千位
4、千位9+2=11
11 mod 10=1,即新的千位数字为1
11 div 10=1,即新的进位,留给万位
5、万位0+1=1
输出结果: 因为a[1]是个位,a[2]是十位,……,因此 在输出时,应采取降序输出: for i:=n downto 1 do write(a[i]);
任务1: 请你编写程序,计算高精度与单精度数值之和并输出。
二、高精度加高精度 即:大数字加上大数字
如:12345678909999+9999888877776666
1 mod 10=1,即新的万位数字为1
1 div 10=0,没有进位,结束计算。
特殊情况:最高位进位 99999999999999+1=100000000000000
14位
15位
原有数值加上新数值以后,位数会增加,要考虑到
进位,一般是在加完以后判断最高位div10,看结果 是不是大于0,如果是说明有进位,应当处理进位: 1、原有长度加1 2、原最高位重新赋值 3、新最高位赋值
做法: 1、用2个字符串接收这2个数字; 2、定义三个数组:a,b,c,分别用来转换这两个大数字以及存储结果; 3、求出2个字符串的长度m和n,结果使用长字符串的长度(假如是k); 4、从个位开始逐位相加,并加上从前一位来的进位,个位时进位是0, 假设用t表示进位,开始时令t=0,就有c[1]:=a[1]+b[1]+t=9+6+0=15, 然后t:=c[1] div 10=1,也是下一位的进位,c[1]:=c[1] mod 10=5,即 个位真正的值,c[2]:=a[2]+b[2]+t=9+6+1=16,t:=c[2] div 10=1, c[2]:=c[2] mod 10=6,以后以此类推; 5、处理最高位的进位。
高精度计算加法
高精度计算加法1 加法加法是数学中最常见的计算方法,它是对两个数的求和运算。
它是计算机中也最常见的运算,也是最基本的运算。
在高精度的计算中,加法更加复杂,它要求计算精度更高,不能简单地看作就是对两个数求和。
下面我们就来介绍加法的高精度计算方法:2 高精度加法的实现原理高精度加法的实现原理是将两个数按位分解,然后依次相加,每位加法采用模运算处理进位,以避免溢出。
例如,两个数的加法运算如下:A=12345678B=98765432加法运算结果:101222210将A和B分解,A=12 345 678,B=98 765 4321.第一步:将B的最右位7和A的最右位8求和,得15,进位1;2.第二步:将B的倒数第二位6和A的倒数第二位5及进位1求和,得12,进位1;3.第三步:以此类推,将B的每一位和A的每一位及进位求和,最终得出的结果就是加法运算的结果:101222210。
从上述例子可以看出,在高精度加法中,每次进行加法运算的时候,都要考虑进位的情况,并采用模运算处理进位,以确保计算精确度不损失。
3 加法的应用在计算机科学中,高精度加法的应用极为广泛。
(1)大整数乘法计算:任意精度乘法运算可以转化成多次高精度加法运算,在大整数乘法中,可以采用高精度加法来进行转换,从而使得乘法运算更加准确。
(2)多项式乘法计算:多项式的乘法计算也可以采用高精度加法来计算,从而节省不少时间。
(3)向量运算:向量的运算也可以采用高精度加法来实现,可以在保证精度的前提下,大大节省时间。
4 总结高精度加法是数学中最常见的运算,也是计算机中最常见的运算。
它要求计算的精度更高,不能简单地看作就是对两个数求和。
为了保证运算的精度,需要采用模运算处理进位。
高精度加法的应用极为广泛,既可以用于大整数乘法计算,又可以用于多项式乘法计算,也可以用于向量运算。
Pascal高精度运算(加法篇)
高精度运算涉及到的问题:
1、数据的输入。 2、数据的存储。
3、数据的运算:进位。
4、结果的输出:小数点的位置、处理多余的0等。
高精度加法
题目要求: 输入: 第一行:正整数a。 第二行:正整数b。已知:a和b(<10240)。
思考、高精度减法运算
问题表述: 输入a,b(<10240)两个数,输出a-b的值。
样例1输入: 456 409 样例1输出: 47
样例2输入: 999 1000 样例2输出: -1
F(i):第i个月后共有的兔子对数。 F(1)=1; F(2)=1; f(3)=2; f(4)=3; f(5)=5; f(6)=8;
F(i)=f(i-2)+f(i-1)
{N<=93} var f:array[1..100] of longint; var n,i:integer; begin readln(n); f[1]:=1; f[2]:=1; for i:=3 to n do f[i]:=f[i-2]+f[i-1]; writeln(f[n]); end.
处理进位: for i:=1 to len do begin c[i+1]:=c[i+1]+c[i] div 10; c[i]:=c[i] mod 10; end;
4、结果的输出:数组c。
if c[len+1]>0 then len:=len+1; for i:=len downto 1 do write(c[i]);
继续思考
a,b:array[1..maxn] of integer; 在前面的运算中我们定义数组中的数字为 integer类型的值,但是我们知道integer的 值数字可以表示-32000到+32000之间的数 字,是否有些浪费?
高精度运算
高精度运算第二讲高精度运算(加法)一、高精度加法运算学习中级本书上的P180页到183页举例:回文数若一个数(首位不为零)从左向右读与从右向左读都是一样,我们就将其称之为回文数。
例如:给定一个10进制数56,将56加65(即把56从右向左读),得到121是一个回文数。
又如:对于10进制数87:STEP1:87+78 = 165 STEP2:165+561 = 726STEP3:726+627 = 1353 STEP4:1353+3531 = 4884 在这里的一步是指进行了一次N进制的加法,上例最少用了4步得到回文数4884。
写一个程序,给定一个N(2<=N<=10或N=16)进制数M,求最少经过几步可以得到回文数。
如果在30步以内(包含30步)不可能得到回文数,则输出“Impossible!”样例:INPUT OUTPUTN = 9 M= 87 STEP=6[算法设计] 本问题的核心是高精度加法,具体处理起来可以分为三个部分。
第一,是对读入数据的处理。
本题中,数据的进制是可变的,所以用整型数(即十进制数)不是很方便,考虑一般情况,我们可以采用字符串读入,再对数据作后期加工,把它的每一位都分离开来,存入一个数组digit里,数组invert存放数组digit的倒序,变量len记录了数据的位数。
在转化过程中要注意到16进制的特殊性,要对于字母A B C D E F要单独处理。
第二,进行判断与运算。
存储数据时用什么形式表示其实无所谓,关键是做加法运算的时候要符合n进制的规律。
所以,运算时一律以10进制形式存储,存储该位数码对应的十进制数值,A用10,F用15表示。
判断是否构成回文数时也一样用10进制,逐对比较对称的两个数位上的数字,看它们是否相等。
做加法的次数以30次为限。
第三,输出结果。
如果当前的数是回文数,则输出步数;否则按“Impossible”输出。
[程序清单]program ex6_5(input,output)const max=1000;type arraytype=array [1..max] of longint;var i,n,len,step:longint;str:string;digit,invert:arraytype;function palindrome(var digit:arraytype;len:longint):boolean;var i,j:longint;begini:=1; j:=len;while (i<="" p="">begin i:=i+1; j:=j-1 end;if iend;beginwrite('Input n:'); readln(n);write('Input number:'); readln(str);for i:=1 to max do digit[i]:=0;len:=length(str);for i:=1 to len doif str[i]>='A'then digit[len+1-i]:=ord(str[i])-ord('A')+10else digit[len+1-i]:=ord(str[i])-ord('0');step:=0;while (step<30) and not(palindrome(digit,len)) dobeginfor i:=1 to len do invert[i]:=digit[len+1-i];for i:=1 to len do digit[i]:=digit[i]+invert[i];for i:=1 to len doif digit[i]>=n thenbegin digit[i+1]:=digit[i+1]+1;digit[i]:=digit[i]-n end;if digit[len+1]>0 then len:=len+1;step:=step+1end;if step=30then writeln('Impossible!')else writeln('STEP=',step)end.二、高精度减法运算(中级书183~186页)自学三、高精度乘法运算学习中级本书上的P186页到189页举例:用高精度计算出S=1!+2!+3!+…+n!(n≤50),其中“!”表示阶乘,例如:5!=5*4*3*2*1,输入正整数N,输出计算结果S。
高精度加法(c++)
高精度加法(c++)题目:输入两个整数a和b,输出这两个整数的和。
a和b都不超过100位。
算法描述由于a和b都比较大,所以不能直接使用语言中的标准数据类型来存储。
对于这种问题,一般使用数组来处理。
定义一个数组A,A[0]用于存储a的个位,A[1]用于存储a的十位,依此类推。
同样可以用一个数组B来存储b。
计算c = a + b的时候,首先将A[0]与B[0]相加,如果有进位产生,则把进位(即和的十位数)存入r,把和的个位数存入C[0],即C[0]等于(A[0]+B[0])%10。
然后计算A[1]与B[1]相加,这时还应将低位进上来的值r也加起来,即C[1]应该是A[1]、B[1]和r三个数的和.如果又有进位产生,则仍可将新的进位存入到r中,和的个位存到C[1]中。
依此类推,即可求出C的所有位。
最后将C输出即可。
输入:输入包括两行,第一行为一个非负整数a,第二行为一个非负整数b。
两个整数都不超过100位,两数的最高位都不是0。
输出:输出一行,表示a + b的值。
样例输入20100122201001221234567890 2010012220100122样例输出20100122203011233454668012代码:#include <bits/stdc++.h>using namespace std;int a[100],b[100],c[100];int index=0,carry=0;int main() {string s1,s2;cin>>s1>>s2;for(int i=0; i<s1.length(); i++) { a[i]=s1[s1.length()-i-1]-'0';}for(int i=0; i<s2.length(); i++) { b[i]=s2[s2.length()-i-1]-'0';}while(index<s1.length()||index<s2.length()) { c[index]=a[index]+b[index]+carry;carry=c[index]/10;c[index]%=10;index++;}c[index]=carry;if(c[index]!=0) cout<<c[index];for(int i=index-1; i>=0; i--) {cout<<c[i];}return 0;}。
二进制高精度加法
二进制高精度加法1. 介绍二进制高精度加法是一种针对二进制数进行加法运算的方法。
在计算机科学和数字逻辑中,二进制数是一种常见的数值表示形式,它只包含0和1两个数字。
在进行二进制数的加法运算时,需要考虑进位的问题,确保计算结果的准确性和完整性。
本文将详细介绍二进制高精度加法的原理、步骤以及应用。
2. 原理二进制高精度加法的原理基于十进制高精度加法的原理。
在十进制加法中,当两个数字进行加法运算时,先进行个位数的相加,如果和值超过9,则需要向十位数进位,然后再进行十位数的相加。
同样地,在二进制高精度加法中,相邻位的相加可能会产生进位,需要将进位值加到下一位的运算中。
3. 步骤执行二进制高精度加法的步骤如下:3.1 对齐数字首先,需要将需要相加的两个二进制数进行对齐,确保它们的位数相同。
在对齐过程中,可以在较短的数值前面补0,使其位数和较长的数值相同。
对齐后,每一位上的数字相加得到的和即为该位上的运算结果。
3.2 逐位相加从两个二进制数的最低位(个位)开始,相邻位上的数字进行相加。
如果和值为0或1,直接写在对应的运算结果位上。
如果和值为2,则写0,并将进位标记为1。
如果和值为3,则写1,并将进位标记为1。
如果相加过程中出现进位,则需要将进位加到下一位的运算中,确保计算结果的准确性。
进位的处理方式为将进位值直接加到下一位的运算结果中。
3.4 考虑最高位的进位在相加的过程中,可能会出现最高位上的进位。
如果最高位上有进位产生,则需要在运算结果的最高位上加1。
3.5 结果输出经过以上步骤运算后,便得到了二进制高精度加法的结果。
结果可以表示为一个二进制数,即加法的和。
4. 例子下面以一个例子来演示二进制高精度加法的过程。
4.1 例子说明假设需要将二进制数10101和1101相加。
4.2 对齐数字将10101和01101对齐,得到:10101+ 011014.3 逐位相加从最低位开始,逐位相加。
得到的运算结果如下:110101+ 01101-----100110在相加过程中,没有出现进位。
【模板题】高精度加法-高精度加法模板
【模板题】高精度加法-高精度加法模板一、背景介绍在日常生活和工作中,我们经常会遇到需要进行高精度加法运算的问题,比如金融领域的利息计算、科学研究中的数据处理等。
高精度加法是指在计算过程中需要考虑更多位数的精度,避免因舍入误差而影响计算结果的准确性。
为了解决这一问题,我们需要掌握高精度加法的模板和方法。
二、高精度加法模板1. 定义两个字符串表示的大数:例如"123456789"表示一个大数123456789。
2. 从右往左,对两个大数的相同位置的数字进行相加,若有进位则向高位加一。
3. 如果两个大数位数不一样,要在短的大数前面补0,使其位数一样,再按照规则进行相加。
4. 最后得到的结果需要进行判断,看最高位是否有进位。
5. 输出最后的结果。
以上就是高精度加法的基本模板,通过这个模板我们可以实现任意位数的大数加法计算。
三、高精度加法的应用高精度加法的应用非常广泛,比如在金融领域的利息计算中,由于涉及到较大的金额和较长的时间跨度,需要进行高精度的加法运算,以确保计算结果的准确性;在科学研究中,处理实验数据时也经常需要进行高精度加法运算,以避免数据误差对实验结果造成影响;在工程领域的精确计算、密码学的加密算法设计等领域,高精度加法也具有重要的应用价值。
四、个人观点和总结高精度加法作为一种重要的数学运算方法,在现实生活和工作中有着广泛的应用。
掌握高精度加法的模板和方法,不仅可以提高我们的计算准确性,还可以拓展我们的数学思维。
在日常生活中,我们也可以运用高精度加法的思想,提高我们的逻辑思维能力和解决问题的能力。
高精度加法是一种非常有价值的数学工具,通过深入理解和掌握其模板和方法,可以帮助我们更好地应对复杂的计算问题,提高我们的工作效率和计算准确性。
高精度加法也是数学教育中的重要内容之一,通过学习和应用高精度加法,我们可以培养自己的数学思维和解决实际问题的能力。
高精度加法是一种非常重要的数学工具,它在日常生活和工作中有着广泛的应用。
高精度算法(加减)
高精度-加法
(3)去掉最高位的0 因为两数相加,也可能不产生进位,因此要把这种情况下最高位的0去掉,其实就 是减小和的长度len的值。 While ( (len>1) && (c[len] ==0))
len--; 注意,len>1的条件是必要的,因为如果和是0的话,想一想该如何保存。
【方法一】 1、同位相加+进位 2、进位 3、存余数
2、变量的使用要规范: 如:循环控制变量一般用 i 、 j 、 k,一般不要用m、n等。 长度用len表示。 这样容易找错误。
比较两个高精度数大小
当a>b,返回1; a<b,返回-1;a==b,返回0 int compare(hp a, hp b) {
int i; if (a[0] > b[0]) return 1; if (a[0] < b[0]) return -1; for (i=a[0]; i>=1; i--)
//同位相加+进位; //进位到上一位 //存余数
【方法二】 1、同位相加 2、进位存余
高精度-加法
9758 567
1 0325
a4 a3 a2 a1 b3 b2 b1
c5 c4 c3 c2 c1
高精度- for(int i=1;i<=lenc;i++){
高精度-减法
【探究】若 被减数小于减数 如何改编代码?
• 假设str1 为被减数,str2为减数: • 比较两个字符串的大小
• 若 str1 的长度大于 str2,则说明 被减数 大于 减数; • 若 str1 的长度等于 str2,则需要比较两个字符串的大小(string类型可直接比较大小); • 若 str1 的长度小于 str2,则说明 被减数 小于 减数; • 若str1小与str2,则交换两个字符串数据,并输出负号 '-';否则不做其他操作
高精度vector加法
高精度vector加法在计算机科学领域中,矢量(vector)通常指向量(指有方向和大小的量),在高精度计算中也有类似的概念。
对于一个n位的高精度数字,我们可以将其视为一个n维的整数向量,其中每一位上的数字作为向量的一个分量。
在实际应用中,常常需要对两个高精度向量进行加法运算。
简单的算法是将两个向量相应分量上的数字相加,得到一个新的向量作为结果。
然而,这种算法的时间复杂度是线性级别的,即O(n),其中n为向量的长度。
当n很大时,这种算法会表现出很差的性能。
一种更快的算法是采用分治思想。
我们可以将两个向量分别拆分成左右两个子向量,再分别对子向量进行加法运算。
这样一来,在每一层递归中,我们只需处理两个长度为n/2的子向量,而不是一个长度为n的向量,从而达到了减少计算量的目的。
最终的结果就是将所有子向量的结果合并起来就得到了最终的答案。
这种算法的时间复杂度为O(logn),是线性级别的。
具体的实现过程可以分为以下几步:1. 确定最终结果向量的长度由于两个向量的长度可能不同,对于最终的结果向量来说,其长度应该为输入向量中长度最大的那个。
2. 补齐长度不足的向量为了方便计算,我们需要先将长度较短的向量在高位上补齐0,使得两个向量的长度相等。
3. 递归进行加法运算将两个输入向量分别拆分成左右两个子向量,然后对子向量进行加法运算。
如果当前向量的长度小于某个阈值(比如16),那么我们就直接采用简单算法进行加法运算。
4. 合并子向量的结果将左右子向量的结果合并起来即可得到当前向量的结果。
对于最终的结果向量来说,合并子向量的结果也就是将所有子向量的结果合并起来。
需要注意的是,在运算过程中,我们需要进行进位操作。
具体的实现可以采用递归方法或循环方法,以保证算法的性能。
最终,我们可以得到一个高效的高精度向量加法算法,它可以在O(log n)时间内计算出任意长度的高精度向量的和。
该算法可以应用于各种领域,如密码学、计算几何等,具有广泛的应用前景和科研价值。
高精度算法
高精度算法1、高精度加法program HighPrecision1_Plus;constfn_inp='hp1.inp';fn_out='hp1.out';maxlen=100; { 数的最大长度}typehp=recordlen:integer; { 数的长度}s:array[1..maxlen] of integer{ s[1]为最低位,s[len]为最高位}end;varx:array[1..2] of hp;y:hp; { x:输入; y:输出}procedure PrintHP(const p:hp);var i:integer;beginfor i:=p.len downto 1 do write(p.s);end;procedure init; {初始化}varst:string;j,i:integer;beginassign(input,fn_inp);reset(input);for j:=1 to 2 dobeginreadln(st);x[j].len:=length(st);for i:=1 to x[j].len do { 将字符串转换到HP }x[j].s:=ord(st[x[j].len+1-i])-ord('0');end;close(input);end;procedure Plus(a,b:hp;var c:hp); { c:=a+b }var i,len:integer;beginfillchar(c,sizeof(c),0);if a.len>b.len then len:=a.len { 从a,b中取较大长度}else len:=b.len;for i:=1 to len do { 从低到高相加} begininc(c.s,a.s+b.s);if c.s>=10 thenbegindec(c.s,10);inc(c.s[i+1]); { 加1到高位}end;end;if c.s[len+1]>0 then inc(len);c.len:=len;end;procedure out; {打印输出}beginassign(output,fn_out);rewrite(output);PrintHP(y);writeln;close(output);end;begininit;Plus(x[1],x[2],y);out;end.2、高精度减法program HighPrecision2_Subtract; constfn_inp='hp2.inp';fn_out='hp2.out';maxlen=100; { 数的最大长度} typehp=recordlen:integer; { 数的长度}s:array[1..maxlen] of integer{ s[1]为最低位,s[len]为最高位} end;varx:array[1..2] of hp;y:hp; { x:输入; y:输出}positive:boolean;procedure PrintHP(const p:hp);var i:integer;beginfor i:=p.len downto 1 do write(p.s);end;procedure init;varst:string;j,i:integer;beginassign(input,fn_inp);reset(input);for j:=1 to 2 dobeginreadln(st);x[j].len:=length(st);for i:=1 to x[j].len do { change string to HP }x[j].s:=ord(st[x[j].len+1-i])-ord('0');end;close(input);end;procedure Subtract(a,b:hp;var c:hp); { c:=a-b, suppose a>=b } var i,len:integer;beginfillchar(c,sizeof(c),0);if a.len>b.len then len:=a.len { get the bigger length of a,b } else len:=b.len;for i:=1 to len do { subtract from low to high }begininc(c.s,a.s-b.s);if c.s<0 thenbegininc(c.s,10);dec(c.s[i+1]); { add 1 to a higher position }end;end;while(len>1) and (c.s[len]=0) do dec(len);c.len:=len;end;function Compare(const a,b:hp):integer;{1 if a>b0 if a=b-1 if a < b}var len:integer;beginif a.len>b.len then len:=a.len { get the bigger length of a,b } else len:=b.len;while(len>0) and (a.s[len]=b.s[len]) do dec(len);{ find a position which have a different digit }if len=0 then compare:=0 { no difference }else compare:=a.s[len]-b.s[len];end;procedure main;beginif Compare(x[1],x[2])<0 then positive:=falseelse positive:=true;if positive then Subtract(x[1],x[2],y)else Subtract(x[2],x[1],y);end;procedure out;beginassign(output,fn_out);rewrite(output);if not positive then write('-');PrintHP(y);writeln;close(output);end;begininit;main;out;end.3、高精度乘法1).高精度乘单精度(1位数)程序如下:program HighPrecision3_Multiply1;constfn_inp='hp3.inp';fn_out='hp3.out';maxlen=100; { 数的最大长度}typehp=recordlen:integer; { 数的长度}s:array[1..maxlen] of integer{ s[1]为最低位,s[len]为最高位}end;varx:array[1..2] of hp;y:hp; { x:输入; y:输出}procedure PrintHP(const p:hp);var i:integer;beginfor i:=p.len downto 1 do write(p.s);end;procedure init;varst:string;i:integer;beginassign(input,fn_inp);reset(input);readln(st);x.len:=length(st);for i:=1 to x.len do { change string to HP }x.s:=ord(st[x.len+1-i])-ord('0');readln(z);close(input);end;procedure Multiply(a:hp;b:integer;var c:hp); { c:=a*b } var i,len:integer;beginfillchar(c,sizeof(c),0);len:=a.len;for i:=1 to len dobegininc(c.s,a.s*b);inc(c.s[i+1],c.s div 10);c.s:=c.s mod 10;end;inc(len);while(c.s[len]>=10) dobegininc(c.s[len+1],c.s[len] div 10);c.s[len]=c.s[len] mod 10;inc(len);end;while(len>1) and (c.s[len]=0) do dec(len);c.len:=len;end;procedure main;beginMultiply(x,z,y);end;procedure out;beginassign(output,fn_out);rewrite(output);PrintHP(y);writeln;close(output);end;begininit;main;out;end.2).高精度乘一个整型数据(integer)只需要将上述程序的hp类型定义如下即可: typehp=recordlen:integer { length of the number }s:array[1..maxlen] of longint{ s[1] is the lowest positions[len] is the highest position }end;3).高精度乘高精度program HighPrecision4_Multiply2;constfn_inp='hp4.inp';fn_out='hp4.out';maxlen=100; { max length of the number } typehp=recordlen:integer; { length of the number }s:array[1..maxlen] of integer{ s[1] is the lowest positions[len] is the highest position }varx:array[1..2] of hp;y:hp; { x:input ; y:output }procedure PrintHP(const p:hp);var i:integer;beginfor i:=p.len downto 1 do write(p.s);end;procedure init;varst:string;j,i:integer;beginassign(input,fn_inp);reset(input);for j:=1 to 2 dobeginreadln(st);x[j].len:=length(st);for i:=1 to x[j].len do { change string to HP }x[j].s:=ord(st[x[j].len+1-i])-ord('0');end;close(input);end;procedure Multiply(a,b:hp;var c:hp); { c:=a+b }var i,j,len:integer;beginfillchar(c,sizeof(c),0);for i:=1 to a.len dofor j:=1 to b.len dobegininc(c.s[i+j-1],a.s*b.s[j]);inc(c.s[i+j],c.s[i+j-1] div 10);c.s[i+j-1]:=c.s[i+j-1] mod 10;end;len:=a.len+b.len+1;{the product of a number with i digits and a number with j digits can only have at most i+j+1 digits}while(len>1)and(c.s[len]=0) do dec(len);c.len:=len;procedure main;beginMultiply(x[1],x[2],y);end;procedure out;beginassign(output,fn_out);rewrite(output);PrintHP(y);writeln;close(output);end;begininit;main;out;end.4、高精度除法1).高精度除以整型数据(integer);程序如下:program HighPrecision3_Multiply1;constfn_inp='hp5.inp';fn_out='hp5.out';maxlen=100; { max length of the number } typehp=recordlen:integer; { length of the number }s:array[1..maxlen] of integer{ s[1] is the lowest positions[len] is the highest position }end;varx,y:hp;z,w:integer;procedure PrintHP(const p:hp);var i:integer;beginfor i:=p.len downto 1 do write(p.s);end;procedure init;varst:string;i:integer;beginassign(input,fn_inp);reset(input);readln(st);x.len:=length(st);for i:=1 to x.len do { change string to HP }x.s:=ord(st[x.len+1-i])-ord('0');readln(z);close(input);end;procedure Divide(a:hp;b:integer;var c:hp;var d:integer); { c:=a div b ; d:=a mod b }var i,len:integer;beginfillchar(c,sizeof(c),0);len:=a.len;d:=0;for i:=len downto 1 do { from high to low }begind:=d*10+a.s;c.s:=d div b;d:=d mod b;end;while(len>1) and (c.s[len]=0) do dec(len);c.len:=len;end;procedure main;beginDivide(x,z,y,w);end;procedure out;beginassign(output,fn_out);rewrite(output);PrintHP(y);writeln;writeln(w);close(output);end;begininit;main;out;end.2).高精度除以高精度程序如下:program HighPrecision4_Multiply2;constfn_inp='hp6.inp';fn_out='hp6.out';maxlen=100; { max length of the number } typehp=recordlen:integer; { length of the number }s:array[1..maxlen] of integer{ s[1] is the lowest positions[len] is the highest position }end;varx:array[1..2] of hp;y,w:hp; { x:input ; y:output }procedure PrintHP(const p:hp);var i:integer;beginfor i:=p.len downto 1 do write(p.s);end;procedure init;varst:string;j,i:integer;beginassign(input,fn_inp);reset(input);for j:=1 to 2 dobeginreadln(st);x[j].len:=length(st);for i:=1 to x[j].len do { change string to HP } x[j].s:=ord(st[x[j].len+1-i])-ord('0');end;close(input);end;procedure Subtract(a,b:hp;var c:hp); { c:=a-b, suppose a>=b } var i,len:integer;beginfillchar(c,sizeof(c),0);if a.len>b.len then len:=a.len { get the bigger length of a,b } else len:=b.len;for i:=1 to len do { subtract from low to high }begininc(c.s,a.s-b.s);if c.s<0 thenbegininc(c.s,10);dec(c.s[i+1]); { add 1 to a higher position }end;end;while(len>1) and (c.s[len]=0) do dec(len);c.len:=len;end;function Compare(const a,b:hp):integer;{1 if a>b0 if a=b-1 if a < b}var len:integer;beginif a.len>b.len then len:=a.len { get the bigger length of a,b } else len:=b.len;while(len>0) and (a.s[len]=b.s[len]) do dec(len);{ find a position which have a different digit }if len=0 then compare:=0 { no difference }else compare:=a.s[len]-b.s[len];end;procedure Multiply10(var a:hp); { a:=a*10 }var i:Integer;beginfor i:=a.len downto 1 doa.s[i+1]:=a.s;a.s[1]:=0;inc(a.len);while(a.len>1) and (a.s[a.len]=0) do dec(a.len);end;procedure Divide(a,b:hp;var c,d:hp); { c:=a div b ; d:=a mod b }var i,j,len:integer;beginfillchar(c,sizeof(c),0);len:=a.len;fillchar(d,sizeof(d),0);d.len:=1;for i:=len downto 1 dobeginMultiply10(d);d.s[1]:=a.s; { d:=d*10+a.s }{ c.s:=d div b ; d:=d mod b; }{ while(d>=b) do begin d:=d-b;inc(c.s) end }while(compare(d,b)>=0) dobeginSubtract(d,b,d);inc(c.s);end;end;while(len>1)and(c.s[len]=0) do dec(len);c.len:=len;end;procedure main;beginDivide(x[1],x[2],y,w);end;procedure out;beginassign(output,fn_out);rewrite(output);PrintHP(y);writeln;PrintHP(w);writeln;close(output);end;begininit;main;out;end.练习:求n!(n<10000)的最后一位不为0的数字.。
高精度计算c++加法
高精度计算c++加法在计算机科学中,高精度计算是经常需要用到的一种技术,尤其是在处理大数运算时。
C语言是一种常用的编程语言,它提供了许多内置函数来处理整数,包括高精度计算。
在C语言中,可以使用长整型数据类型来进行高精度计算。
本文将介绍如何使用C语言进行高精度加法运算。
一、高精度加法原理高精度加法运算与普通的加法运算有一些不同。
在普通加法中,我们需要考虑进位的问题,而在高精度加法中,我们需要考虑的是位的数量。
也就是说,我们需要将两个大数分别表示成一位一位的形式,然后逐位相加,如果有进位,则要向上一位加。
最终得到的结果就是两个大数和的最高位以及剩下的位。
二、实现高精度加法下面是一个简单的C语言程序,用于实现高精度加法:```c#include <stdio.h>#include <stdlib.h>#define MAX_DIGITS 1000 // 定义最大位数// 高精度加法函数long long add(long long a, long long b) {long long carry = 0; // 进位初始化为0long long result[MAX_DIGITS+1]; // 结果数组,长度为最大位数+1int i, k; // i表示当前处理的位数,k表示当前位的值for (i = 0; i < MAX_DIGITS; i++) { // 处理每一位k = (int)a % 10 + (int)b % 10; // 当前位的值result[i] = k + carry; // 加上进位carry = result[i] / 10; // 计算进位result[i+1] += carry * 10; // 将进位写入下一个位置}if (carry > 0) { // 如果有进位result[MAX_DIGITS] += carry; // 将最高位的进位写入结果数组的最后一位}// 将结果数组逆序输出即可得到结果for (i = MAX_DIGITS-1; i >= 0; i--) {printf("%lld ", result[i]);}printf("\n");return result[0]; // 返回结果数组的第一个值}int main() {long long a, b, result;printf("Enter two large numbers: \n");scanf("%lld %lld", &a, &b); // 读入两个大数result = add(a, b); // 对两个数进行高精度加法运算printf("Result: %lld\n", result); // 输出结果return 0;}```这个程序中,我们首先定义了一个常量MAX_DIGITS来表示最大位数。
高精度加函数
高精度加函数摘要:一、高精度加法函数的定义二、高精度加法函数的应用场景三、高精度加法函数的优缺点分析四、高精度加法函数的实现方法五、高精度加法函数的发展趋势与展望正文:高精度加法函数是一种在计算机科学中处理大数相加的算法。
在实际应用中,常常需要处理很大的整数或者浮点数,这时候传统的低精度加法函数就无法满足需求。
高精度加法函数通过使用特殊的算法和数据结构,可以实现对大数的快速、精确的加法运算。
高精度加法函数广泛应用于各种领域,如计算机图形学、数值分析、密码学等。
例如,在计算机图形学中,需要对大量的顶点坐标进行计算,这时候就需要使用高精度加法函数来保证计算结果的精度;在数值分析中,高精度加法函数可以用于解决线性和非线性方程组,提高计算效率;在密码学中,高精度加法函数可以用于实现数字签名、加密和解密等算法。
高精度加法函数具有以下几个优缺点:1.优点:可以处理很大的数值,提高了计算范围;计算速度快,效率高;支持多种数据类型,如整数、浮点数等。
2.缺点:相对于传统的低精度加法函数,高精度加法函数的实现较为复杂,计算资源消耗较高。
高精度加法函数的实现方法主要有以下几种:1.基于竖式加法的实现方法:将大数转换为字符串,然后按照竖式加法的方式进行计算。
这种方法简单易实现,但是效率较低。
2.基于模运算的实现方法:将大数转换为同余类,然后利用模运算的性质进行计算。
这种方法效率较高,但是实现较为复杂。
3.基于FFT(快速傅里叶变换)的实现方法:利用FFT 算法将大数转换为频域表示,然后进行加法运算。
这种方法效率高,但是实现较为复杂。
随着计算机科学的发展,高精度加法函数的应用将会越来越广泛。
高精度计算加法
高精度计算加法
一、高精度计算加法
高精度计算加法可以用来解决计算上的精度问题,其优点是可以保证结果的准确性和精确度,节省计算量。
在实际的工程计算中,精度的要求越来越高,因此,高精度计算加法技术的重要性也日益凸显。
高精度计算加法可以通过不同的算法来实现。
首先,可以借助位移算法来实现,该算法利用位移操作将两个数字的位移到相同的位置,然后,再两个数相加,以实现加法计算。
其次,可以使用“自下而上”算法来实现,该算法称之为完全加法器,以把小的数字自下而上的层级相加,最终实现大的数字的加法计算。
此外,高精度计算加法还可以用分治算法来实现,该算法利用分治的思想,将两个大数分解成若干个小的数字,然后分别进行加法计算,最终将两个大数相加。
以上就是高精度计算加法的基本原理,虽然不同的算法都可以实现,但每个算法都有自己的优点和缺点。
因此,在实际应用中,应根据实际情况来灵活选用适合自己的技术。
- 1 -。
高精度计算(加法)
高精度计算(加法)高精度加法所谓的高精度运算,是指参与运算的数(加数,减数,因子……)范围大大超出了标准数据类型(整型,实型)能表示的范围的运算。
例如,求两个200位的数的和。
这时,就要用到高精度算法了。
在这里,我们先讨论高精度加法。
高精度运算主要解决以下三个问题:基本方法1、加数、减数、运算结果的输入和存储运算因子超出了整型、实型能表示的范围,肯定不能直接用一个数的形式来表示。
在Pascal中,能表示多个数的数据类型有两种:数组和字符串。
(1)数组:每个数组元素存储1位(在优化时,这里是一个重点!),有多少位就需要多少个数组元素;用数组表示数的优点:每一位都是数的形式,可以直接加减;运算时非常方便用数组表示数的缺点:数组不能直接输入;输入时每两位数之间必须有分隔符,不符合数值的输入习惯;(2)字符串:字符串的最大长度是255,可以表示255位。
用字符串表示数的优点:能直接输入输出,输入时,每两位数之间不必分隔符,符合数值的输入习惯;用字符串表示数的缺点:字符串中的每一位是一个字符,不能直接进行运算,必须先将它转化为数值再进行运算;运算时非常不方便;(3)因此,综合以上所述,对上面两种数据结构取长补短:用字符串读入数据,用数组存储数据:var s1,s2:string;a,b,c:array [1..260] of integer;i,l,k1,k2:integer;beginwrite('input s1:');readln(s1);write('input s2:');readln(s2);{————读入两个数s1,s2,都是字符串类型}l:=length(s1);{求出s1的长度,也即s1的位数;有关字符串的知识。
}k1:=260;for i:=l downto 1 dobegina[k1]:=ord(s1[i])-48;{将字符转成数值}k1:=k1-1;end;k1:=k1+1;{————以上将s1中的字符一位一位地转成数值并存在数组a中;低位在后(从第260位开始),高位在前(每存完一位,k1减1)}对s2的转化过程和上面一模一样。
高精度运算(加减)
高精度运算(加减)高精度计算(一)一、教学目标●了解什么是高精度计算。
为什么要进行高精度计算。
●熟练掌握基本的加、减高精度计算二、重点难点分析●高精度数的存储方式;三、教具或课件使用多媒体演示文稿四、主要教学过程(一)引入新课利用计算机进行数值计算,有时会遇到这样的问题:有些计算要求精度高,希望计算的数的位数可达几十位甚至几百位,虽然计算机的计算精度也算较高了,但因受到硬件的限制,往往达不到实际问题所要求的精度.我们可以利用程序设计的方法去实现这们的高精度计算.这里仅介绍常用的几种高精度计算的方法。
(二)教学过程设计1、高精度计算中需要处理好以下几个问题:(1)数据的接收方法和存贮方法数据的接收和存贮:当输入的数很长时,可采用字符串方式输入,这样可输入数字很长的数,利用字符串函数和操作运算,将每一位数取出,存入数组中.Type numtype=array[1..500]of word;{整数数组类型}Var a,b:numtype;{a和b为整数数组}la,lb:integer;{整数数组a的长度和b的长度}s:string;{输入数串}将数串s转化为整数数组a的方法如下:readln(s);la:=length(s);for i:=1 to la do a[la-i+1]:=ord(s[i])-ord(‘0’);另一种方法是直接用循环加数组方法输入数据.Type arr= array[1..100] of integer;prucedure readdata(var int:arr);var ch:char;i,k:integer;beginread(ch);k:=0;while ch in['0'..'9'] do begininc(k);int[k]:=ord(ch)-ord(‘0’);read(ch);end;end;储存数据一律用数组。
根据不同的需要,数据的储存可分正向与反向两种。
高精度四则运算
高精度四则运算
高精度除法: 1. 将被除数和除数从高位开始逐位相除,将每一位的结果保存在一个新的数组中。 2. 需要注意的是,如果被除数小于除数Байду номын сангаас则需要向高位借位。 3. 最后将得到的结果进行逆序输出即可。
需要注意的是,在进行高精度运算时,需要考虑到进位和借位的情况,以及结果的正负号 等特殊情况。
高精度四则运算
高精度减法: 1. 将被减数和减数从低位开始逐位相减,将每一位的结果保存在一个新的数组中。 2. 需要注意的是,如果减数大于被减数,则需要向高位借位。 3. 最后将得到的结果进行逆序输出即可。
高精度乘法: 1. 将两个大整数从低位开始逐位相乘,将每一位的结果保存在一个新的数组中。 2. 需要注意的是,相乘的结果可能会超过10,需要进行进位。 3. 最后将得到的结果进行逆序输出即可。
高精度四则运算
高精度四则运算是指在计算过程中保持数值的精度,避免因计算过程中的截断误差而导致 结果不准确的问题。在计算机中,通常使用字符串或数组来表示大整数,通过模拟手工计算 的过程进行运算。
高精度加法: 1. 将两个大整数从低位开始逐位相加,将每一位的结果保存在一个新的数组中。 2. 需要注意的是,如果相加的两个位数之和超过了9,则需要进位。 3. 最后将得到的结果进行逆序输出即可。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
程序设计挑战式课程设计极限挑战挑战,不是为着征服自然,而是为着突破自我,超越自我生命有极限,思想无极限,高度有极限,境界无极限
作业名称:
高精度加法 学 院:
班 级:
学 号:
姓 名:
团队组成: 无
大学
2015年11月23日
请填写以下十项内容,将表格按页对齐(插入空行),勿删除任何部分。
1、问题与背景(描述程序所要解决的问题或应用背景)
2、开发工具(列出所使用的开发工具和第3方开发库)
3、主要功能(详细说明程序的功能)
4、设计内容(详细描述解决问题的原理和方法、算法、数据结构等)
5、程序文件与工程名称(标出程序中所有文件名、工程名称及其说明)
6、函数模块(程序中各个函数的原型声明及其说明)
7、使用说明(运行程序的小型说明书)
8、程序开发总结(简要叙述编写本作业的收获与思考)
9、运行截图(附上程序运行的截图画面,至少有1幅,截图越翔实得分越高)
Windows中抓取当前活动窗口:Alt + Print Screen,抓取全屏:Print Screen。
或者使用HyperSnap等软件(百度搜索)。
10、源程序(附上程序源代码,若是多个文件,标出文件名)
源文件:高精度加法\main.cpp
源代码如下:
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
void add(const char *num1,const char *num2,char *result);
int main()
{
char s[100]={0},argv1[100]={0},argv2[100]={0};
int a=1;
cout<<"本程序用于两个数的高精度加法计算,允许正负号"<<endl;
cout<<endl<<endl;
while (a)
{
cout<<"请分别输入两个100位以内的数字,以回车结束"<<endl;
gets(argv1);
gets(argv2);
cout<<endl;
cout<<"下面将输出两数的和"<<endl;
add(argv1,argv2,s);
cout<<s<<endl<<endl;
cout<<"继续请输入1,结束请输入0"<<endl;
cin>>a;
cout<<endl;
if (a)
{
s[100]={0},argv1[100]={0},argv2[100]={0};
cout<<"请按回车以继续"<<endl;
getchar(),getchar();
cout<<endl;
}
}
return 0;
}
int ctoi(char c)
{
return (c-'0');
}
void _add(const char *num1,const char *num2,char *result) {
int i,j,k,n1,n2,n;
int sig,sta,car,len1,len2;
char c[100]={0};
sig=(*num1=='-')?-1:1,sta=(sig==-1)?1:0;
len1=strlen(num1),len2=strlen(num2);
if (len1>=len2)
{
j=len2-1;
k=0,car=0;
for (i=len1-1;i>=sta;i--)
{
n1=ctoi(num1[i]);
n2=(j>=sta)?(ctoi(num2[j])):0;
j--;
n=(car==1)?(n1+n2+1):(n1+n2);
if (n>9) n=n%10,car=1;
else car=0;
c[k]=n+'0';
k++;
}
if (car==1) c[k]=1+'0',k++;
}
else
{
j=len1-1;
k=0,car=0;
for (i=len2-1;i>=sta;i--)
{
n2=ctoi(num2[i]);
n1=(j>=sta)?(ctoi(num1[j])):0;
j--;
n=(car==1)?(n1+n2+1):(n1+n2);
if (n>9) n=n%10,car=1;
else car=0;
c[k]=n+'0';
k++;
}
if (car==1) c[k]=1+'0',k++;
}
i=0;
if (sig==-1) result[i]='-',i++;
for (j=k-1;j>=0;j--) result[i]=c[j],i++;
}
void _sub(const char *num1,const char *num2,char *result)
{
int i,j,k,n1,n2,n;
int sig,sta1,sta2,car,len1,len2;
char c[100]={0};
sig=(*num1=='-')?-1:1,sta1=(*num1=='-')?1:0,sta2=(*num2=='-')?1:0;
len1=strlen(num1),len2=strlen(num2);
j=len2-1,k=0,car=0;
for (i=len1-1;i>=sta1;i--)
{
n1=ctoi(num1[i]);
n2=(j>=sta2)?(ctoi(num2[j])):0;
j--;
if (car==1) n1=n1-1,car=0;
if (n1<n2) n=n1+10-n2,car=1;
else n=n1-n2;
c[k]=n+'0';
k++;
}
i=0;
if (sig==-1) result[i]='-',i++;
for (j=k-1;j>=0;j--) result[i]=c[j],i++;
}
void add(const char *num1,const char *num2,char *result) {
int i,j,bigger=0;
int sig1,sig2,sta1,sta2,len1,len2;
sig1=(*num1=='-')?-1:1,sig2=(*num2=='-')?-1:1;
sta1=(sig1==-1)?1:0,sta2=(sig2==-1)?1:0;
len1=strlen(num1),len2=strlen(num2);
if (sig1==sig2) bigger=-1;
else if ((len1-sta1)>(len2-sta2)) bigger=1;
else if ((len1-sta1)<(len2-sta2)) bigger=2;
else
{
for (i=sta1;i<len1;i++)
{
j=sta2;
if (num1[i]>num2[j])
{
bigger=1;
break;
}
else if (num1[i]<num2[j])
{
bigger=2;
break;
}
j++;
}
}
switch (bigger)
{
case 0: result[0]='0'; break;
case -1: _add(num1,num2,result); break;
case 1: _sub(num1,num2,result); break;
case 2: _sub(num2,num1,result); break;
default: break;
}
}。