高精度整数加法

最新推荐文章于 2022-10-05 17:21:52 发布
最新推荐文章于 2022-10-05 17:21:52 发布
阅读量650 收藏
点赞数
分类专栏： c/c++ 文章标签： 高精度 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010571660/article/details/9262203
版权

问题描述： 
在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中，

参与运算的操作数和结果必须在-231~231-1之间。如果需要进行更大范围的十进制整数加法，需要使用特殊

的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。

 

如下： 

9876543210 + 1234567890 = ?

让字符串 num1="9876543210"，字符串 num2="1234567890"，结果保存在字符串 result = "11111111100"。

 

-9876543210 + (-1234567890) = ?

让字符串 num1="-9876543210"，字符串 num2="-1234567890"，结果保存在字符串 result = "-11111111100"。

 

题目：要求编程实现上述高精度的十进制加法。

 

 

我的思路是：先将每个字符串除符号位之外的所有数字位转换成整数，然后按照右对齐的方式，暂时不考虑进位或借位，进行加减法运算，之后再考虑每一位是否需要进位或借位，更新每一位的值，最后再将这些数值转换成字符，存入相应的数组。

 

下面是参考代码：

#include <iostream>
#include <stdlib.h>
#include <string>
#define MAX 15
using namespace std;

void add(const char *num1,const char *num2,char *result);

int main()
{
 char num1[]="-9876543210";
 char num2[]="-1234567890";
 char res[MAX]="";

 add(num1,num2,res);                                                                                                                                          
 return 0;
}

