高精度计算(加减乘)

合集下载

高精度

高精度

• f(3)=2;
{
• f(4)=3;
f3=f1+f2;
• f(5)=5; • f(6)=8;
F(i)=f(i-2)+f(i-1)
f1=f2; f2=f3; }
printf("%ld\n",f3);
• 一、n数求和(problem.c)
• 【问题描述】

有n个数,计算这n个数的和。
• 【输入文件】
• 【问题描述】
• 学习程序我们都要从基础学起,在解决简单的数学问题中学会使用程序,学 会程序的基本的语法和基本的算法。今天我们练习一个简单数学运算——求两 个正整数的和。
• 【输入文件】

文件名:sum.in

文件中有两个正整数,已知这个数字不超过1000000000000000000。
• 【输出文件】
• 加法运算 • 减法运算 • 乘法运算 • 除法运算
高精度除以单精度 ★高精度除以高精度
高精度运算涉及到的主要操作: • 数据的输入和存储
• 数据的运算
加、减、乘、除运算 加法和乘法的进位 减法的借位和符号确定 除法商和余数的处理
• 数据的输出
加法
A+B problem
• 输入两个整数a和b • 计算a+b的值 • 样例输入: 10 20 • 样例输出: 30
1234567891011+17161514 13121110987654321=????
1237 __+____4__7_6____ ____1__6__10__13___
17 1 3
我们该怎么来表示一个几百位数的数呢?
一般变量表示
×
字符串表示

高精度计算

高精度计算

高精度计算由于计算机具有运算速度快,计算精度高的特点,许多过去由人来完成的烦琐、复杂的数学计算,现在都可以由计算机来代替。

计算机计算结果的精度,通常要受到计算机硬件环境的限制。

例如,pascal 要计算的数字超过19位,计算机将按浮点形式输出;另一方面,计算机又有数的表示范围的限制,在一般的微型计算机上,实数的表示范围为l0-38 -l038。

例如,在计算N!时,当N=21时计算结果就超过了这个范围,无法计算了。

这是由计算机的硬件性质决定的,但是,我们可以通过程序设计的方法进行高精度计算(多位数计算)。

学习重点1、掌握高精度加、减、乘、除法。

3、理解高精度除法运算中被除数、除数、商和余数之间的关系。

4、能编写相应的程序,解决生活中高精度问题。

学习过程一、高精度计算的基本方法用free pascal程序进行高精度计算,首先要处理好以下几个基本问题:【数据的输入与保存】(1)一般采用字符串变量存储数据,然后用length函数测量字符串长度确定其位数。

(2)分离各位数位上的数字分离各数位上的数通常采用正向存储的方法。

以“163848192”为例,见下表:A[9] A[8] A[7] A[6] A[5] A[4] A[3] A[2] A[1]1 6 3 8 4 8 1 9 2基本原理是A[1]存放个位上的数字,A[2]存放十位上的数字,……依此类推。

即下标小的元素存低位上的数字,下标大的元素存高位上的数字,这叫“下标与位权一致”原则。

【计算结果位数的确定】(1)高精度加法:和的位数为两个加数中较大数的位数+1。

(2)高精度减法:差的位数为被减数和减数中较大数的位数。

(3)高精度乘法:积的位数为两个相乘的数的位数之和。

(4)高精度除法:商的位数按题目的要求确定。

【计算顺序与结果的输出】高精度加、减、乘法,都是从低位到高位算起,而除法相反。

输出结果都是从高位到低位的顺序,注意:高位上的零不输出(整数部分是零除外)。

高精度加减乘除算法

高精度加减乘除算法

⾼精度加减乘除算法⾼精度运算所谓的⾼精度运算,是指参与运算的数(加数,减数,因⼦……)范围⼤⼤超出了标准数据类型(整型,实型)能表⽰的范围的运算。

例如,求两个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)-48;{将字符转成数值}k1:=k1-1;end;k1:=k1+1;{————以上将s1中的字符⼀位⼀位地转成数值并存在数组a中;低位在后(从第260位开始),⾼位在前(每存完⼀位,k1减1)}对s2的转化过程和上⾯⼀模⼀样。

高精度算法大全

高精度算法大全

