3.C++秒懂高精度数

最新推荐文章于 2024-08-22 09:58:11 发布
最新推荐文章于 2024-08-22 09:58:11 发布
阅读量784 收藏
点赞数
分类专栏： 高精度数 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyds_WXY/article/details/124932975
版权

高精度数加法运算的进位问题

知识目标

  • 学习高精度数加法运算的进位。高精度数的加法运算——进阶高精度数的加法运算

【问题描述】

输入两个高精度数，输出这两个数的和（两个高精度数位数不一定相同且可能存在进位）。

【样例输入 1】 9999900000

123456789

【样例输出 1】 10123356789

【样例输入 2】 123456789

123456789

【样例输出 2】 246913578

解题思路：

  • 1、读入两个大数存入两个字符串中
  • 2、求出大数的长度
  • 3、将字符类型转换为数字类型倒序存入整型数组中
  • 4、将两个整型数组中对应位数字相加存入整型数组中，并处理进位
  • 5、判断最高进位是否为 0
  • 6、倒序输出

【过程分析】

对此类型的题我们总结方法如下：

两个高精度数的加法：倒序补 0，对应位相加，处理进位，倒序输出。

第一步：定义两个字符型数组 a1，b1 用来存储进行相加的两个高精度数，定义整型数组a，b，c 分别用来存储两个高精度数的数字和相加后得到的数字，定义整型变量 lena，lenb， i 分别表示相加的两个数的位数及循环变量，定义整型变量 lenc，x 分别表示两个高精度数相加后的数的位数长度和进位，对 lenc 和 x 赋初始值为 0；

char a1[1001]= {},b1[1001]= {};
int a[1001]= {},b[1001]= {},c[1001]= {},lena,lenb,i; 
int lenc = 0,x = 0;

第二步：输入两个高精度数，并分别求出两个高精度数的长度；

cin>>a1>>b1;
lena = strlen(a1); 
lenb = strlen(b1);

第三步：使用 for 循环遍历，分别将存储在字符数组里的被加数和加数字符串转换为数字， 并倒序储存到整型数组里；

for(i = 0; i <= lena-1; i++) { 
    a[lena-i-1] = a1[i] - 48;
}
for(i = 0; i <= lenb -1; i++) { 
    b[lenb-i-1] = b1[i] - 48;
}

第四步：使用 while 循环语句对各个数位上的数求和，满足相加得到的位数小于 a 的长度或者 b 的长度时，执行循环语句，每次循环的过程中将 a 和 b 对应位的数相加并加上进位 x 的值，得到对应数位的数存储在 c 数组中，因为得到的数可能超过 10，因此计算完后需要进行进位 x 值的更新，并用该数对 10 取余得到该位上的数；

while(lenc<lena||lenc<lenb) { 
    c[lenc]=a[lenc]+b[lenc]+x; 
    x = c[lenc]/10;
    c[lenc] = c[lenc]%10; 
    lenc++;
}

第五步：使用 if 语句判断三个高精度最高位相加的进位 x 是否不为 0，成立则赋值给相加和的最高位，不成立则 lenc 减 1,去掉前导 0；

if(x){
    c[lenc]=x;
}else{
    lenc--;
}

第六步：使用 for 循环语句进行倒序输出各个数位上的数即为最后的正确结果。

for( i = lenc; i >= 0; i--){ 
    cout << c[i];
}

完整代码：

#include <iostream> 
#include <cstring> 
using namespace std; 
int main() {
    char a1[1001]= {},b1[1001]= {};
    int a[1001]= {},b[1001]= {},c[1001]= {},lena,lenb,i; 
    int lenc = 0, x = 0;
    cin>>a1>>b1;
    lena = strlen(a1); 
    lenb = strlen(b1);
    for(i = 0; i <= lena-1; i++) { 
        a[lena-i-1] = a1[i] - 48;
    }
    for(i = 0; i <= lenb -1; i++) { 
        b[lenb-i-1] = b1[i] - 48;
    }
    while(lenc<lena||lenc<lenb) { 
        c[lenc]=a[lenc]+b[lenc]+x; 
        x = c[lenc]/10;
        c[lenc] = c[lenc]%10; 
        lenc++;
    }
    if(x){
        c[lenc]=x;
    }else{
        lenc--;
    }
    for(i = lenc;i >=0;i--){ 
        cout << c[i];
    }
    return 0;
}