void add(const char *num1,const char *num2,char *result)
{
 if (num1==NULL || num2==NULL)
 {
  return;
 }
 if ((num1[0]=='-'&& num1[1]=='0') || num1[0]=='0' || (num2[0]=='-'&& num2[1]=='0') || num2[0]=='0')
 {
  return;
 }
 const char *n1=NULL;
 const char *n2=NULL;
 char *p=result;

 int len1=strlen(num1);
 int len2=strlen(num2);
 int sum[MAX+1]={0};
 int x[MAX]={0};
 int y[MAX]={0};

 int i=0,j=0;
 //不考虑符号位，哪个字符串长，就将哪个赋给n1,将来转换成整数时存放在x[]中
 if((*num1=='-' && *num2=='-') || (*num1!='-' && *num2!='-'))
 {
  if (len1>=len2)
  {
   n1=num1;
   n2=num2;
  }
  else
  {
   n1=num2;
   n2=num1;
  }
 }
 else if(*num1=='-' && *num2!='-')
 {
  if (len1-1>=len2)
  {
   n1=num1;
   n2=num2;
  }
  else
  {
   n1=num2;
   n2=num1;
  }
 }
 else
 {
  if (len1>=len2-1)
  {
   n1=num1;
   n2=num2;
  }
  else
  {
   n1=num2;
   n2=num1;
  }
 }
 //把第一个数的每一位转换成数字，保存在数组中
 if (n1[0]!='-')
 {
  for (i=len1-1;i>=0;i--)
  {
   x[i]=(n1[i]-'0');
   //cout <<x[i]<<" ";
  }
 }
 else
 {
  for (i=len1-1;i>0;i--)
  {
   x[i]=n1[i]-'0';
   //cout <<x[i]<<" ";
  }
 }


 //把第二个数的每一位转换成数字，保存在数组中
 if (*n2!='-')
 {
  for (j=len2-1;j>=0;j--)
  {
   y[j]=n2[j]-'0';
   //cout <<y[j]<<" ";
  }
 }
 else
 {
  for (j=len2-1;j>0;j--)
  {
   y[j]=n2[j]-'0';
   //cout <<y[j]<<" ";
  }
 }
//cout<<endl;
 int takeover=0;//进位标志符
 int takedown=0;//借位标志符
 int k=0;

 //1：两个数都为正数
 if (*n1!='-' && *n2!='-')
 {
  //先不考虑进位，求每一位对应的和
   for(i=len1-1,j=len2-1;i>=0;i--,j--)
   {
    if (j>=0)
    {
     sum[k]=x[i]+y[j];
     //cout <<sum[k] <<" ";
    }
    else
    {
     sum[k]=x[i];
    }
    k++;
   }
   //cout<<endl;

   //计算进位，修改相应位的值
   for (i=0;i<MAX;i++)
   {
    if (sum[i]>=10)
    {
     sum[i]=sum[i]%10;
     takeover=1;
     sum[i+1]+=takeover;
    }
   }

   //把每一位转换成字符型
   if (sum[len1]==0)
   {
    for (i=0;i<len1;i++)
    {
     p[len1-1-i]=sum[i]+'0';
    }
   }
   else
   {
    for (i=0;i<=len1;i++)
    {
     p[len1-i]=sum[i]+'0';
    }
   }
   printf("%s\n",p);
      
 }
 //2：两个数都为负数
 else if (*n1=='-' && *n2=='-')
 {
  //先不考虑进位，求每一位对应的和
  for(i=len1-1,j=len2-1;i>0;i--,j--)
  {
   if (j>0)
   {
    sum[k]=x[i]+y[j];
    //cout <<sum[k] <<" ";
   }
   else
   {
    sum[k]=x[i];
   }
   k++;
  }
  //cout<<endl;
  
  //计算进位，修改相应位的值
  for (i=0;i<MAX;i++)
  {
   if (sum[i]>=10)
   {
    sum[i]=sum[i]%10;
    takeover=1;
    sum[i+1]+=takeover;
   }
  }
  
  //把每一位转换成字符型
  if (sum[len1-1]==0)
  {
   for (i=0;i<len1-1;i++)
   {
    p[len1-1-i]=sum[i]+'0';
   }
  }
  else
  {
   for (i=0;i<len1;i++)
   {
    p[len1-i]=sum[i]+'0';
   }
  }
  p[0]='-';
   printf("%s\n",p);
 }
 //3：较长的数为正数，较短的数为负数
 else if (*n1!='-' && *n2=='-')
 {
  //不考虑借位，计算每一位对应的差
  for(i=len1-1,j=len2-1;i>=0;i--,j--)
  {
   if (j>0)
   {
    sum[k]=x[i]-y[j];
   }
   else
   {
    sum[k]=x[i];
   }
   k++;
  }

  //根据每一位的值，考虑借位，更新数值
   for (i=0;i<len1-1;i++)
   {
    if (sum[i]<0)
    {
     sum[i]=sum[i]+10;
     takedown=1;
     sum[i+1]-=takedown;
    }
   }
   //把每一位转换成字符型
   if (sum[len1-1]>0)
   {
    for (i=0;i<len1;i++)
    {
     p[len1-1-i]=sum[i]+'0';
    }
   }
   else if(sum[len1-1]==0)
   {
    for (i=0;i<len1-1;i++)
    {
     p[len1-2-i]=sum[i]+'0';
    }
   }
   else
   {
    for (i=0;i<len1-1;i++)
    {
     sum[i]=10-sum[i];
     takedown=1;
     sum[i+1]+=takedown;
    }
    if(sum[i]==0)
    {
     for(i=0;i<len1-1;i++)
     {
      p[len1-1-i]=sum[i]+'0';
     }
    }
    else if (sum[i]<0)
    {
     sum[i]=-sum[i];
     for(i=0;i<=len1-1;i++)
     {
      p[len1-i]=sum[i]+'0';
     }
    }
    p[0]='-';
   } 

 printf("%s\n",p);
 }
 //4：较长的数为负数，较短的数为正数
 else if (*n1=='-' && *n2!='-')
 {
  //不考虑借位，计算每一位对应的差
  for(i=len1-1,j=len2-1;i>0;i--,j--)
  {
   if (j>=0)
   {
    sum[k]=x[i]-y[j];
   }
   else
   {
    sum[k]=x[i];
   }
   k++;
  }

   //根据每一位的值，考虑借位，更新数值
   for (i=0;i<len1-2;i++)
   {
    if (sum[i]<0)
    {
     sum[i]=sum[i]+10;
     takedown=1;
     sum[i+1]-=takedown;
    }
   }
   //把每一位转换成字符型
   if (sum[len1-2]>0)
   {
    for (i=0;i<len1-1;i++)
    {
     p[len1-1-i]=sum[i]+'0';
    }
    p[0]='-';
   }
   else if(sum[len1-2]==0)
   {
    for (i=0;i<len1-2;i++)
    {
     p[len1-2-i]=sum[i]+'0';
    }
    p[0]='-';
   }
   else
   {
    for (i=0;i<len1-2;i++)
    {
     sum[i]=10-sum[i];
     takedown=1;
     sum[i+1]+=takedown;
    }
    if(sum[i]==0)
    {
     for(i=0;i<len1-1;i++)
     {
      p[len1-2-i]=sum[i]+'0';
     }
     p[0]='-';
    }
    else if (sum[i]<0)
    {
     sum[i]=-sum[i];
     for(i=0;i<=len1-2;i++)
     {
      p[len1-2-i]=sum[i]+'0';
     }
    }
   }  
 printf("%s\n",p);
 }
}

 