高精度算法大全在一般的科学计算中,会经常算到小数点后几百位或者更多,当然也可能是几千亿几百亿的大数字.一般这类数字我们统称为高精度数,高精度算法是用计算机对于超大数据的一种模拟加,减,乘,除,乘方,阶乘,开放等运算.譬如一个很大的数字N >= 10^ 100, 很显然这样的数字无法在计算机中正常存储.于是, 我们想到了办法,将这个数字拆开,拆成一位一位的或者是四位四位的存储到一个数组中, 用一个数组去表示一个数字.这样这个数字就被称谓是高精度数.对于高精度数,也要像平常数一样做加减乘除以及乘方的运算,于是就有了高精度算法:由于计算机输入计算结果的精度通常受到计算机的限制,如:在双精度方式下,计算机最多只能输出16位有效数字,如果超过16位,则只能按浮点形式输出,另外,一般计算机实数表示的范围为1038,如果超过这个范围,计算机就无法表示了。

但是我们可以通过一些简单的办法来解决这个问题。

这就是我们要说的高精度计算机。

一、基本方法:在计算机上进行高精度计算,首先要处理好以下几个基本问题:1、数据的接收与存储;2、计算结果位数的确定;3、进位处理和借位处理;4、商和余数的求法;下面我们逐一介绍一下这几个问题的解决方法。

1、数据的接收与存储:要在计算机上进行高精度计算,首先就应该有精确的输入,即计算机要精确地接收和存储数据。

通常:①、当输入的数值在计算机允许的范围内时,可以用数值型变量来接收数据。

②、当输入的数据超过计算机允许显示的精度范围时,采用字符来接收数据。

③、分离各位数字。

接收数据子模块(字符型变量接收数据):prucedure readdata(var in:array[1..100] of integer);var ch:char;i,k:integer;beginread(ch);k:=0;while ch in['0'..'9'] do begininc(k);int[k]:=ord(ch)-48;read(ch);end;end;2、计算结果位数的确定①、两数之和的位数最大为较大的数的位数加1。

高精度计算(加减乘)

高精度计算(加减乘)

//在c[0]放入,a[0]和b[0]的最大值,和的最少位数 if(a[0]>b[0])
c[0]=a[0]; else
c[0]=b[0]; //按位加法 for(int i=1;i<=c[0];i++){
c[i]=(a[i]+b[i]+jw)%10; jw=(a[i]+b[i]+jw)/10; } if(jw>0){ c[0]++; c[c[0]]=jw; } //输出答案 for(int i=c[0];i>=1;i--) { cout<<c[i]; } return 0; }
if(c[i]>0)break; else c[0]--; } if(c[0]==0) c[0]=1; //答案为0 //输出答案 for(int i=c[0];i>=1;i--) cout<<c[i]; return 0; }
3 高精度乘以低精度
a[3] a[2]/b[2] a[1]/b[1]
a[i]
2 大整数减法
#include<iostream> #include<string> using namespace std; string s1,s2,t; int a[100],b[100],c[100]; bool flag; int main(){
cin>>s1;cin>>s2; //预处理 if(s2.size()>s1.size())flag=true; if(s2.size()==s1.size() &&s2>s1)flag=true; if(flag==true){

c++的正整数高精度加减乘除

c++的正整数高精度加减乘除

c++的正整数⾼精度加减乘除数值计算之⾼精度加减乘除⼀.⾼精度正整数的⾼精度计算1.加法2.减法减法和加法的最⼤区别在于:减法是从⾼位开始相减,⽽加法是从低位开始相加3.乘法:⽤⾼精度加法实现l 乘法的主要思想是把乘法转化为加法进⾏运算。

请先看下⾯的等式:12345*4=12345+12345+12345+1234512345*20=123450*212345*24=12345*20+12345*4l 等式(1)说明,多位数乘⼀位数,可以直接使⽤加法完成。

l 等式(2)说明,多位数乘形如d*10n的数,可以转换成多位数乘⼀位数来处理。

l 等式(3)说明,多位数乘多位数,可以转换为若⼲个“多位数乘形如d*10n的数与多位数乘⼀位数”之和。

l 因此,多位数乘多位数最终可以全部⽤加法来实现。