高精度数的运算：

【问题描述】输入三个高精度数，计算他们的和并输出（没有进位）。

【输入样例】

111111111111111111111

222222222222222222222

17

【输出样例】

333333333333333333350

解题思路：

  • 1、读入三个大数存入三个字符串中
  • 2、将字符类型转换为数字类型存入整型数组中
  • 3、首先计算前两个高精度数的和，存储在第一个整形数组中，然后计算第一个整形数组和第三个整形数组的和，保存在第一个整形数组中
  • 4、输出第一个整形数组

【过程分析】

第一步：定义三个字符型数组 a1，b1，c1 用来存储进行相加的三个高精度数，定义整型数组a，b，c,d 分别用来存储三个高精度数的数字和三个数相加和，定义整型变量lena，lenb， lenc，i 分别表示相加的三个数的位数及循环变量，定义整型变量 len，x 分别表示三个高精度数相加后的数的位数长度和进位，对 lenc 和 x 赋初始值为 0；

char a1[1001]={},b1[1001]={},c1[1001]={};
int a[1001]={},b[1001]={},c[1001]={},d[1001]={};
int x=0,len=0,lena,lenb,lenc;

第二步：输入三个高精度数，并分别求出三个高精度数的长度；

cin>>a1>>b1>>c1; lena = strlen(a1); 
lenb = strlen(b1); 
lenc = strlen(c1);

第三步：使用 for 循环遍历，分别将存储在字符数组里的被加数和加数字符串转换为数字， 并倒序储存到整型数组里；

for(i = 0; i <= lena-1; i++) { 
    a[lena-i-1] = a1[i] - 48;
}
for(i = 0; i <= lenb -1; i++) { 
    b[lenb-i-1] = b1[i] - 48;
}
for(i = 0; i <= lenc -1; i++) { 
    c[lenc-i-1] = c1[i] - 48;
}

 第四步：使用 while 循环语句对各个数位上的数求和，满足相加得到的位数小于 a 的长度或者 b 的长度或者 c 的长度时，执行循环语句，每次循环的过程中将 a 和 b 对应位的数相加并加上进位 x 的值，得到对应数位的数存储在 c 数组中，因为得到的数可能超过 10，因此计算完后需要进行进位 x 值的更新，并用该数对 10 取余得到该位上的数；

while(len<lena||len<lenb||len<lenc) { 
    d[len]=a[len]+b[len]+c[len]x;
    x = d[len]/10; d[len] = d[len]%10; 
    len++;
}

第五步：使用 if 语句判断三个高精度最高位相加的进位 x 是否不为 0，成立则赋值给相加和的最高位，不成立则 len 减 1,去掉前导 0；

if(x){
    d[len] = x;
}else{ 
    len--;
}

第六步：使用 for 循环语句进行倒序输出各个数位上的数即为最后的正确结果；

for( i=len;i >=0;i--){ 
    cout << d[i];
}

完整代码：

#include<iostream> 
#include<cstdio> 
#include<algorithm> 
#include<cstring> 
using namespace std; 
int main(){
    char a1[1001]={},b1[1001]={},c1[1001]={};
    int a[1001]={},b[1001]={},c[1001]={},d[1001]={};
    int x=0,len=0,lena,lenb,lenc,i; 
    cin>>a1>>b1>>c1;
    lena = strlen(a1); 
    lenb = strlen(b1); 
    lenc = strlen(c1);
    for(i = 0; i <= lena-1; i++) { 
        a[lena-i-1] = a1[i] - 48;
    }
    for(i = 0; i <= lenb -1; i++) { 
        b[lenb-i-1] = b1[i] - 48;
    }
    for(i = 0; i <= lenc -1; i++) { 
        c[lenc-i-1] = c1[i] - 48;
    }
    while(len<lena || len<lenb || len<lenc) { 
        d[len] = a[len] + b[len] + c[len] + x; 
        x = d[len]/10;
        d[len] = d[len]%10; 
        len++;
    }
    if(x){
        d[len] = x;
    }else{
        len--;
    }
    for( i=len;i >=0;i--){ 
        cout << d[i];
    }
    return 0;
}