以上仅是我个人的一点想法，方法可能不是很好，希望大家指导！

化茧成蝶2013
关注
专栏目录
【华为OD机试Python实现】HJ57 高精度整数加法（中等）
03-31 854
文章目录题目描述输入描述：输出描述：示例1参考代码 题目描述 输入两个用字符串 str 表示的整数，求它们所表示的数之和。 数据范围：1≤len(str)≤10000 输入描述： 输入两个字符串。保证字符串只含有’0’~'9’字符 输出描述： 输出求和后的结果 示例1 输入： 9876543210 1234567890 输出： 11111111100 参考代码 # 偷懒的做法 使用 eval 直接相加，机试可以使用笔试时该方法不能通过 while 1: try: print
【华为机试真题JavaScript】高精度整数加法
最新发布
10-26 228
输入两个用字符串 str 表示的整数，求它们所表示的数之和。数据范围： 1 \le len(str) \le 10000 \1≤len(str)≤10000。
高精度整数的加法
weixin_50731537的博客
11-22 230
//高精度整数的加法 #include<iostream> using namespace std; int Mul(int* a, int na, int x) { int i; int jw = 0; //进位 for (i = 0; i < na; i++) { int temp = a[i] * x + jw; a[i] = temp % 10; jw = temp / 10; } //进位不为0的时候处理a[na]及以后的位 while (jw !=
华为OJ——无线OSS－高精度整数加法
Lizhifun
08-15 1077
题目描述 在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中， 参与运算的操作数和结果必须在-231~231-1之间。如果需要进行更大范围的十进制整数加法，需要使用特殊 的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。如下： 9876543210 + 1234567890 = ? 让字符串 num1="98765432
高精度整数加法（大整数加法）
weixin_30794491的博客
09-08 140
　　如果我们需要很大范围的十进制整数加法，对于4字节int型，不能表示该数据，此时需要用字符串保存操作数和结果，采取逐位运算的方式。如： 　　987654321 + 1234567989 = 1111111110 　　-1234 + （-4567） = -5801 　　-1234 + 30 = -1204 　　0 + 0 = 0 　　0 + 34 = 34. 　　实现函数void ad...
大整数加法（高精度）
weixin_33701251的博客
01-14 186
对于一些超过100位的大整数，我们不可能直接去计算，否者将超出编译器的规定范围而出错！！！所以，你只能利用字符串数组的知识来解这样的题，呵呵呵！！！不多说了，下面看程序吧！！哈 #include&lt;iostream&gt;#include&lt;cstring&gt;using namespace std;int main(){  int Num[105][105]; char num[10...
【华为机试真题 Python】高精度整数加法
10-05 413
输入两个用字符串 str 表示的整数，求它们所表示的数之和。保证字符串只含有’0’~'9’字符。数据范围：1≤len(str)≤10000。
高精度大整数加法C++实现
01-06
该资源通过C++代码实现两个大整数的相加，适用于当long long也存不下的数进行相加时使用，通过数组模拟算术加法实现，运行时只需输入两个加数，敲回车即可出结果
【华为OJ】【039-无线OSS-高精度整数加法】
https://github.com/Wang-Jun-Chao
05-10 2360
【华为OJ】【算法总篇章】【华为OJ】【039-无线OSS-高精度整数加法】【工程下载】题目描述在计算机中，由于处理器位宽限制，只能处理有限精度的十进制整数加减法，比如在32位宽处理器计算机中， 参与运算的操作数和结果必须在-231~231-1之间。如果需要进行更大范围的十进制整数加法，需要使用特殊 的方式实现，比如使用字符串保存操作数和结果，采取逐位运算的方式。如下： 9876543210 + 1
高精度整数加法（java）
就这样吧
07-23 340
题目 牛客链接：高精度整数加法 题目描述 输入两个用字符串表示的整数，求它们所表示的数之和。 字符串的长度不超过10000。 本题含有多组样例输入。 输入 9876543210 1234567890 输出 11111111100 基本思路 题目不难，就是比较难处理。字符串类型的题目貌似都比较繁琐！ 找出最长的字符串 num； 将输入的两个字符串字符串 num1 和 num2 的数组逐个添加到数组后续进行相加； 处理最长的字符串在没有遍历玩的情况下； 处理溢出的数字； 遍历输出。
高精度加法（大整数加法）
m0_52118763的博客
09-12 687
高精度加法是高精度四则运算中比较简单的， 主要就是将长整数当成string读入，然后 倒着存到vector中，然后处理一下进位的问题 #include<iostream> #include<vector> using namespace std; vector<int> add(vector<int> &A, vector<int> &B) { vector<int> C; int t=0; f
高精度正整数加法
蚩尤煜的博客
03-21 317
高精度正整数加法1.原理2.代码 1.原理 使用的是模拟手算的方法 例如：123456+1234 1 2 3 4 5 6 + 1 2 3 4 = 1 2 4 6 9 0 我们手算时都是从最右边开始竖着的那位相加的，依次向左重复竖着相加 2.代码 //s1长度长，s2短 //这里使用引用参数(&)是为了不要再生成s1，s2字符串 void Add(string& s1, string& s2) { int cnt = 0; //记录进位，初始化为0，无进
大整数加法（高精度加法）
weixin_30300225的博客
08-17 304
什么是大整数？所谓大整数就是特别大的是（超出long long的范围），这个时候我们常用的a+b就不能用了； 但是我们可以将整数转化为字符串来处理，利用加法的原理，一位一位的来加，因为字符串没有长度的限制； 题目链接：https://www.luogu.org/problem/P1601 题目描述 高精度加法,相当于a+b problem，不用考虑负数. 输入格式 ...
高精度整数加法器
qq_40962064的博客
05-11 260
输入两个整数，其位数不超过1000位。 用代码模拟加法的运算法则，按照从低位开始各对应位相加并加上来自低位的进位从而获得本位的数值。 采用了重载+运算符的方法实现该加法运算。 #include<stdio.h> #include<string.h> struct bigInteger{//高精度整数结构体 int digit[1000];//按四位数一个单位保存数值 i...
高精度算法：大整数加法
m0_66729771的博客
07-18 412
高精度算法
整数高精度运算——加法
07-06 148
高精度运算是信息学的一种重要算法。这种算法使用多个存储单位进行计算，因此它的计算范围超过一般使用一个存储单位的算法。也是一些信息学竞赛的常考题目。 高精度运算主要有以下几个步骤： 1、读取字符串，转换成数字倒序存储到整数数组中； 2、运算，注意进位和借位； 3、倒序输出整数数组，加法注意最高位进位，减法注意高位中的无用的0不要输出； 高精度加法代码： #include&...
高精度整数加法实现-刘汝佳绝对值算法
这段代码提供了高精度整数加法的一个基础实现，通过巧妙地处理符号和进位，使得大整数的加法运算变得可行。在实际编程竞赛或开发中，这样的高精度库是解决复杂数学问题的基础，尤其是在需要精确计算的场景下。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值