4.除法:⽤⾼精度减法实现⼆.注意清零和对位操作三. 代码1//2// main.cpp3// 正整数⾼精度运算4//5// Created by ashley on 14-11-9.6// Copyright (c) 2014年 ashley. All rights reserved.7//89 #include <iostream>10 #include <string>11using namespace std;1213string clearZeros(string data)14 {15if (data[0] == '0') {16int key = (int) data.length() - 1;17for (int i = 0; i < data.length(); i++) {18if (data[i] != '0') {19 key = i;20break;21 }22 }23 data.erase(0, key);24 }25if (data == "") {26 data = "0";27 }28return data;29 }3031//对位操作32void countPoint(string &operand1, string &operand2)33 {34while (operand1.length() < operand2.length()) {35 operand1 = "0" + operand1;36 }37while (operand1.length() > operand2.length()) {38 operand2 = "0" + operand2;39 }40 }4142//判断⼤⼩43bool bigger(string operand1, string operand2)44 {45return operand1 >= operand2;46 }4748string addition(string addent, string adder)49 {50//先对位,在加数和被加数前⾯适当补0,使他们包含相同的位数51 countPoint(addent, adder);52//前⾯再补⼀个0,确定和的最多位数53 addent = "0" + addent;54 adder = "0" + adder;55//从低位开始,对应位相加,结果写进被加数中,如果有进位,直接给被加数前⼀位加1 56for (int i = (int) addent.length() - 1; i > 0; i--) {57 addent[i] = addent[i] + adder[i] - 48;58if (addent[i] > '9') {59 addent[i] = addent[i] - 10;60 addent[i - 1] = addent[i - 1] + 1;61 }62 }63return clearZeros(addent);64 }6566string subtraction(string subtrahend, string subtractor)67 {68//先对位,在减数和被减数前⾯适当补0,使他们包含相同的位数69 countPoint(subtrahend, subtractor);70//判断被减数和减数谁⼤,保证被减数⼤于减数71if (bigger(subtrahend, subtractor)) {72 subtrahend[0] = subtrahend[0] - subtractor[0] + 48;73for (int i = 1; i < (int)subtrahend.length(); i++) {74if (subtrahend[i] >= subtractor[i]) {75 subtrahend[i] = subtrahend[i] - subtractor[i] + 48;76 } else {77 subtrahend[i] = subtrahend[i] - subtractor[i] + 10 + 48;78 subtrahend[i - 1]--;79 }80 }81 } else {82 subtrahend = '-' + subtraction(subtractor, subtrahend);83 }84return subtrahend;85 }8687string multiplication(string multiplicand, string multiplier)88 {89string result = "0";90for (int i = (int)multiplier.length() - 1; i >= 0 ; i--) {91for (char c = '1'; c <= multiplier[i]; c++) {92 result = addition(result, multiplicand);93 }94 multiplicand = multiplicand + "0";95 }96return clearZeros(result);97 }9899// 试商法100string division(string dividend, string divisor)101 {102// 存放商103string result;104// 存放余数105string remains;106for (int i = 0; i < (int)dividend.length(); i++) {107 remains = remains + dividend[i];108 result = result + "0";109// 从1往上试110while (bigger(remains, result)) {111 cout << result << "-----------" << remains << endl;112 result[result.length() - 1]++;113 remains = subtraction(remains, divisor);114 }115 }116return clearZeros(result);117 }118int main(int argc, const char * argv[])119 {120string a, b;121int tests;122 cin >> tests;123while (tests--) {124 cin >> a >> b;125//正整数⾼精度加法,从低位开始126//cout << addition(a, b) << endl;127//正整数⾼精度减法,从⾼位开始128//cout << subtraction(a, b) << endl;129//正整数⾼精度乘法,将乘法转换为加法进⾏运算130//cout << multiplication(a, b) << endl;131 cout << division(a, b) << endl;132//正整数⾼精度除法133134 }135return0;136 }。

高精度加减乘除 浮点型

高精度加减乘除 浮点型

高精度加减乘除浮点型
高精度加减乘除是指针对浮点数进行精确计算,避免由于浮点
数运算的精度问题而导致的计算结果不准确的情况。

在进行高精度
加减乘除浮点型计算时,需要考虑以下几个方面:
1. 精度损失,浮点数在计算机中以二进制形式表示,有时会出
现精度损失,导致计算结果不准确。

为避免这种情况,可以使用高
精度计算库,如Python中的decimal模块或者其他高精度计算库,
来进行精确计算。

2. 舍入误差,在浮点数计算过程中,舍入误差是不可避免的,
特别是在连续的加减乘除运算中。

为了减小舍入误差,可以采用四
舍五入、向上取整或向下取整等方法来处理计算结果。

3. 数值范围,浮点数的表示范围是有限的,超出范围的计算会
导致溢出或下溢。