模拟乘法：

【问题描述】输入一个高精度数，输出他的两倍的值是多少？

【输入样例】

1111111111111111111111111115

【输出样例】

2222222222222222222222222230

【过程分析】

第一步：定义一个字符型数组 a1 用来存储进行相加的一个高精度数，定义整型数组 a，b 分别用来存储高精度数的数字和数字 2 倍的值，定义整型变量 lena，i 分别表示相加的三个数的位数及循环变量，定义整型变量 len，x 分别表示三个高精度数相加后的数的位数长度和进位，对 len 和 x 赋初始值为 0；

char a1[1001]={};
int a[1001]={},b[1001]={};
int x=0,len=0，lena;

第二步：输入一个高精度数；

cin>>a1;
lena = strlen(a1);

第三步：使用 for 循环遍历，分别将存储在字符数组里的被加数和加数字符串转换为数字， 并倒序储存到整型数组里；

for(i = 0; i <= lena-1; i++) { 
    a[lena-i-1] = a1[i] - 48;
}

第四步：使用 while 循环语句对各个数位上的数求和，满足相加得到的位数小于 a 的长度或者 b 的长度或者 c 的长度时，执行循环语句，每次循环的过程中将 a 和 b 对应位的数相加并加上进位 x 的值，得到对应数位的数存储在 c 数组中，因为得到的数可能超过 10，因此计算完后需要进行进位 x 值的更新，并用该数对 10 取余得到该位上的数；

while(len<lena) {
    b[len]=a[len]+a[len]+x; x = b[len]/10;
    b[len] = b[len]%10; len++;
}

第五步：使用 if 语句判断三个高精度最高位相加的进位 x 是否不为 0，成立则赋值给相加和的最高位，不成立则 len 减 1,去掉前导 0；

if(x){
    b[len] = x;
}else{ 
    len--;
}

第六步：使用 for 循环语句进行倒序输出各个数位上的数即为最后的正确结果；

for( i=len;i >=0;i--){ 
    cout << b[i];
}

完整代码：

#include <iostream> 
#include <cstring> 
using namespace std; 
int main (){
    char a1[1001]={};
    int a[1001]={},b[1001]={};
    cin >> a1;
    int lena = strlen(a1);
    int x=0,len=0;
    for (int i=0;i<=lena-1;i++){ 
        a[lena-1-i] = a1[i] - 48;
    }
    while(len<lena){ 
        b[len]=a[len]+a[len]+x; 
        x=b[len]/10;
        b[len] = b[len]%10; len++;
    }
    if(x){
        b[len] = x;
    }else{
        len--;
    }
    for(int i=len;i>=0;i--){ 
        cout <<b[i];
    }
    return 0;
}

求高精度数相加的进位次数：

【问题描述】

输入两个高精度数，输出他们相加时的进位次数

【样例输入】

11111111111111111

92222222222222219

【样例输出】

2

【过程分析】

第一步：定义两个字符型数组 a1，b1 用来存储进行相加的两个高精度数，定义整型数组a，b，c 分别用来存储两个高精度数的数字和相加后得到的数字，定义整型变量 lena，lenb， i 分别表示相加的两个数的位数及循环变量，定义整型变量 lenc，x，num 分别表示两个高精度数相加后的数的位数长度，进位和进位的次数，对 lenc，x，num 赋初始值为 0；

