精华内容
下载资源
问答
  • 对于超大数字的运算,用long long int仍然不能解决,这时候就需要考虑通过模拟运算和数组存储来实现高精度运算。 本文讨论借助C++的string来实现高精度的运算。 首先输入的量直接存储为string,设为s1和s2。 接下来...
  • C语言-高精度加法

    2014-11-13 09:41:18
    C语言-高精度加法,C语言程序设计实验之高精度加法
  • 高精度加法

    2014-07-01 18:53:04
    还在为longlong型都无法计算的超长数字做加法而发愁吗?只要一个高精度加法就搞定啦!
  • 文章目录系列文章目录前言一、高精度加法分析1.1 数学的竖式加法计算1.2 数组模拟竖式计算1.3 计算步骤分析二、使用步骤2.1 代码结构2.2 读入数据并倒置:readDataAndReverse(int *arr,int &len)函数2.3 两个...


    前言

    利用计算机进行数值计算,有时会遇到这样的问题:有些计算要求精度高,希望计算的数的位数可达几十位甚至几百位,虽然计算机的计算精度也算较高了,但因受到硬件的限制,往往达不到实际问题所要求的精度。我们可以利用程序设计的方法去实现这样的高精度计算。计算结果超过常用的数据类型长度即可使用高精度计算。

    int范围:[-231,231-1],大约是109数量级。long long范围[-263,263-1],大约是1018数量级。超过这个量级,我们就可以选择高精度计算了。


    一、高精度加法分析

    1.1 数学的竖式加法计算

    在进行高精度加法之前,我们来回顾一下小学时我们是如何进行加法计算的。我们以一个较小的数作为例子:计算12342+432的值。请添加图片描述
    我们很容易就能写出上面这个式子,计算的时候一会习惯性的从箭头位置从右往左进行计算得到结果。但是写到程序中还是这样吗?

    1.2 数组模拟竖式计算

    前面讲了,因为数据已经超过了常用的数据类型,存入过大的数据的时候是有问题的,所以我们在存储输入的数据的时候都是使用数组来完成,现在我们来看一下数组接受数据会发生什么情况。
    请添加图片描述
    这里增加了下标,我们会发现一个问题,这时候想要计算,他们的下标不是对齐的,我们不能直接直接把0号下标的两个数直接相加。我们希望他们是尾部对齐的效果。那么解决这个问题我们可以先把这两个数组进行逆序(reverse)操作,算完之后再把结果倒序输出即可。顺便加上对应的数组。下图为逆序后做的计算。

    请添加图片描述

    1.3 计算步骤分析

    根据上图,我们分析一下代码步骤。

    1. 创建已知和未知的变量
    2. 程序读取a数组和b数组,并将数组倒置(reverse)
    3. 使用从左往右进行累加计算,并将结果存储到ans数组中。公式:ans[i]=a[i]+b[i];
    4. 将结果逆序输出

    二、使用步骤

    2.1 代码结构

    计算的位数我们设定为小于500位。在写代码的时候我们可以先把我们要做的流程利用函数的形式来表示,具体的实现,等我们想清楚之后再写,这样子写的时候思路更清晰,而且做什么事也不会写乱了。
    代码如下(示例):

    #include <iostream>
    #include <string>
    using namespace std;
    // 1. 创建变量(包括三个数组、数组的大小N、三个数组的长度,t表示进位)
    const int N = 520;
    int a[N],b[N],ans[N],len_a,len_b,len_ans,t;
    void readDataAndReverse(int *arr,int &len);
    void addData(int *a,int *b,int &len_ans);
    void reversePrint(int *ans);
    int main(){
    	// 2. 读入数据并倒置
    	readDataAndReverse(a,len_a);
    	readDataAndReverse(b,len_b);
    	// 3. 数组做累加
    	addData(a,b,len_ans);
    	// 4. 逆序输出
    	reversePrint(ans);
    	return 0;
    }
    void readDataAndReverse(int *arr,int &len){
    	
    }
    void addData(int *a,int *b,int &len_ans){
    	
    }
    void reversePrint(int *ans){
    	
    }
    

    2.2 读入数据并倒置:readDataAndReverse(int *arr,int &len)函数

    代码如下(示例):

    /*
    函数功能:读入数据,并逆序存入数组
    参数:
    	arr:要存入数据的数组
    	len:对应数组的长度
    返回值:null
    */
    void readDataAndReverse(int *arr,int &len){
    	
    	// 1. 由于数据量比较大,所以我们都是先读入字符串,再转存数组
    	string s;
    	cin>>s;
    	len = s.length();		// 字符串的长度,就是对应数组(a,b数组)的长度
    	/*
    		i: 表示arr数组的下标,从1开始到len(不从零开始存,方便记忆)
    		j: 表示s字符数组的下标,从结尾len开始到1
    		s[j]-'0': s[j]得到的是一个字符数字,这个字符数字想要转成真正的数字需要减去0,详见ASCII码表
    	*/
    	for(int i=0,j=len-1;j>=0;i++,j--){
    		arr[i] = s[j]-'0';
    	}
    }
    

    测试:在两个输入的函数下面添加打印数组的代码做测试,是可以的。
    在这里插入图片描述

    2.3 两个数据相加:addData(int *a,int *b,int &len_ans)函数

    这里我们增加一个变量t,t表示进位数值。我们思考这么一个问题,在前面的例子中,我们对两个数字进行累加的时候并没有考虑到a[i]+b[i]>=10的情况,如果不做进位维护的话,会导致结果和预期不一样。通过下图,我们再看一下程序改如何改进:

    请添加图片描述
    根据上面的图片,增加的部分是进位维护程序,并且是在得到ans数组之后进行的。

    /*
    函数功能:对两个数组进行累加
    参数:
    	a:a数组
    	b:b数组
    	len_ans:累加后的数组长度
    返回值:null
    */
    void addData(int *a,int *b,int &len_ans){
    	// 1、得到a和b中最长的数组长度
    	len_ans = len_a;
    	if (len_a<len_b){
    		len_ans = len_b;
    	}
    	// 做累加
    	t=0;	// 进位,默认第一次累加为零
    	for(int i=0;i<=len_ans;i++){
    		ans[i] = a[i]+b[i]+t;
    		t=0;	// 每次累加完之后归零,并不是每次都有进位
    		// 进位维护,如果累加之后结果大于等于10,进位变1,结果%10
    		if(ans[i]>=10){
    			t = 1;
    			ans[i]=ans[i]%10;
    		}
    	}
    	// 累加完了之后判断最后进位t是否等于1,是的话说明还有一位数,我们手动加到数组中
    	if(t==1){
    		len_ans++;
    		ans[len_ans-1]=1;
    	}
    }
    

    在这里插入图片描述
    输入数据做测试,需要自己在addData()后面添加打印程序。没有问题。

    2.4 逆序输出:reversePrint(int *ans)函数

    上一部分我们已经做了输出,发现并没有问题,到这一步,我们只是需要把它倒序输出吗?也就是下面的代码。
    尝试输入:00123 00123
    他会输出246吗?

    void reversePrint(int *ans){
    	for(int i=len_ans-1;i>0;i--){
    		cout<<ans[i];
    	} 
    }
    

    在这里插入图片描述

    2.4.1 去除前导零

    可以看到,并不是我们想要的结果,因为算出来的前面还有两个0,我们称这个为前导零。所以下面我们要做的就是去除前导零
    在这里插入图片描述
    如何去除前导零呢?如上图所示,我们需要一个“指针”,当然这个并不是c++中的那个指针,这里只是表示指向那个位置的一个值,刚好这个值就是len_ans,所以用len_ans当这个“指针”就行。处理步骤按图上的来就行。

    void reversePrint(int *ans){
    	// 最后一个位置是len_ans-1,所以从ans[len_ans-1]开始判断
    	while(ans[len_ans-1]==0&&len_ans>0){
    		len_ans--;
    	}
    	// 逆序输出
    	for(int i=len_ans-1;i>=0;i--){
    		cout<<ans[i];
    	} 
    }
    

    总结

    高精度加法步骤:

    1. 创建对应的数组变量及其他变量
    2. 以字符串形式读入数据并逆序存储到数组中
    3. 将两个数组做累加, 注意进位的维护
    4. 逆序输出(注意删除前导零)

    完整代码

    1.使用函数形式

    #include <iostream>
    #include <string>
    using namespace std;
    // 1. 创建变量(包括三个数组、数组的大小N、三个数组的长度)
    const int N = 520;
    int a[N],b[N],ans[N],len_a,len_b,len_ans,t;
    void readDataAndReverse(int *arr,int &len);
    void addData(int *a,int *b,int &len);
    void reversePrint();
    int main(){
    	// 2. 读入数据并倒置
    	readDataAndReverse(a,len_a);
    	readDataAndReverse(b,len_b);
    	
    	
    	// 3. 数组做累加
    	addData(a,b,len_ans);
    	// 4. 逆序输出
    	reversePrint();
    	return 0;
    }
    void readDataAndReverse(int *arr,int &len){
    	// 1. 由于数据量比较大,所以我们都是先读入字符串,再转存数组
    	string s;
    	cin>>s;
    	len = s.length();		// 字符串的长度,就是对应数组(a,b数组)的长度
    	/*
    		i: 表示arr数组的下标,从1开始到len(不从零开始存,方便记忆)
    		j: 表示s字符数组的下标,从结尾len开始到1
    		s[j]-'0': s[j]得到的是一个字符数字,这个字符数字想要转成真正的数字需要减去0,详见ASCII码表
    	*/
    	for(int i=0,j=len-1;j>=0;i++,j--){
    		arr[i] = s[j]-'0';
    	}
    }
    void addData(int *a,int *b,int &len){
    	// 1、得到a和b中最长的数组长度
    	len_ans = len_a;
    	if (len_a<len_b){
    		len_ans = len_b;
    	}
    	// 做累加
    	t=0;	// 进位,默认第一次累加为零
    	for(int i=0;i<len_ans;i++){
    		ans[i] = a[i]+b[i]+t;
    		t=0;	// 每次累加完之后归零,并不是每次都有进位
    		// 进位维护,如果累加之后结果大于等于10,进位变1,结果%10
    		if(ans[i]>=10){
    			t = 1;
    			ans[i]=ans[i]%10;
    		}
    	}
    	// 累加完了之后判断最后进位t是否等于1,是的话说明还有一位数,我们手动加到数组中
    	if(t==1){
    		len_ans++;
    		ans[len_ans-1]=1;
    	}
    }
    void reversePrint(){
    	// 最后一个位置是len_ans-1,所以从ans[len_ans-1]开始判断
    	while(ans[len_ans-1]==0&&len_ans>0){
    		len_ans--;
    	}
    	// 逆序输出
    	for(int i=len_ans-1;i>=0;i--){
    		cout<<ans[i];
    	} 
    }
    

    2.不使用函数形式

    #include <iostream>
    #include <string>
    using namespace std;
    // 1. 创建变量(包括三个数组、数组的大小N、三个数组的长度)
    const int N = 520;
    int a[N],b[N],ans[N],len_a,len_b,len_ans,t;
    int main(){
    	// 2. 读入数据并倒置
    	string s;
    	cin>>s;
    	len_a = s.length();		
    	for(int i=0,j=len_a-1;j>=0;i++,j--){
    		a[i] = s[j]-'0';
    	}
    	cin>>s;
    	len_b = s.length();		
    	for(int i=0,j=len_b-1;j>=0;i++,j--){
    		b[i] = s[j]-'0';
    	}
    	
    	// 1、得到a和b中最长的数组长度
    	len_ans = len_a;
    	if (len_a<len_b){
    		len_ans = len_b;
    	}
    	// 做累加
    	t=0;	// 进位,默认第一次累加为零
    	for(int i=0;i<len_ans;i++){
    		ans[i] = a[i]+b[i]+t;
    		t=0;	// 每次累加完之后归零,并不是每次都有进位
    		// 进位维护,如果累加之后结果大于等于10,进位变1,结果%10
    		if(ans[i]>=10){
    			t = 1;
    			ans[i]=ans[i]%10;
    		}
    	}
    	// 累加完了之后判断最后进位t是否等于1,是的话说明还有一位数,我们手动加到数组中
    	if(t==1){
    		len_ans++;
    		ans[len_ans-1]=1;
    	}
    	
    	// 最后一个位置是len_ans-1,所以从len_ans-1开始判断
    	while(ans[len_ans-1]==0&&len_ans>0){
    		len_ans--;
    	}
    	// 逆序输出
    	for(int i=len_ans-1;i>=0;i--){
    		cout<<ans[i];
    	} 
    	
    	return 0;
    }
    

    优化

    程序代码还可以在进行优化,例如数组倒置,或者是求取len_a和len_b中的最大值,都可以使用algorithm头文件进行处理,这里就自行查阅数据学习了。

    初次学习,写的不足或者看不懂的地方请留言。

    展开全文
  • C语言实现高精度加法

    2021-05-21 13:47:04
    免费资源网 - https://freexyz.cn/本篇为高精度加法的计算,接下来我还会去写高精度乘法的计算。一、高精度运算的概念高精度运算其实就是参与运算的数完全超出基本数据类型所能表示的范围的运算(例如int型范围就是 -...

    免费资源网 - https://freexyz.cn/

    本篇为高精度加法的计算,接下来我还会去写高精度乘法的计算。

    一、高精度运算的概念

    高精度运算其实就是参与运算的数完全超出基本数据类型所能表示的范围的运算(例如int型范围就是 - 2147483648 ~+ 2147483647)

    所以如果想求较大数的话就要创建新的数据类型

    二、数据类型的选取

    我选择的是int型数组,这样比较便于计算和理解

    三、代码

    其中a和b我是通过随机数来赋值

    //author summer_awn

    //date 2017/6/20

    #include

    #include

    #define lenth_a 200

    #define lenth_b 200

    using namespace std;

    //计算a+b

    void 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) {//输出a

    cout << 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) {//输出b

    cout << b[i];

    }

    cout << endl;

    cout << endl;

    int lenth_result;//结果的长度en

    if (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);

    }

    四、结果

    结果有截图,未验证(因为懒)

    dcc192c5ef7af613b1378dd70ba22a93.png

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持。

    免费资源网 - https://freexyz.cn/

    展开全文
  • 高精度加法演示

    2018-01-13 20:11:00
    高精度加法的相关代码,来自课堂内容,仅作参考
  • c++实现高精度加法

    2020-12-31 07:22:16
    最近遇到一个c++实现高精度加法的问题,高精度问题往往十复杂但发现其中的规律后发现并没有那么复杂,这里我实现了一个整数的高精度加法,主要需要注意以下几点: 1:将所需输入的数据以字符数组的形式输入,建立...
  • C++的高精度加法

    千次阅读 多人点赞 2020-02-21 12:06:48
    为什么需要高精度计算 对于 C++ 而言,最大的数据为 long long(64b,8位),对于超过 8B 的数据,C++ 没有对应的数据类型进行表示。...高精度加法计算原理 在读小学时,我们做加法都采用竖式方法,如图 1 ...

    为什么需要高精度计算

    对于 C++ 而言,最大的数据为 long long64b8位),对于超过 8B 的数据,C++ 没有对应的数据类型进行表示。所以我们需要知道高精度计算。更详细的解释,可以参考这个网页https://blog.csdn.net/justidle/article/details/104414459

    高精度加法计算原理

    在读小学时,我们做加法都采用竖式方法,如图 1 所示。 这样,我们方便写出两个整数相加的算法。

    我们就可以用 C++ 语言来模拟这个竖式加法的过程。我们可以考虑利用 C++ 的数组来存储对应数据,假设用数组 A 存储 856 的每一位,具体来说就是 A1 存储个位 6,A2 存储十位 5,A3存储百位 8;类似数组 A 的结构,使用数组 B 存储 255;类似数组 A 的结构,使用数组 C 来存储对应的和 1111。两数相加的结果就如图 2 所示。这样理论上来说,我们就可以计算无限大的数据。如上图 2 所示,下表表示对应的存储方式。

     数组 A数组 B数组 C
    [0]651
    [1]551
    [2]821
    [3]  1

    总结:利用数组存储,突破存储的限制。每个位置存储 0 ~ 9 之间的数据。

    高精度加法实现

    思路

    1、定义存储数组。

    2、读入数据到数组中。注意是倒序存放,也就是个位放在数组下标为 0 的地方。

    3、从个位开始模拟竖式加法的过程,完成整个加法。

    4、删除前导 0 。所谓前导零,就是出现类似这样数据 01234,这个 0 实际是不需要的。

    5、输出加法的结果。倒序输出加法的结果数组 C,因为我们的个位是存储在下标为 0 的地方。

    技术细节说明

    定义存储数组

    根据题目的要求定义数组。这个部分代码如下:

    const int MAXN = 1e5+4; //根据题目的最大值。+4为了防止A+B出现进位
    char s1[MAXN] = {};//存储字符串
    char s2[MAXN] = {};//存储字符串
    int a[MAXN] = {};//存储加数A
    int b[MAXN] = {};//存储加数B
    int c[MAXN] = {};//存储和B

    读入数据到数组

    利用读入字符串的方法读入数据,再倒序写入到对应的数组中。这个部分代码如下:

        scanf("%s %s", s1, s2);//读入字符串A
        //将字符串写入到数组A中
        int len1 = strlen(s1);
        for (int i=0; i<len1; i++) {
            //倒序写入
            a[i] = s1[len1-i-1] - '0';
        }
    
        //将字符串写入到数组A中
        int len2 = strlen(s2);
        for (int i=0; i<len2; i++) {
            //倒序写入
            b[i] = s2[len2-i-1] - '0';
        }

    注意:我们需要保存加数 A 和加数 B 的最大长度。因为竖式加法需要。

    模拟竖式加法

    有两个技术细节:1、进位如何保存;2、最高位进位如何解决。这个部分代码如下:

        //模拟竖式加法
        int jw=0;//进位
        int len = max(len1, len2)+1;//注意因为最高位可能出现进位
        for (int i=0; i<len; i++) {
            c[i] = a[i] + b[i] + jw;//当前加数A位数据+加数B位位数据+上一位的进位
            jw = c[i] / 10;//本次加法是否存在进位
            c[i] %= 10;//只能保存 0 ~ 9 的数据
        }

    删除前导零

    因为加法运算可能会出现最高位进位,所以我们在模拟竖式加法的时候多加了一位,所以我们需要判断是否需要删除前导零。这个部分代码如下:

        //删除前导零
        for (int i=len-1; i>=0; i--) {
            //因为我们是从索引 0 开始,所以最高位是保存在 len-1
            if (0==c[i] && len>1) {
                //注意要有 len>1 这个条件。考虑特殊情况,加法结果为 00,我们实际要输出 0。
                len--;
            } else {
                //第一个不是零的最高位,结束删除
                break;
            }
        }

    输出计算结果

    采用倒序的方式输出,因为我们数据保存是倒序结构,也就是低位在前。

        //逆序打印输出
        for (int i=len-1; i>=0; i--) {
            printf("%d", c[i]);
        }
        printf("\n");    

    例题和 AC 代码

    题目

    题目链接

    一本通 OJ:http://ybt.ssoier.cn:8088/problem_show.php?pid=1168

    我自己 OJ:http://47.110.135.197/problem.php?id=1215

    题目描述

    求两个不超过 200 位的非负整数的和。

    输入

    有两行,每行是一个不超过200位的非负整数,可能有多余的前导0。

    输出

    一行,即相加后的结果。结果里不能有多余的前导0,即如果结果是342,那么就不能输出为0342。

    样例输入

    22222222222222222222
    33333333333333333333

    样例输出

    55555555555555555555

    分析

    题目告诉我们不超过 200 位,也就是 MAXN = 200+4。

    AC 代码

    
    #include <bits/stdc++.h>
    using namespace std;
    
    const int MAXN = 200+4; //根据题目的最大值。+4为了防止A+B出现进位
    char s1[MAXN] = {};//存储字符串
    char s2[MAXN] = {};//存储字符串
    int a[MAXN] = {};//存储加数A
    int b[MAXN] = {};//存储加数B
    int c[MAXN] = {};//存储和B
    
    int main() {
        scanf("%s %s", s1, s2);//读入字符串A
        //将字符串写入到数组A中
        int len1 = strlen(s1);
        for (int i=0; i<len1; i++) {
            //倒序写入
            a[i] = s1[len1-i-1] - '0';
        }
    
        //将字符串写入到数组A中
        int len2 = strlen(s2);
        for (int i=0; i<len2; i++) {
            //倒序写入
            b[i] = s2[len2-i-1] - '0';
        }
    
        //模拟竖式加法
        int jw=0;//进位
        int len = max(len1, len2)+1;//注意因为最高位可能出现进位
        for (int i=0; i<len; i++) {
            c[i] = a[i] + b[i] + jw;//当前加数A位数据+加数B位位数据+上一位的进位
            jw = c[i] / 10;//本次加法是否存在进位
            c[i] %= 10;//只能保存 0 ~ 9 的数据
        }
    
        //删除前导零
        for (int i=len-1; i>=0; i--) {
            //因为我们是从索引 0 开始,所以最高位是保存在 len-1
            if (0==c[i] && len>1) {
                //注意要有 len>1 这个条件。考虑特殊情况,加法结果为 00,我们实际要输出 0。
                len--;
            } else {
                //第一个不是零的最高位,结束删除
                break;
            }
        }
    
        //逆序打印输出
        for (int i=len-1; i>=0; i--) {
            printf("%d", c[i]);
        }
        printf("\n");    
    
        return 0;
    }
    展开全文
  • 高精度加法详解

    2021-03-02 17:27:50
    高精度加法详解 对于加法学过编程的都知道,不过如果数据非常的大,大到无法用long long 这个数据类型储存,,特别是在这个大数据时代,这样的情况时有发生。这个时候就需要高精度算法来解决。 算法基本思想: 其实...

    高精度加法详解

    对于加法学过编程的都知道,不过如果数据非常的大,大到无法用long long 这个数据类型储存,,特别是在这个大数据时代,这样的情况时有发生。这个时候就需要高精度算法来解决。

    算法基本思想:

    其实也很简单,首先,既然普通的数据类型不够大,那么我们干脆用数组来存储,这样就解决了数据溢出的问题。其次,要怎么进行计算呢?就是用小学学加法时候的笔算用代码表示出来。比如小学计算947+34=?这个问题时:

    如此,只要数组足够大,多大的数据我也可以计算出来。

    算法描述:

    • 定义三个字符数组a,b,分别用来存储两个加数,定义一个temp来存储进位,且初始化为0,定义一个整数数组存储和。
    • 字符数组转换成整数数组A,B。
    • A[0]是个位,A[1]是十位,以此类推b。(B数组也是如此)
    • 个位相加即A[0]+B[0]+temp(初始化为0不会影响)=C[0],如果有进位(和是两位数),则把进位(和的十位)存储在temp中,个位存储在C[0]。
    • 十位相加即A[0]+B[0]+temp=C[0],如果有进位(和是两位数),则把进位(和的十位)存储在temp中,个位存储在C[0]。
    • 一直加下去,得出结果。

    接着就是代码实现:

    #include <iostream>
    #include <cstring>
    using namespace std;
    int A[100000],B[100000],C[10000000],temp=0,lena,lenb,lenc;
    char a[1000000],b[10000000];//因为数组太大尽量都定义在main函数外面。 
    int main(){
    	cin>>a;
    	cin>>b;
    	lena=strlen(a) ;//计算长度 
    	lenb=strlen(b);
    	for(int i=0;i<lena;++i)
    	A[i]=a[lena-1-i]-'0';
    	/*
    	将字符数组变成整数数组,并且将数组倒转。
    	为什么要倒转呢?
    	因为一开始输入时,高位在前,只有倒转以后才可以做到低位在前 。
    	例如输入100,200;
    	在a,b中存储时100,200;
    	倒转以后在A,B中就时001,002;
    	方便计算 
    	*/ 
    	for(int i=0;i<lenb;++i)
    	B[i]=b[lenb-1-i]-'0';
    	lenc=lena>lenb?lena:lenb;//得到较长的一个数
    	for(int i=0;i<lenc;++i) 
    	{
    		C[i]=A[i]+B[i]+temp;
    		temp=C[i]/10;
    		C[i]%=10;
    	}
    	if(temp!=0)//看最后是否temp为0。并进行分类处理 
    	{
    	C[lenc]=temp;
    	for(int i=lenc;i>=0;--i)
    	cout<<C[i];
    	return 0;
    	}
    	for(int i=lenc-1;i>=0;--i)//先输出高位 c
    	cout<<C[i];
    	return 0;
    }
    

    洛谷练习题:

    https://www.luogu.com.cn/problem/P1601

    题目描述

    高精度加法,相当于a+b problem,不用考虑负数.

    输入格式

    分两行输入。a,b≤10500a,b \leq 10^{500}a,b≤10500

    输出格式

    输出只有一行,代表a+b的值

    输入输出样例
    输入 #1
    1
    1
    

    输出 #1

    2
    

    输入 #2

    1001
    9099
    

    输出 #2

    101
    
    展开全文
  • c 语言 高精度加法

    2019-05-31 11:40:03
    高精度加法 问题描述  输入两个整数a和b,输出这两个整数的和。a和b都不超过100位。 算法描述  由于a和b都比较大,所以不能直接使用语言中的标准数据类型来存储。对于这种问题,一般使用数组来处理。  定义一个...
  • 高精度加法函数模板

    2021-02-27 10:09:28
    string P (string & num,string add){ int g=0; if(num.length()<add.length()){ string t=num; num=add; ... string t (num.length()-add.length(),'0');... int len1=num.length(),len2=add.length.
  • 用C++实现高精度加法

    2020-12-22 15:42:30
    近遇到一个c++实现高精度加法的问题,高精度问题往往十复杂但发现其中的规律后发现并没有那么复杂,这里我实现了一个整数的高精度加法,主要需要注意以下几点:  1:将所需输入的数据以字符数组的形式输入,建立...
  • 蓝桥杯java高精度加法

    2021-03-09 18:53:47
    高精度加法的应用 Fibonacci数列 Fibonacci数列的代表问题是由意...C语言-进制转化及高精度加法._数学_高中教育_教育专区。C语言-进制转化及高精度加法. 感谢! C语言-进制转化及高精度加法. 感谢! ...c语言 高精度加...
  • 高精度加法(C语言实现)

    万次阅读 多人点赞 2018-08-09 17:58:46
    那么,先来讲一下高精度加法吧! 源代码&amp;amp;amp;amp;amp;amp;amp;amp;amp;注释 //小程序版 #include&amp;amp;amp;amp;amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;amp;amp;amp;amp...
  • C语言高精度加法

    2020-12-25 21:05:04
    希望大佬看到错误可以帮忙指出,第一次遇到需要高精度计算的题目,一开始傻乎乎的直接计算发现不得行,原来还能这样。 主要思路: 字符数组可以连续输入但又不是整型数字而是字符,而整型数组可以输入数字但又不能...
  • c语言高精度加法

    2021-12-06 20:56:18
    c语言高精度加法
  • 这里是一些废话: 早在学习斐波那契数列兔子繁殖问题的时候,超过一定...自己就下决心学会了高精度四则运算之后一定要写一个非常详细的思路和注释给初学者,但是我学会了以后就并不想写思考历程了(??),好吧好吧
  • java:高精度加法

    千次阅读 2020-02-15 19:23:11
    java:高精度加法 题目 问题描述  输入两个整数a和b,输出这两个整数的和。a和b都不超过100位。 算法描述  由于a和b都比较大,所以不能直接使用语言中的标准数据类型来存储。对于这种问题,一般使用数组来处理。  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 32,930
精华内容 13,172
关键字:

高精度加法

友情链接: STM32F10-CAN.zip