在进行高精度计算时,需要注意数值范围的限制,避免出现计算结果超出浮点数表示范围的情况。

4. 性能考虑,高精度计算通常会牺牲一定的计算性能,因为需
要进行更复杂的运算和更多的内存存储。

在实际应用中,需要权衡
计算精度和性能之间的关系,选择合适的计算方法。

总之,高精度加减乘除浮点型计算需要综合考虑精度损失、舍入误差、数值范围和性能等多个方面的因素,以确保计算结果的准确性和可靠性。

在实际应用中,需要根据具体的计算需求选择合适的高精度计算方法和工具。

高精度计算(二)

高精度计算(二)

高精度计算(二)【例3】高精度乘法。

从键盘读入两个正整数,求它们的积。

分析:(1)、乘法运算a←a*c(a为高精度类型,c为字节型)按照乘法规则,从a的第l位开始逐位与c相乘。

在第i位乘法运算中(1≤i≤la),a的i位与c的乘积必须加上i-1位的进位(i-1位的乘积除以10的整商),然后规整积的i-l位(取i-1位的乘积对10的余数)。

procedure multiply(var a:numtype; c:byte);vari:byte;begina[1] ←a[l]*c;{第1位初始化}for i←2 to la do {逐位相乘}begina[i] ←a[i]*c;a[i] ←a[i]+a[i-l] div 10;a[i-1] ←a[i-l] mod 10end:{for}while a[1a]>=10 do {积的最高位进位}beginla←la+1;a[la] ←a[la-1] div 10;a[la-1] ←a[la-1]mod 10;end; {while}end;{multiply}(2)、乘法运算c←a*b(a,b为高精度类型,)类似加法,可以用竖式求乘法。

在做乘法运算时,同样也有进位,同时对每一位进乘法运算时,必须进行错位相加,如图3, 图4。

分析C 数组下标的变化规律,可以写出如下关系式:C i= C 'i +C ''i +…由此可见,C i跟A[i]*B[j]乘积有关,跟上次的进位有关,还跟原C i的值有关,分析下标规律,有x:= A[i]*B[j]+ x DIV 10+ C[i+j-1];C[i+j-1] := x mod 10;类似,高精度乘法的参考程序:program exam3;constmax=200;vara,b,c:array[1..max] of 0..9;n1,n2:string;lena,lenb,lenc,i,j,x:integer;beginwrite(’Input multiplier:’); readln(n1);write(’Input multiplicand:’); readln(n2);lena:=length(n1); lenb:=length(n2);for i:=1 to lena do a[lena-i+1]:=ord(n1[i])-ord(’0’);for i:=1 to lenb do b[lenb-i+1]:=ord(n2[i])-ord(’0’);for i:=1 to lena do beginx:=0;for j:=1 to lenb do begin {对乘数的每一位进行处理}x := a[i]*b[j] + x div 10 + c[i+j-1]; {当前乘积+上次乘积进位+原数}c[i+j-1] := x mod 10;end;c[i+j]:= x div 10; {进位}end;lenc:=i+j;while (c[lenc]=0) and (lenc>1) do dec(lenc);for i:=lenc downto 1 do write(c[i]);writelnend.【例4】高精度除法。

bigdecimal加减乘除计算

bigdecimal加减乘除计算

bigdecimal加减乘除计算BigDecimal是Java中的一个类,用于进行高精度的数值计算。

在实际应用中,我们经常需要进行浮点数的加减乘除运算,而使用BigDecimal可以避免浮点数运算中的精度丢失问题。

下面我们将分别介绍BigDecimal的加减乘除运算。

一、加法运算BigDecimal的加法运算使用add方法,接受一个BigDecimal类型的参数,返回一个新的BigDecimal对象,表示两个数相加的结果。

例如,我们要计算1.23加上2.34的结果,可以使用如下代码:BigDecimal num1 = new BigDecimal("1.23");BigDecimal num2 = new BigDecimal("2.34");BigDecimal sum = num1.add(num2);System.out.println("1.23 + 2.34 = " + sum);二、减法运算BigDecimal的减法运算使用subtract方法,接受一个BigDecimal 类型的参数,返回一个新的BigDecimal对象,表示两个数相减的结果。

