- 中文名
- 高精度算法
- 外文名
- High Accuracy Algorithm
- 适用领域
- 计算机科学
- 所属学科
- 数据结构与算法分析
高精度加法
var a,b,c:
array[1..201] of 0..9;
n:string;
lenalenb,lenc,i,x:integer;
begin
write('Inputaugend:');
readln(n);
lena:=length(n);
for i:=1 to lena do a[lena-i+1]:=ord(n)-ord('0');{加数放入a数组}
write('Inputaddend:');
readln(n);
lenb:=length(n);
for i:=1 to lenb do b[lenb-i+1]:=ord(n)-ord('0');{被加数放入b数组}
i:=1;
while (i<=lena)or(i<=lenb) do begin
x:=a[i]+b[i]+xdiv10;{两数相加，然后加前次进位}
c[i]:=xmod10;{保存第i位的值}
i:=i+1
end;
if x>=10 {处理最高进位} then begin
lenc:=i;
c:=1;
end
else enc:=i-1;
for i:=lenc downto 1 do write(c);
writeln;{输出结果}
end.
高精度乘法低对高
constmax=100;n=20;
vara:
array[1..max]of0..9;
i,j,k,x:integer;
begin
k:=1;a[k]:=1;{a=1}
fori:=2tondo{a*2*3….*n}begin
x:=0;{进位初始化}
forj:=1tokdo{a=a*i}begin
x:=x+a[j]*i;
a[j]:=xmod10;
x:=xdiv10
end;
whilex>0do{处理最高位的进位}begin
k:=k+1;
a[k]:=xmod10;
x:=xdiv10
end;
end;
writeln;
fori:=kdownto1write(a);{输出a}
end.
高精度乘法高对高
vara,b,c:
array[1..200]of0..9;
n1,n2:string;
lena,
lenb,lenc,i,j,x:integer;
begin
write('Inputmultiplier:');readln(n1);
write('Inputmultiplicand:');readln(n2);
lena:=length(n1);lenb:=length(n2);
fori:=1tolenadoa[lena-i+1]:=ord(n1)-ord('0');
fori:=1tolenbdob[lenb-i+1]:=ord(n2)-ord('0');
fori:=1tolenadobegin
x:=0;
forj:=1tolenbdo{对乘数的每一位进行处理}begin
x:=a[j]*b[j]+xdiv10+c;{当前乘积+上次乘积进位+原数}
c:=xmod10;
end;
c:=xdiv10;{进位}
end;
lenc:=i+j;
while(c[lenc]=0)and(lenc>1)dodec(lenc);{最高位的0不输出}
fori:=lencdownto1dowrite(c);
writeln;
end.
高精度除法
算法一
procedurehigh_devide(a,b:hp;varc,d:hp);
var
i,len:integer;
begin
fillchar(c,sizeof(c),0);
fillchar(d,sizeof(d),0);
len:=a[0];d[0]:=1;
fori:=lendownto1dobegin
multiply(d,10,d);
d[1]:=a[i];
while(compare(d,b)>=0)do{即d>=b}
begin
Subtract(d,b,d);
inc(c[i]);
end;
end;
while(len>1)and(c.s[len]=0)dodec(len);
c.len:=len;
end;
算法二
fillchar(s,sizeof(s),0);{小数部分初始化}
fillchar(posi,sizeof(posi),0);{小数值的位序列初始化}
len←0;st←0;{小数部分的指针和
循环节的首指针初始化}
read(x,y);{读
被除数和
除数}
write(xdivy);{输出
整数部分}
x←xmody;{计算x除以y的
余数}
ifx=0thenexit;{若x
除尽y，则成功退出}
whilelenlimitdo{若小数位未达到上限，则循环}
begin
inc(len);posix←len;{记下当前位小数，计算下一位小数和余数}
x←x*10;slen←xdivy;x←xmody;
ifposix0{若下一位余数先前出现过，则先前出现的位置为
循环节的开始}
thenbeginst←posix;break;end;{then}
ifx=0thenbreak;{若除尽，则成功退出}
end;{
while}
iflen=0
thenbeginwriteln;exit;end;{若小数部分的位数为0，则成功退出；否则输出小数点}
write(.);
ifst=0{若无循环节，则输出小数部分，否则输出循环节前的小数和循环节}
thenfori←1tolendowrite(s)
elsebegin
fori←1tost-1dowrite(s);
write();
fori←sttolendowrite(s);
write();
end;{else}
无符号高精度整数
#include<iostream>
#include<vector>
#include<string>
using namespace std;
struct Wint:vector<int>//用标准库vector做基类，完美解决位数问题，同时更易于实现
{
//将低精度转高精度的初始化，可以自动被编译器调用
//因此无需单独写高精度数和低精度数的运算函数，十分方便
Wint(int n=0)//默认初始化为0，但0的保存形式为空
{
push_back(n);
check();
}
Wint& check()//在各类运算中经常用到的进位小函数，不妨内置
{
while(!empty()&&!back())pop_back();//去除最高位可能存在的0
if(empty())return *this;
for(int i=1; i<size(); ++i)
{
(*this)[i]+=(*this)[i-1]/10;
(*this)[i-1]%=10;
}
while(back()>=10)
{
push_back(back()/10);
(*this)[size()-2]%=10;
}
return *this;//为使用方便，将进位后的自身返回引用
}
};
//输入输出
istream& operator>>(istream &is,Wint &n)
{
string s;
is>>s;
n.clear();
for(int i=s.size()-1; i>=0; --i)n.push_back(s[i]-'0');
return is;
}
ostream& operator<<(ostream &os,const Wint &n)
{
if(n.empty())os<<0;
for(int i=n.size()-1; i>=0; --i)os<<n[i];
return os;
}
//比较，只需要写两个，其他的直接代入即可
//常量引用当参数，避免拷贝更高效
bool operator!=(const Wint &a,const Wint &b)
{
if(a.size()!=b.size())return 1;
for(int i=a.size()-1; i>=0; --i)
if(a[i]!=b[i])return 1;
return 0;
}
bool operator==(const Wint &a,const Wint &b)
{
return !(a!=b);
}
bool operator<(const Wint &a,const Wint &b)
{
if(a.size()!=b.size())return a.size()<b.size();
for(int i=a.size()-1; i>=0; --i)
if(a[i]!=b[i])return a[i]<b[i];
return 0;
}
bool operator>(const Wint &a,const Wint &b)
{
return b<a;
}
bool operator<=(const Wint &a,const Wint &b)
{
return !(a>b);
}
bool operator>=(const Wint &a,const Wint &b)
{
return !(a<b);
}
//加法，先实现+=，这样更简洁高效
Wint& operator+=(Wint &a,const Wint &b)
{
if(a.size()<b.size())a.resize(b.size());
for(int i=0; i!=b.size(); ++i)a[i]+=b[i];
return a.check();
}
Wint operator+(Wint a,const Wint &b)
{
return a+=b;
}
//减法，返回差的绝对值，由于后面有交换，故参数不用引用
Wint& operator-=(Wint &a,Wint b)
{
if(a<b)swap(a,b);
for(int i=0; i!=b.size(); a[i]-=b[i],++i)
if(a[i]<b[i])//需要借位
{
int j=i+1;
while(!a[j])++j;
while(j>i)
{
--a[j];
a[--j]+=10;
}
}
return a.check();
}
Wint operator-(Wint a,const Wint &b)
{
return a-=b;
}
//乘法不能先实现*=，原因自己想
Wint operator*(const Wint &a,const Wint &b)
{
Wint n;
n.assign(a.size()+b.size()-1,0);
for(int i=0; i!=a.size(); ++i)
for(int j=0; j!=b.size(); ++j)
n[i+j]+=a[i]*b[j];
return n.check();
}
Wint& operator*=(Wint &a,const Wint &b)
{
return a=a*b;
}
//除法和取模先实现一个带余除法函数
Wint divmod(Wint &a,const Wint &b)
{
Wint ans;
for(int t=a.size()-b.size(); a>=b; --t)
{
Wint d;
d.assign(t+1,0);
d.back()=1;
Wint c=b*d;
while(a>=c)
{
a-=c;
ans+=d;
}
}
return ans;
}
Wint operator/(Wint a,const Wint &b)
{
return divmod(a,b);
}
Wint& operator/=(Wint &a,const Wint &b)
{
return a=a/b;
}
Wint& operator%=(Wint &a,const Wint &b)
{
divmod(a,b);
return a;
}
Wint operator%(Wint a,const Wint &b)
{
return a%=b;
}
//顺手实现一个快速幂，可以看到和普通快速幂几乎无异
Wint pow(const Wint &n,const Wint &k)
{
if(k.empty())return 1;
if(k==2)return n*n;
if(k.front()%2)return n*pow(n,k-1);
return pow(pow(n,k/2),2);
}
//通过重载运算符，还可以实现++、--、^、!、逻辑运算符等很多运算，十分简单，此处都不写了
int main()//你完全可以像int一般便捷地使用Wint，如下
{
Wint a,b;
//可以把b改成int型，仍能正常使用
cin>>a>>b;
cout<<(a<b)<<endl
<<(a==b)<<endl
<<a+b<<endl
<<a-b<<endl
<<a*b<<endl
<<a/b<<endl
<<a%b<<endl
<<pow(a,b);
}
带符号高精度浮点数
#include<bits/stdc++.h>
using namespace std;
struct Wint:deque<int> {
Wint(int n=0) {
push_back(n);
check();
}
Wint& check() {
while(!empty()&&!back())pop_back();
if(empty())return *this;
for(register unsigned int i=1; i<size(); ++i) {
(*this)[i]+=(*this)[i-1]/10;
(*this)[i-1]%=10;
}
while(back()>=10) {
push_back(back()/10);
(*this)[size()-2]%=10;
}
return *this;
}
};
ostream& operator<<(ostream &os,const Wint &n) {
if(n.empty())os<<0;
for(int i=n.size()-1; i>=0; --i)os<<n[i];
return os;
}
bool operator!=(const Wint &a,const Wint &b) {
if(a.size()!=b.size())return 1;
for(int i=a.size()-1; i>=0; --i)
if(a[i]!=b[i])return 1;
return 0;
}
bool operator==(const Wint &a,const Wint &b) {
return !(a!=b);
}
bool operator<(const Wint &a,const Wint &b) {
if(a.size()!=b.size())return a.size()<b.size();
for(int i=a.size()-1; i>=0; --i)
if(a[i]!=b[i])return a[i]<b[i];
return 0;
}
bool operator>(const Wint &a,const Wint &b) {
return b<a;
}
bool operator<=(const Wint &a,const Wint &b) {
return !(a>b);
}
bool operator>=(const Wint &a,const Wint &b) {
return !(a<b);
}
Wint& operator+=(Wint &a,const Wint &b) {
if(a.size()<b.size())a.resize(b.size());
for(register unsigned int i=0; i!=b.size(); ++i)a[i]+=b[i];
return a.check();
}
Wint operator+(Wint a,const Wint &b) {
return a+=b;
}
Wint& operator-=(Wint &a,Wint b) {
if(a<b)swap(a,b);
for(register unsigned int i=0; i!=b.size(); a[i]-=b[i],++i)
if(a[i]<b[i]) {
register unsigned int j=i+1;
while(!a[j])++j;
while(j>i) {
--a[j];
a[--j]+=10;
}
}
return a.check();
}
Wint operator-(Wint a,const Wint &b) {
return a-=b;
}
Wint operator*(const Wint &a,const Wint &b) {
Wint n;
n.assign(a.size()+b.size()-1,0);
for(register unsigned int i=0; i!=a.size(); ++i)
for(register unsigned int j=0; j!=b.size(); ++j)
n[i+j]+=a[i]*b[j];
return n.check();
}
Wint& operator*=(Wint &a,const Wint &b) {
return a=a*b;
}
Wint divmod(Wint &a,const Wint &b) {
Wint ans;
for(int t=a.size()-b.size(); a>=b; --t) {
Wint d;
d.assign(t+1,0);
d.back()=1;
Wint c=b*d;
while(a>=c) {
a-=c;
ans+=d;
}
}
return ans;
}
Wint operator/(Wint a,const Wint &b) {
return divmod(a,b);
}
Wint& operator/=(Wint &a,const Wint &b) {
return a=a/b;
}
Wint& operator%=(Wint &a,const Wint &b) {
divmod(a,b);
return a;
}
Wint operator%(Wint a,const Wint &b) {
return a%=b;
}
Wint pow(const Wint &n,const Wint &k) {
if(k.empty())return 1;
if(k==2)return n*n;
if(k.front()%2)return n*pow(n,k-1);
return pow(pow(n,k/2),2);
}
//=======以下采用上一个高精度无符号整数的模板，编写的带符号浮点数高精度模板========//
constexpr int AC=5;//输出小数点后位数
constexpr int DisplayA=-AC,CalA=floor(sqrt(AC)+0.1)*AC;//为了方便后续表示的常量，前一个是显示的最小指数；后一个是计算精确度，理论上越高越准确，速度越慢
struct Wfloat {
int s,e;//s符号，e指数
Wint f;//f有效数字
Wfloat& check() {//内置进位、去0、精度检查函数
f.check();
while(!f.empty()&&!f.front()) {
f.pop_front();
++e;
}
if(f.empty()) {
s=0;
f.push_back(0);
e=0;
}
if(e<-(CalA+1)) {
e+=CalA+1;
f/=pow((Wint)10,-e);
e=-(CalA+1);
}
return *this;
}
Wfloat(double n=0) {//初始化函数，避免未定义
s=e=0;
check();
}
Wfloat& operator=(const string &x) {//内置赋值函数，使用string字符串进行赋值，支持正负号和小数点，例如：Wfloat a;string s="-1.234";a=s;
register int n=0;
e=0;
s=1;
f.clear();
if(x=="0") {
s=0;
f.push_back(0);
return *this;
}
for(register unsigned int i=x.size()-1; i>0; --i) {
if(x[i]!='.')f.push_back(x[i]-'0');
else n=i;
}
switch(x[0]) {
case '-':
s=-1;
break;
case '+':
s=1;
break;
default:
f.push_back(x[0]-'0');
}
e=n?(n-f.size()-1):0;
return (*this).check();
}
};
//大小比较，不等于和小于直接写，其他的套壳
bool operator!=(const Wfloat &a,const Wfloat &b) {
if(a.s!=b.s)return true;
if(a.e!=b.e)return true;
if(a.f!=b.f)return true;
return false;
}
bool operator==(const Wfloat &a,const Wfloat &b) {
return !(a!=b);
}
bool operator<(const Wfloat &a,const Wfloat &b) {
if(a.s!=b.s)return a.s<b.s;
if(a.e==b.e)return a.f<b.f;
Wint tmp;
if(a.e>b.e) {
tmp=a.f;
for(register int i=0; i<a.e-b.e; ++i)tmp.push_front(0);
return tmp<b.f;
} else {
tmp=b.f;
for(register int i=0; i<b.e-a.e; ++i)tmp.push_front(0);
return a.f<tmp;
}
}
bool operator>(const Wfloat &a,const Wfloat &b) {
return b<a;
}
bool operator<=(const Wfloat &a,const Wfloat &b) {
return !(a>b);
}
bool operator>=(const Wfloat &a,const Wfloat &b) {
return !(a<b);
}
Wfloat abs(Wfloat n) {//绝对值函数
n.s=1;
return n;
}
ostream& operator<<(ostream &os,const Wfloat &n) {//输出函数
if(n.s==0||n.f==0) {
os<<0;
return os;
}
if(n.s==-1)os<<'-';
Wint t,s;
if(n.e<0) {
Wint x;
x.push_back(1);
for(register int i=0; i<-n.e; ++i)x.push_front(0);
register unsigned int flag=0;
if(x<n.f) {
t=n.f/x;
s=n.f-t*x;
} else {
t=0;
s=n.f;
flag=x.size()-n.f.size();
}
if(n.e<DisplayA) {
while(s.size()>(unsigned)AC+1)s.pop_front();
if(s.front()>4)++(*(s.begin()+1));
s.pop_front();
x.clear();
x.push_back(1);
for(register int i=0; i<AC; ++i)x.push_front(0);
s.check();
while(s>=x) {
s-=x;
t+=1;
}
}
for(register unsigned int i=1; i<flag; ++i)s.push_back(0);
while(!s.empty()&&!s.front())s.pop_front();
os<<t;
if(!s.empty())os<<'.'<<s;
} else if(n.e==0) {
os<<n.f;
} else {
t=n.f*pow((Wint)10,n.e);
os<<t;
}
return os;
}
//+-*/
Wfloat& operator+=(Wfloat &a,const Wfloat &b) {
if(a.s==0)
a=b;
else if(b.s==0)
return a;
else if(a.s==b.s)
if(a.e==b.e)
a.f+=b.f;
else if(a.e<b.e)
a.f+=b.f*pow((Wint)10,b.e-a.e);
else {
a.f=a.f*pow((Wint)10,a.e-b.e)+b.f;
a.e=b.e;
}
else {
a.s=(abs(a)>abs(b))?a.s:b.s;
if(a.e==b.e)
a.f-=b.f;
else {
Wint tmp;
if(a.e<b.e) {
tmp=b.f;
for(register int i=0; i<b.e-a.e; ++i)tmp.push_front(0);
a.f-=tmp;
} else {
tmp=a.f;
for(register int i=0; i<a.e-b.e; ++i)tmp.push_front(0);
a.f=tmp-b.f;
a.e=b.e;
}
}
}
return a.check();
}
Wfloat operator+(Wfloat a,const Wfloat &b) {
return a+=b;
}
Wfloat& operator-=(Wfloat &a,Wfloat b) {
b.s=-b.s;
return a+=b;
}
Wfloat operator-(const Wfloat &a,Wfloat b) {
b.s=-b.s;
return a+b;
}
Wfloat& operator*=(Wfloat &a,const Wfloat &b) {
a.s=a.s*b.s;
a.e+=b.e;
a.f*=b.f;
return a.check();
}
Wfloat operator*(Wfloat a,const Wfloat &b) {
return a*=b;
}
Wfloat& operator/=(Wfloat &a,const Wfloat &b) {
a.s=a.s*b.s;
a.e-=CalA;
for(register unsigned int i=0; i<CalA; ++i)a.f.push_front(0);
a.f/=b.f;
return a.check();
}
Wfloat operator/(Wfloat a,const Wfloat &b) {
return a/=b;
}
void f(const Wfloat &a) {//指数表示法函数
cout<<a.s<<' '<<a.f<<'E'<<a.e<<endl;
}
//也可以使用一下的define版，能直接cout<<f(a)输出指数表示法
//#define f(a) (a.s==-1?'-':'\0')<<a.f<<'E'<<a.e
int main() {
//使用样例
Wfloat a,b;
string s;
cin>>s;
a=s;
f(a);
//cout<<f(a)<<endl;
cin>>s;
b=s;
f(b);
//cout<<f(b)<<endl;
cout<<a+b<<' '<<flush;
cout<<a-b<<' '<<flush;
cout<<a*b<<' '<<flush;
cout<<a/b<<' '<<endl;
return 0;
}
传统朴素字符串
//更简单的做法（高精度加法）
#include <iostream>
#include <cstring>
using namespace std;
char a[1001],b[1001];
int x[1001],y[1001],s[1001];
int main()
{
int i,la,lb;
cin>>a>>b;
la=strlen(a);
lb=strlen(b);
for(i=0;i<la;i++)
{
x[i]=a[la-1-i]-48;
}
for(i=0;i<lb;i++)
{
y[i]=b[lb-1-i]-48;
}
int temp;
for(i=0;i<1001;i++)
{
temp=x[i]+y[i]+s[i];
if(temp>=10)
{
s[i+1]++;
s[i]=temp-10;
}
else
{
s[i]=temp;
}
}
for(i=1001;i>=0;i--)
{
if(s[i]!=0)
{
break;
}
}
for(i=i;i>=0;i--)
{
cout<<s[i];
}
cout<<endl;
return 0;
}
//更简单的做法（高精度减法）
#include <iostream>
#include <cstring>
using namespace std;
char a[1001],b[1001];
int x[1001],y[1001],s[1001];
int main()
{
int i,la,lb;
cin>>a>>b;
la=strlen(a);
lb=strlen(b);
for(i=0;i<la;i++)
{
x[i]=a[la-1-i]-48;
}
for(i=0;i<lb;i++)
{
y[i]=b[lb-1-i]-48;
}
int temp;
for(i=0;i<1001;i++)
{
temp=x[i]+y[i]+s[i];
if(temp>=10)
{
s[i+1]++;
s[i]=temp-10;
}
else
{
s[i]=temp;
}
}
for(i=1001;i>=0;i--)
{
if(s[i]!=0)
{
break;
}
}
for(i=i;i>=0;i--)
{
cout<<s[i];
}
cout<<endl;
return 0;
}
//更简单的做法（高精度乘法）
#include <iostream>
#include <cstring>
using namespace std;
char a[1001],b[1001];
int x[1001],y[1001],s[2001];
int main()
{
int i,la,j,lb;
cin>>a>>b;
la=strlen(a);
lb=strlen(b);
for(i=0;i<la;i++)
{
x[i]=a[la-1-i]-48;
}
for(i=0;i<lb;i++)
{
y[i]=b[lb-1-i]-48;
}
for(i=0;i<la;i++)
{
for(j=0;j<lb;j++)
{
s[i+j]=s[i+j]+x[i]*y[j];
}
}
for(i=0;i<2001;i++)
{
s[i+1]=s[i+1]+s[i]/10;
s[i]=s[i]%10;
}
for(i=2000;i>=0;i--)
{
if(s[i]!=0)
{
break;
}
}
for(i=i;i>=0;i--)
{
cout<<s[i];
}
cout<<endl;
return 0;
}
算法一
#include<stdio.h>
#include<string.h>
#define MAXLEN 200
//设置数的最大长度
int main(){
int a[MAXLEN+10],b[MAXLEN+10],len1,len2,c[2*MAXLEN+10],i,j;
char str1[MAXLEN+10],str2[MAXLEN+10];
for(i=0;i<MAXLEN+10;i++)a[i]=b[i]=0;//将a,b两个数组都置为零
for(i=0;i<2*MAXLEN+10;i++)c[i]=0;//将c置为零
//
scanf("%s%s",str1,str2);
gets(str1);
gets(str2);//以字符的形式读入两个乘数
len1=strlen(str1);
len2=strlen(str2);
for(i=len1-1,j=0;i>=0;i--)//将字符型数转换成数字，低位存在数组的低位(倒置)
a[j++]=str1[i]-'0';//字符型减去'0'的ASCIII码值转换为数字
for(i=len2-1,j=0;i>=0;i--)
b[j++]=str2[i]-'0';//同上
for(i=0;i<len2;i++)//循环相乘，用第二个数的每一位去乘以第一个数，a的第i位乘以b的第j位之后存在c的第i+j位上
for(j=0;j<len1;j++)
c[i+j]+=b[i]*a[j];
for(i=0;i<len1+len2+2;i++)//处理进位问题，如果大于10，则进位
if(c[i]>=10){
c[i+1]+=c[i]/10;
c[i]%=10;
}
for(i=len1+len2+2;(c[i]==0)&&(i>=0);i--);//过滤掉高位的数字零，使之不输出
if(i>=0)
for(;i>=0;i--)
printf("%d",c[i]);
else printf("0");
printf("\n");
return 0;
}
算法二
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<malloc.h>
int an,bn,fa=1,fb=1;
/*把an,bn,k设为全局变量,an纪录第一个高精度数组的位数,bn纪录第二个高精度数组的位数,k纪录输出结果的位数*/
char b1[250],b2[250];/*纪录需要计算的两个高精度数据*/
void
input(int a1[],int a2[])
{
/*函数input为输入函数,用来纪录两个待计算的高精度数据,以数组首地址为参数.以实现返回两个高精度数据*/
int i,ai=1,bi=1;
scanf("%s%s",b1,b2);/*输入两个高精度数据*/
an=
strlen(b1);/*an纪录b1的位数*/
bn=strlen(b2);/*bn纪录b2的位数*/
if(b1[0]==45){an--;fa=-1;ai=0;}/*判断数组的符号*/
if(b2[0]==45){bn--;fb=-1;bi=0;}
for(i=0;i<an;i++,ai++){a1[i]=b1[an-ai]-'0';
printf("%d",a1[i]);}
/*把字符形数据b1转为整数形数据,同样用数组纪录*/
for(i=0;i<bn;i++,bi++)a2[i]=b2[bn-bi]-'0';/*同上*/
return;
}
void subtraction(int a[],int b[],int q);
void addition(int a[],int b[],int q)/*高精度加法运算*/
{
int i,c[251]={0},k;
if(fa*fb>0||q)
{
if(an>bn)
k=an;
else
k=bn;/*用k纪录结果的最小位数*/
for(i=0;i<k;i++)
{
c[i]=a[i]+b[i]+c[i];
c[i+1]=(int)c[i]/10;
c[i]=(int)c[i]%10;
}/*
高精度加法运算过程*/
if(c[k])k++;/*判断最后结果的位数*/
if(fa<0&&q||fa<0)
printf("-");
for(i=k-1;i>=0;i--)printf("%d",c[i]);/*输出结果*/
return;
}
else
subtraction(a,b,1);
return;
}
void subtraction(int a[],int b[],int q)/*
高精度减法运算*/
{
int i,f=0,c[251]={0},k;
if(fa*fb>0||q)
{
if(an>bn)
k=an;
else/*用k纪录结果的最大位数*/
{
k=bn;
for(i=k;a[i]<=b[i]&&i>=0;i--)
if(a[i]<b[i])f=1;/*f纪录结果符号*/
}
if(!f)/*高精度减法运算过程*/
for(i=0;i<k;i++)
{
if(a[i]<b[i])
{a[i+1]--;
a[i]+=10;
}
c[i]=a[i]-b[i];
}
else/*当a<b时的处理*/
for(i=0;i<k;i++)
{
if(b[i]<a[i])
{b[i+1]--;
b[i]+=10;
}
c[i]=b[i]-a[i];
}
while(!c[k-1]&&k>1)k--;/*判断最后结果的位数*/
if(q&&(fa>0&&f||fa<0&&!f)||fa>0&&(fb>0&&!f||f&&!q))
printf("-");/*如果f为真是输出负号*/
for(i=k-1;i>=0;i--)printf("%d",c[i]);
return;
}
else
addition(a,b,1);
}
void multiplication(int a[],int b[])/*
高精度乘法运算*/
{
int i,j,c[501]={0},k;
k=an+bn-1;/*用k纪录结果的最大位数*/
for(i=0;i<an;i++)/*高精度乘法运算过程*/
for(j=0;j<bn;j++)
{
c[i+j]=a[i]*b[j]+c[i+j];
c[i+j+1]=c[i+j]/10+c[i+j+1];
c[i+j]=c[i+j]%10;
}
while(!c[k])k--;/*判断最后结果的位数*/
if(fa*fb<0)
printf("-");
for(i=k;i>=0;i--)printf("%d",c[i]);/*输出结果*/
}
int main()
{
int a[250]={0},b[250]={0};
input(a,b);
printf("\n%s+%s=",b1,b2);
addition(a,b,0);
printf("\n%s-%s=",b1,b2);
subtraction(a,b,0);
printf("\n%s*%s=",b1,b2);
multiplication(a,b);
system("pause");
return 0;
}
Python整数基本运算就是高精度计算，不用特殊处理
Java内部写好了高精度运算，只需要使用BigInteger类或者BigDecimal类即可
//高精度A+B
import java.util.Scanner;
import java.math.BigInteger;
public class plus {
private static Scanner in = new Scanner(System.in);
public static void main(String[] args) {
System.out.println(
in.nextBigInteger().add(in.nextBigInteger()) );
}
}