char a1[1001]= {},b1[1001]= {};
int a[1001]= {},b[1001]= {},c[1001]= {},lena,lenb,i; 
int lenc = 0,x = 0,num = 0;

第二步：输入两个高精度数，并分别求出两个高精度数的长度；

cin>>a1>>b1;
lena = strlen(a1); 
lenb = strlen(b1);

第三步：使用 for 循环遍历，分别将存储在字符数组里的被加数和加数字符串转换为数字， 并倒序储存到整型数组里；

for(i = 0; i <= lena-1; i++) { 
    a[lena-i-1] = a1[i] - 48;
}
for(i = 0; i <= lenb -1; i++) { 
    b[lenb-i-1] = b1[i] - 48;
}

第四步：使用 while 循环语句对各个数位上的数求和，满足相加得到的位数小于 a 的长度或者 b 的长度时，执行循环语句，每次循环的过程中将 a 和 b 对应位的数相加并加上进位 x 的值，得到对应数位的数存储在 c 数组中，因为得到的数可能超过 10，因此计算完后需要进行进位 x 值的更新。使用 if 语句判断 x 的值为 1 时，num 加 1。然后用该数对 10 取余得到该位上的数；

while(lenc<lena||lenc<lenb) { 
    c[lenc]=a[lenc]+b[lenc]+x; 
    x = c[lenc]/10;
    if(x==1){
        num++;
    }
    c[lenc] = c[lenc]%10; lenc++;
}

第五步：输出 num 的值；

cout << num;

完整代码：