例如,我们要计算3.45减去1.23的结果,可以使用如下代码:BigDecimal num1 = new BigDecimal("3.45");BigDecimal num2 = new BigDecimal("1.23");BigDecimal difference = num1.subtract(num2);System.out.println("3.45 - 1.23 = " + difference);三、乘法运算BigDecimal的乘法运算使用multiply方法,接受一个BigDecimal 类型的参数,返回一个新的BigDecimal对象,表示两个数相乘的结果。

高精度运算

高精度运算

由于待处理的数据超过了任何一种数据类型所能容纳的范围,因此必须采用数串形式输入,并将其转化为数组。

该数组的每一个元素对应一个十进制数,由其下标顺序指明位序号。

由于高精度运算可能使得数据长度发生变化,因此除要用整数数组存储数据外,还需要一个整数变量纪录整数数组的元素个数,即数据的实际长度。

typenumtype=array[1..255] of byte;vara:numtype;la:byte;s:string;beginreadln(s);la:=length(s);for i:=1 to la doa[la-i+1]:=ord(s[i])-ord('0');end.高精度加法运算首先,确定a和b中的最大位数x,然后依照由低位至高位的顺序进行加法运算。

在每一次运算中,a当前位加b当前位的和除以10,其整商即为进位,其余数即为和的当前位。

在进行了x 位的加法后,若最高位有进位(a[x+1]<>0),则a的长度为x+1。

以下只列出关键程序:typenumtype=array[1..255] of word;vara,b,s:numtype;la,lb,ls:word;procedure plus(var a:numtype;var la:word;b:numtype;lb:word); {利用过程实现}vari,x:word;beginif la>=lbthen x:=laelse x:=lb;for i:=1 to x dobegina[i]:=a[i]+b[i];a[i+1]:=a[i+1]+a[i] div 10;a[i]:=a[i] mod 10;end;while a[x+1]<>0 dox:=x+1;la:=x; {最高位若有进位,则长度增加}end;高精度减法运算(a>b)依照由低位至高位的顺序进行减法运算。

在每一次位运算中,若出现不够减的情况,则向高位借位。

高精度算法大全

高精度算法大全

高精度算法大全在一般的科学计算中,会经常算到小数点后几百位或者更多,当然也可能是几千亿几百亿的大数字.一般这类数字我们统称为高精度数,高精度算法是用计算机对于超大数据的一种模拟加,减,乘,除,乘方,阶乘,开放等运算.譬如一个很大的数字N >= 10^ 100, 很显然这样的数字无法在计算机中正常存储.于是, 我们想到了办法,将这个数字拆开,拆成一位一位的或者是四位四位的存储到一个数组中, 用一个数组去表示一个数字.这样这个数字就被称谓是高精度数.对于高精度数,也要像平常数一样做加减乘除以及乘方的运算,于是就有了高精度算法:由于计算机输入计算结果的精度通常受到计算机的限制,如:在双精度方式下,计算机最多只能输出16位有效数字,如果超过16位,则只能按浮点形式输出,另外,一般计算机实数表示的范围为1038,如果超过这个范围,计算机就无法表示了。

但是我们可以通过一些简单的办法来解决这个问题。

这就是我们要说的高精度计算机。

一、基本方法:在计算机上进行高精度计算,首先要处理好以下几个基本问题:1、数据的接收与存储;2、计算结果位数的确定;3、进位处理和借位处理;4、商和余数的求法;下面我们逐一介绍一下这几个问题的解决方法。

1、数据的接收与存储:要在计算机上进行高精度计算,首先就应该有精确的输入,即计算机要精确地接收和存储数据。

通常:①、当输入的数值在计算机允许的范围内时,可以用数值型变量来接收数据。

②、当输入的数据超过计算机允许显示的精度范围时,采用字符来接收数据。

③、分离各位数字。

接收数据子模块(字符型变量接收数据):prucedure readdata(var in:array[1..100] of integer);var ch:char;i,k:integer;beginread(ch);k:=0;while ch in['0'..'9'] do begininc(k);int[k]:=ord(ch)-48;read(ch);end;end;2、计算结果位数的确定①、两数之和的位数最大为较大的数的位数加1。

高精度算法(加减)

高精度算法(加减)
}
高精度-加法
(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,则交换两个字符串数据,并输出负号 '-';否则不做其他操作

高精度计算程序算法

高精度计算程序算法
算法 - 思维的体操
高精度计算
Task:
高精度加法 高精度减法 高精度乘法(阶乘) 高精度除法
为什么要用高精度?
在很多的程序中变量的取值范围很有可能 超过long所能表示的范围,甚至是double, 如果超过了这个范围,程序结果就会出错,那 么如何解决这类问题呢?那么我们就需要用 到高精度运算.
【问题】求两个大数的最大公约数和最小公倍数
辗转相除法
用(a,b)来表示a和b的最大公约数. 例:求 15750 与27216的最大公约数. ∵27216=15750×1+11466 ∴(15750,27216)=(15750,11466) ∵15750=11466×1+4284 ∴(15750,11466)=(11466,4284) ∵11466=4284×2+2898 ∴(11466,4284)=(4284,2898) ∵4284=2898×1+1386 ∴(4284,2898)=(2898,1386) ∵2898=1386×2+126 ∴(2898,1386)=(1386,126) ∵1386=126×11 ∴(1386,126)=126 所以(15750,27216)=216
数据的存储方式
我们可以采用字符串读入,然后倒置并转化 成数字存入数组,每一个下标变量存储1个 字符
struct BigNumber{ int len; int v[maxn];
}
gets(string); Len=strlen(string); for(i=0;i<len;i++) {存到数组
}
一次计算2位数,计算次数减少1/2
223+ ຫໍສະໝຸດ 96-----------

高精度算法

高精度算法

高精度算法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的数字.。

高精度加减乘除阶乘计算的算法及代码

高精度加减乘除阶乘计算的算法及代码

高精度计算
主要的方法是利用数组模拟计算比如:
高精度加法
12345678910111213 + 1111111111111111111
开两个数组存储:
a[]={3,1,2,1,1,1,0,1,9,8,7,6,5,4,3,2,1};
b[]={1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
两个数组分别把数值倒存,在一位一位的加,每位加后判断是否大于10,在进位(注:如果太大的数值,可以考虑4位一存哦.) 注意下面的a1,b1,c1 为数组的长度
四位一存:
高精度减法
--SepHiRoTH 18:59 2009年5月17日(CST) 高精度乘法
四位一计算:
更快的算法需要借助FFT(也有人喜欢用NTT) 实现nlogn 高精度除法
只提供程序段,未处理循环小数。

--Taophee 22:24 2011年8月20日
请看到这个问题的OIers注意并及时给出正确解法,最近忙于琐事,拜托了,这个网站很久无人管理了。

--SepHiRoTH 23:02 2011年7月30日(CST)
算法已改。

--Taophee 22:24 2011年8月20日
做一下循环小数,这需要加一段,既然做了就把它做好怎样?--SepHiRoTH 08:20 2011年8月21日(CST)
高精度阶乘
作为一种高精度乘法的扩展算法,实质为高精度乘低精度,算法如下:
--SepHiRoTH 18:59 2009年5月17日(CST)
高精度快速幂
主要用了二分的手段。

中间的乘法就看上面的吧。

--By Clarkok。

C++不知算法系列之高精度数值处理算法

C++不知算法系列之高精度数值处理算法

C++不知算法系列之高精度数值的加、减、乘、除算法1. 前言什么是高精度数值处理算法?高精度数值指因受限于计算机硬件的制约,超过计算机所能存储范围的数值。

既然不能存储,更谈不上运算。

对此类数值的加、减、乘、除运算需要提供针对性的算法方能获取到结果。

此类算法的设计思路因有别于其它算法,为了研究的方便,称此类算法为高精度数值处理算法。

本文将讲解如何实现对此类数值的加、减、乘、除运算。

2. 高精度数值的运算对高精度数值运算时,需要从2个方面入手:•如何存储:其基本存储思想是把数值以字符串的形式输入,然后转储于整型类型的数组中。

理论上,数组的长度是不受限制的,或者采用一部分一部分的处理方式。

•如何计算:基本计算思想是把计算的2个数值以数组形式存储后,以逐位逐位地方式进行计算。

如此,把大问题化解成了小问题。

2.1 高精度的加法高精度数值相加的思路:•用整型数组存储2个加数。

为了遵循数组从头指针向尾指针扫描的使用习惯,存储时,可以把低位存储在前面,高位存储存在后面,至于是否如此存储可以根据实际设计的算法决定。

如下存储374和65。

//加数一int num1[100]={4,7,3,0,0……};//加数二int num2[100]={5,6,0,0……};//相加结果,初始化为 0int result[100]={0};//存储两数相加的进位int jinWei=0;•遍历数组,对2个数组的对应位进行相加。

如num1[0]+num2[0],且把相加结果存储到result[0]位置。

相加时,需要根据加法运算法则,考虑进位和不进位两种情况。

不进位情况:如num1[0]+num2[0]=4+5不需要进位,直接把结果存储到result[0]中。

进位情况:如num1[1]+num2[1]=7+6=13。

有进位操作,则把结果的余数存储在result[1]=3中。

把结果的商(进位值)临时存储在变量jinWei中。

最后,num1[2]+num2[2]+jinWei=3+0+1=4存储在result[2]中。

高精度运算(加减)

高精度运算(加减)

高精度运算(加减)高精度计算(一)一、教学目标●了解什么是高精度计算。

为什么要进行高精度计算。

●熟练掌握基本的加、减高精度计算二、重点难点分析●高精度数的存储方式;三、教具或课件使用多媒体演示文稿四、主要教学过程(一)引入新课利用计算机进行数值计算,有时会遇到这样的问题:有些计算要求精度高,希望计算的数的位数可达几十位甚至几百位,虽然计算机的计算精度也算较高了,但因受到硬件的限制,往往达不到实际问题所要求的精度.我们可以利用程序设计的方法去实现这们的高精度计算.这里仅介绍常用的几种高精度计算的方法。

(二)教学过程设计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. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

高精度乘高精度
× 4 1 7 2 1 8 5 2 2 8 1 2 4 0 6 5 0 0
C[5] C[4] C[3] C[2]
856 × 25 856 × 25 856 × 25 a×b[1] 856 × 25 856 × 25 856 × 25 a×b[2]
C[1] 0+0+6× 5 0 0 0 0 0 0
A3 A2 × B2 C'4 C'3 C'2 C"4 C"3 C"2 C4 C3 C2
A1 B1 C'1 C1

我们在计算高精度乘法结果时,通常先计算C'i,再加上C"i,再加上C'"i,…… Ci跟a[i]*b[j]乘积有关,跟上次的进位有关,还跟原Ci的值有关,分析下标规 律,有:
c[i+j-1]=a[i]*b[j]+x+c[i+j-1]; x=c[i+j-1]/10; c[i+j-1]%=10;
//b逐位乘数组a for (int i=1;i<=b[0];i++) { for (int j=1;j<=a[0];j++)//a逐位乘以b[i] { c[i+j-1பைடு நூலகம்=c[i+j-1]+jw+b[i]*a[j]; //数组c对应位加上进位及a、b对应位乘积 jw=c[i+j-1]/10; //处理进位 c[i+j-1]%=10; } c[i+a[0]]=jw; //a乘以b[i]后的最高位进位 } c[0]=a[0]+b[0]; while (c[0]>1&&c[c[0]]==0) c[0]--; //更新c的位数 for (int i=c[0];i>0;i--) cout<<c[i]; return 0;
else
c[i]=a[i]-b[i]; } //除去多余的0 for(int i=c[0];i>=1;i--){ if(c[i]>0)break; else c[0]--; } if(c[0]==0) c[0]=1; //答案为0 //输出答案 for(int i=c[0];i>=1;i--) cout<<c[i]; return 0; }
3 高精度乘以低精度
a[3] a[2]/b[2] a[1]/b[1]
4 5 2 3 × ———————————— a[i]×b c[3] c[2] c[1] 69 92 115 103 69 5 ———————————————— 79 3 5
a[i] b
3
3 高精度乘以低精度
#include<iostream> #include<cstdio> using namespace std; string s1; int a[100],b,c[100]; int main(){ cin>>s1; cin>>b; a[0]=s1.size(); //把个位放入a[1],把十位放入a[2],把百位放入a[3] for(int i=a[0]-1;i>=0;i--){ int j=a[0]-i; a[j]=s1[i]-’0’; } //被除数位数为最终位数 c[0]=a[0]; //按位计算 for(int i=1;i<=c[0];i++) c[i]=a[i]*b;
几个需要考虑的问题: 1、如何存储大整数?
a10 a9 a8 a7 a6 a5 a4 a3 a2 a1 a0
数组
6 6 8 3 6 2 2 0 1 3
2、如何实现加法? 逐位相加 3、如何处理进位? 向数组的高位进位
+
1 1
4 5 0 9 6 3 8 7 6 7
10 11 1 8 9 12 12 5 10 3 2 6 0 7 7 7 8 10 0
2 大整数减法
#include<iostream> #include<string> using namespace std; string s1,s2,t; int a[100],b[100],c[100]; bool flag; int main(){ cin>>s1;cin>>s2; //预处理 if(s2.size()>s1.size())flag=true; if(s2.size()==s1.size() &&s2>s1)flag=true; if(flag==true){ cout<<‘-’; t=s1; s1=s2; s2=t; }
高精度计算
C/C++中的int类型能表示的范围一般是-231-231 – 1。 unsigned 类型能表示的范围是 0 -232 – 1,即 0 - 4294967295。所以,int和unsigned类型变量,都不能保存 超过10位的整数。
如果有一个长度为100位的大整数,我们如何存储?
我们如何进行大整数的运算?比如如何计算两个100位整 数的和?

类似加法,可以用竖式求乘法。在做乘法运算时,同样也有进位,同时对每 一位进行乘法运算时,必须进行错位相加
× 4 1 7 2 1

8 5 2 2 8 1 2 4 0
6 5 0 0 C6 C"5 C5
分析c数组下标的变化规律,可以写出如下关系式:
Ci = C'i + C"i + ……,其中: C'i由A1*B1、A2*B1、A3*B1、…… 组成 C"i由A1*B2、A2*B2、A3*B2、…… 组成 ……
参考程序: #include<iostream> #include<string> using namespace std; string s1,s2; int a[100],b[100],c[100],jw; int main(){ cin>>s1; cin>>s2; //把s1的长度,放入到a[0]; a[0]=s1.size(); //把个位放入a[1],把十位放入a[2],把百位放入a[3] for(int i=a[0]-1;i>=0;i--){ int j=a[0]-i; a[j]=s1[i]-’0’; } //把s2的长度,放入到b[0]; b[0]=s2.size(); //把个位放入b[1],把十位放入b[2],把百位放入b[3] for(int i=b[0]-1;i>=0;i--){ int j=b[0]-i; b[j]=s2[i]-’0’; }
1 大整数加法
问题描述 求两个不超过100位的非负整数的和。
输入数据 有两行,每行是一个不超过100位的非负整数,没有多余的前导0。
输出要求 一行,即相加后的结果。结果里不能有多余的前导0,即如果结果 是342,那么就不能输出为0342。
输入样例 22222222222222222222 33333333333333333333 输出样例 Output Sample: 55555555555555555555
//处理进位 ,最高位不处理 for(int i=1;i<c[0];i++) if(c[i]>=10) { c[i+1]+=c[i]/10; c[i]=c[i]%10; } //输出 for(int i=c[0];i>=1;i--) { cout<<c[i]; } return 0; }
4、高精度乘高精度
//在c[0]放入,a[0]和b[0]的最大值,和的最少位数 if(a[0]>b[0]) c[0]=a[0]; else c[0]=b[0]; //按位加法 for(int i=1;i<=c[0];i++){ c[i]=(a[i]+b[i]+jw)%10; jw=(a[i]+b[i]+jw)/10; } if(jw>0){ c[0]++; c[c[0]]=jw; } //输出答案 for(int i=c[0];i>=1;i--) { cout<<c[i]; } return 0; }
}
0+3+5× 5 0+2+8× 5 2 2 2+2+5× 2 4 8 8 8+0+6× 2 0 0
4 4 4 4+1+8× 2 1
2
4
0
0
a[i]×b[j]对应于c[i+j-1]
#include<iostream> #include<cstdio> #include<string> using namespace std; string s1,s2; int a[100],b[100],c[100],jw; int main(){ cin>>s1>>s2; //a[0]里存入长度,每一位倒序存入a[i] a[0]=s1.size(); for(int i=a[0]-1;i>=0;i--){ int j=a[0]-i; a[j]=s1[i]-'0'; } b[0]=s2.size(); for(int i=b[0]-1;i>=0;i--){ int j=b[0]-i; b[j]=s2[i]-'0'; }
//逆序存入数组 a[0]=s1.size(); for(int i=a[0]-1;i>=0;i--){ int j=a[0]-I; a[j]=s1[i]-’0’; } b[0]=s2.size(); for(int i=b[0]-1;i>=0;i--){ int j=b[0]-I; b[j]=s2[i]-’0’; } //按位减法 c[0]=a[0]; for(int i=1;i<=c[0];i++){ if(a[i]-b[i]<0){ //借位 a[i+1]- -; c[i]=10+a[i]-b[i]; }
相关文档
最新文档