#include <iostream> 
#include <cstring> 
using namespace std; 
int main (){
    char a1[1001]={},b1[1001]={};
    int a[1001]={},b[1001]={}, c[1001]= {};
    int lena,lenb,i,len = 0,x = 0,num = 0; 
    cin >> a1 >> b1;
    lena = strlen(a1); 
    lenb = strlen(b1);
    for(i = 0; i <= lena-1; i++) { 
        a[lena-i-1] = a1[i] - 48;
    }
    for(i = 0; i <= lenb -1; i++) { 
        b[lenb-i-1] = b1[i] - 48;
    }
    while(len<lena || len<lenb){ 
        a[len]=a[len]+b[len]+x; 
        x=a[len]/10;
        if(x==1) 
            num++; 
            a[len] = a[len]%10; 
            len++;
    }
    cout << num; 
    return 0;
}
yyds_WXY
关注
专栏目录
高精度数的减法
buhuihanshu的博客
03-05 1186
题目名称：高精度数的减法 题目描述：输入两个高精度数（长度不超过100位）a,b。求a-2b的值。 输入描述：共2行，第1行是被减数a，第2行是减数b（a>2b并且a，2b的位数不同且不存在借位，且b+b不存在借位）。 输出描述：一行，即所求的差。 样例输入： 888888888888888888888888 44444444 样例输出： 888888888888888800000000 #include <iostream> #include <cstring> using
c++高精度整数库（支持高精度除高精度）
02-23
这个版本的高精度整数库不仅支持高精度除高精度，同时修复了减法计算中的一个严重的bug。并支持高精度类型与其他一切可转换为高精度类型的类型（int,long long,unsignd,string)进行混合运算。同时，全面优化了除法、取余计算的时间复杂度。
c++高精度（支持高精度除单精度）
02-14
第二版已全面提升性能，并修复了一个严重的内存泄漏的bug。欢迎下载使用！
C++高精度
热门推荐
SkeletonKing233的博客
08-13 1万+
在C++中当你用int、long long，甚至是unsigned long long 都无法处理的超级巨大数字，你会感到无比痛苦甚至到绝望，那么我们此时就只有一种方法了——高精度算法。
高精度算法（c++）
2301_81587174的博客
08-09 719
在C++中，高精度和低精度通常指的是处理数字时所用的数据结构的精度高低。例如，如果你使用内置的整型（如intlong或long long）来处理较大的数字，它们可能会溢出，这时你可能会使用数组或者来模拟大整数，这样的结构就可以看作是高精度数据类型。而对应地，低精度可以理解为使用较小的数据类型，如charshort或内置的整数类型。C++标准规定：int占一个机器字长，在32位系统中int占32位，即4个字节，所以int的范围是[-,],为数量级。long long的范围则是[,],为数量级。
C++ 高精度算法（并附实例）
WIND_NAN的博客
07-26 5490
C++ 高精度算法（并附实例）
[C++实现]高精度算法
m0_71229255的博客
02-10 2143
​ 在一般的科学计算中，会经常算到小数点后几百位或者更多，当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数，高精度算法是用计算机对于超大数据的一种模拟加、减、乘、除、乘方、阶乘、开方等运算。 对于一个很大的数字N >= 10^ 100，很显然这样的数字无法在计算机中正常存储。于是， 我们想到了办法，将这个数字拆开，拆成一位一位的或者是四位四位的存储到一个数组中，用一个数组去表示一个数字。这样这个数字就被称谓是高精度数。 对于高精度数，也要像平常数一样做加减乘除以及乘方的运算，于是就有了高精度
C++算法之高精度计算
一个程序猿~
04-30 3207
利用计算机进行计算时，有时会遇到计算精度不够的问题。但是我们可以利用程序实现高精度计算，本文介绍几种常用的高精度计算方法。
深入理解大数与高精度数的处理问题
09-05
在计算机科学中，大数（Large Number）和高精度数（High-Precision Number）是指那些超过常规数据类型如`float`、`double`所能表示范围的数值。这些数据类型，如`float`，通常有6-7位有效数字，而`double`则有15-16...
大数(高精度数)模板(分享)
09-05
大数（高精度数）模板是处理超过标准整型或浮点型所能表示的数值的一种技术，常在编程竞赛和算法实现中使用。本文将详细分析并解释如何使用C++来实现大数的常见操作，如加法、减法和乘法。 首先，我们定义一个...
c++输入三个高精度数，输出三个其中最大值简单
06-09
// 比较两个高精度数的大小，如果a大于等于b，返回true，否则返回false bool cmp(string a, string b) { if (a.size() != b.size()) { return a.size() > b.size(); } return a >= b; } int main() { // 输入...
c++输入三个高精度数，输出三个其中最大值
06-09
以下是一个简单的 C++ 代码示例，可以实现输入三个高精度数，并输出其中最大值： ```c++ #include #include #include using namespace std; // 高精度整数类 class BigInteger { public: string num; ...
高精度练习题
02-25
一道非常非常恶心的高精度+模拟题（只有输入输出数据和我出这道题时给出的题目描述）
1.C++秒懂高精度数
yyds_WXY的博客
05-22 1656
C++高精度知识
C++高精度算法
qq_41117896的博客
09-03 1608
C++高精度算法 本文转载自：http://blog.sina.com.cn/s/blog_4fdb102b010087ng.html 前言:由于计算机运算是有模运算,数据范围的表示有一定限制,如整型int(C++中int 与long相同)表达范围是(-231~231-1),unsigned long(无符号整数)是(02^32-1),都约为几十亿.如果采用实数型,则能保存最大的double只能提供1516位的有效数字,即只能精确表达数百万亿的数.因此,在计算位数超过十几位的数时,不能采用现有类型,只能自己
高精度加减乘除算法模板题，详细易懂（C++实现）
Curz酥的博客
01-24 902
高精度加减乘除简单算法例题
c++高精度细剖
最新发布
szm111213的博客
08-22 1019
高精度计算是指能够处理超出标准数据类型（如intlong longfloatdouble等）范围或精度的数值运算。这在金融计算、科学模拟、密码学、大数分解等领域尤为重要。
高精度数的计算器c++算法代码
02-26
高精度数的计算器一般使用字符串表示数字，然后模拟手工计算的过程进行计算。下面是一个简单的高精度数的加法算法代码示例（使用C语言实现）： ```c #include <stdio.h> #include <string.h> #define MAXN 1005 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值