C++基础与深度解析 || 长整数加法

最新推荐文章于 2023-05-21 22:38:41 发布
最新推荐文章于 2023-05-21 22:38:41 发布
阅读量930 收藏 3
点赞数 2
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36291615/article/details/126724506
版权

长整数加法

题目要求:

一个文件中包含两行数字序列，每行数字序列表示一个十进制长整数（只包含0~9与符号位，如果存在符号位，那么只能处于开头位置)。你的程序应当接收一个输入参数，表示该文件，程序读取这两个序列并求二者之和，将结果输入到屏幕上。

需要注意的是，由于序列可能比较长，因此其对应的数值可能无法使用一个内建数据类型来保存。需要使用一个数组（或vector)来保存每一位的数值。

注意事项：

  1. 整数前面可能包含表示正数的’+'符号。你的程序应当允许这种输入，但输出结果中不应该包含该符号。
  2. 注意如果两个数的符号位不同，那么实际上实现的应当是减法。
  3. 从数学上来说，一个十进制数前面如果加0不会影响该数的值，比如 123 与 0123 表示的是相同的值。你的程序在读取数据时应当能够处理这种情况，但输出结果时不应该包含前面位置的0.

扩展一：

程序可以再接收一个表示进制的参数，以实现不同进制下的长整数加法，比如:

Project1 InputFile 8

实现的就是两个8进制长整数想加。第二个如果大于10，那么就可以使用字母来表示相应的值，比如使用 a 或 A 来表示十进制的10，使用 b 或 B 来表示十进制的11，依此类推。

注意事项：

  1. 进制最多支持到36， 使用0 ~ 9，a ~ z（或A~Z)共36个字符表示。
  2. 如果用户输入的第二个参数不是一个合法的值，那么程序应当返回相应的错误码。
  3. 如果用户输入的第二个参数是一个合法的值，还需要判断输入文件中的两个数是否合法。比如对于8进制来说：93不是一个合法的值，因为9不是一个有效位。
  4. 程序的输出结果进制应当与输入数值的进制相同。

扩展二：

在扩展一的基础上再增加一个参数，表示输出的进制。比如：

Project1 InputFile 8 3

表示计算两个8进制长整数相加，结果以3进制的形式输出。

代码实现：

#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<stdlib.h>
#include<algorithm>

using namespace std;

// 读取文件input.txt中数据
vector<string> Read_txt(const string& path)
{
	ifstream fin;
	vector<string> data;
	fin.open(path, ios::in);
	if (!fin.is_open()) {
		cout << " 无法打开该文件！" << endl;
		exit(0);
	}

	string buff;
	while (getline(fin, buff)) {
		data.push_back(buff);
	}
	fin.close();
	return data;
}

//删除其数字序列前的符号和无效零，返回两行数字序列的正负。
string JudgeAndDel_sym(string& str1, string& str2) {
	string dsym;
	if ((str1[0] == '-') && (str2[0] == '-')) {
		dsym = "--";
		str1.erase(0, 1); //删除字符串1前的 '-' 号
		str2.erase(0, 1); //删除字符串1前的 '-' 号
		while (str1[0] == '0') //删除有效数字前的0
			str1.erase(0, 1);
		while (str2[0] == '0')
			str2.erase(0, 1);

	}
	else if ((str1[0] == '-') && (str2[0] != '-')) {
		dsym = "-+";
		str1.erase(0, 1);
		if (str2[0] == '+')
			str2.erase(0, 1);
		while (str1[0] == '0')
			str1.erase(0, 1);
		while (str2[0] == '0')
			str2.erase(0, 1);
	}
	else if ((str1[0] != '-') && (str2[0] == '-')) {
		dsym = "+-";
		str2.erase(0, 1);
		if (str1[0] == '+')
			str1.erase(0, 1);
		while (str1[0] == '0')
			str1.erase(0, 1);
		while (str2[0] == '0')
			str2.erase(0, 1);
	}
	else {
		dsym = "++";
		if (str1[0] == '+')
			str1.erase(0, 1);
		if (str2[0] == '+')
			str2.erase(0, 1);
		while (str1[0] == '0')
			str1.erase(0, 1);
		while (str2[0] == '0')
			str2.erase(0, 1);
	}
	return dsym;
}



//两数字序列符号相同的加法运算
string add_same_sym(const string& str1, const string& str2) {
	if (str1.empty() && str2.empty())
		return "0";
	if (str1.empty())
		return str2;
	if (str2.empty())
		return str1;
	int n1 = str1.size() - 1;
	int n2 = str2.size() - 1;
	int cf = 0;  //进位标志位
	string ret;  //运算结果
	while (n1 >= 0 || n2 >= 0) {
		int num1 = 0; //保存字符串1中的单个数字
		int num2 = 0; //保存字符串2中的单个数字
		if (n1 >= 0)
			num1 = str1[n1--] - '0';
		if (n2 >= 0)
			num2 = str2[n2--] - '0';
		int sum = num1 + num2 + cf;
		cf = sum / 10;
		sum %= 10;
		ret.push_back(sum + '0');
	}
	if (cf > 0)  // 最后一次是否有进位
		ret.push_back('1');
	reverse(ret.begin(), ret.end());  //翻转字符串
	return ret;
}

//两数字序列符号相异的加法运算（实则运用减法） 
string add_diff_sym(const string& str1, const string& str2) {
	if (str1.empty() && str2.empty())
		return "0";
	if (str1.empty())
		return str2;
	if (str2.empty())
		return str1;
	int n1 = str1.size() - 1;
	int n2 = str2.size() - 1;
	int cf = 0;
	string ret;
	while (n1 >= 0 || n2 >= 0) {
		int num1 = 0; //保存字符串1中的单个数字
		int num2 = 0; //保存字符串2中的单个数字
		if (n1 >= 0)
			num1 = str1[n1--] - '0';
		if (n2 >= 0)
			num2 = str2[n2--] - '0';
		int sum = num1 - num2 - cf;
		if (sum < 0) {  // 需要进位（借位）
			cf = 1;
			sum += 10;
		}
		else
			cf = 0;
		ret.push_back(sum + '0');
	}
	reverse(ret.begin(), ret.end());
	return ret;
}



//char 转 int 
int Atoi(char c)
{
	int num = 0;
	if (c >= '0' && c <= '9') {
		num = c - '0';
	}
	else if (c >= 'a' && c <= 'z') {
		num = 10 + (c - 'a');
	}
	else if (c >= 'A' && c <= 'Z') {
		num = 10 + (c - 'A');
	}
	else
		num = 37;  // radix最大为36，所以36以上的数字都为不合法数字 
	return num;
}


//int 转 char
char Itoa(int num)
{
	char c = 0;
	if (num >= 0 && num <= 9) {
		c = num + '0';
	}
	if (num >= 10 && num <= 35) {
		c = (num - 10) + 'a';
	}
	return c;
}

//输入进制数（argv[2]、argv[3])的有效性检查 
int check_base(const string& base) {
	if (base.size() > 1) {
		cout << "输入进制数" << base << " 不合法。 { 请输入2~9 或 a~z（表示 10~35 进制） 或 0 (表示 36 进制) }" << endl;
		exit(0);
	}
	int radix = 0;
	if (base[0] == '0')
		radix = 36;
	else if (base[0] >= '2' && base[0] <= '9') {
		radix = base[0] - '0';
	}
	else if (base[0] >= 'a' && base[0] <= 'z') {
		radix = 10 + (base[0] - 'a');
	}
	else if (base[0] >= 'A' && base[0] <= 'Z') {
		radix = 10 + (base[0] - 'A');
	}
	else {
		cout << "输入进制数 " << base << " 不合法。{ 请输入2~9 或 a~z（表示 10~35 进制） 或 0 (表示 36 进制) }" << endl;
		exit(0);
	}
	return radix;
}

//检查两个数字序列的合法性
void check_data(const string& str1, const string& str2, int radix) {
	for (auto c : str1) {
		int num = Atoi(c);
		if (num >= radix) {
			cout << "第一行数字序列中含有的字符 " << c << " 在 " << radix << " 进制中不是一个有效数字。" << endl;
			exit(0);
		}
	}
	for (auto c : str2) {
		int num = Atoi(c);
		if (num >= radix) {
			cout << "第二行数字序列中含有的字符 " << c << " 在 " << radix << " 进制中不是一个有效数字。" << endl;
			exit(0);
		}
	}
	return;
}



// 实现字符串中数字序列的乘法运算
string multiply(string ret, int radix) {
	int cf = 0; //保存进位
	for (int i = ret.size() - 1; i >= 0; i--) {
		int current = radix * (ret[i] - '0') + cf;
		ret[i] = current % 10 + '0';
		cf = current / 10;
	}
	if (cf != 0)
		ret = to_string(cf) + ret;
	return ret;
}

// 实现字符串中数字序列的加法运算
string Addt(string str, int x)
{
	int cf = x;
	for (int i = str.size() - 1; i >= 0; i--)
	{
		int current = (str[i] - '0') + cf;
		str[i] = current % 10 + '0';
		cf = current / 10;
	}
	if (cf != 0)
	{
		str = to_string(cf) + str;
	}
	return str;
}

// 其他进制转十进制
string BasetoTen_conversion(const string& str, int radix) {
	string ret = "0";
	for (int i = 0; i < str.size(); ++i) {
		ret = Addt(multiply(ret, radix), Atoi(str[i]));
	}
	return ret;
}



//实现字符串中数字序列的除法运算
string Divide(string str, int obj_radix, string& ret)//除法
{
	int remain = 0;
	for (int i = 0; i < str.size(); i++)
	{
		int current = remain * 10 + str[i] - '0';
		str[i] = current / obj_radix + '0';
		remain = current % obj_radix;
	}
	int pos = 0;
	ret.push_back(Itoa(remain));
	while (str[pos] == '0')
	{
		pos++;
	}
	return str.substr(pos);
}

//十进制转其他进制
string TentoBase_conversion(string str, int obj_radix) {
	if (obj_radix == 10)
		return str;
	string ret = "";
	string flag = "";
	if (str[0] == '-') {
		str.erase(0, 1);
		flag = "-";
	}
	while (str.size() != 0) {
		str = Divide(str, obj_radix, ret);
	}
	reverse(ret.begin(), ret.end());
	return flag + ret;
}

string Str_add(string& str1, string& str2, int radix) {
	string dsym = JudgeAndDel_sym(str1, str2);
	check_data(str1, str2, radix);
	if (radix != 10) {
		str1 = BasetoTen_conversion(str1, radix);
		str2 = BasetoTen_conversion(str2, radix);
	}
	if (dsym == "--") {
		string ret = add_same_sym(str1, str2);
		return '-' + ret;
	}
	else if (dsym == "-+") {
		if (str1.size() > str2.size()) {
			string ret = add_diff_sym(str1, str2);
			while (ret[0] == '0' && ret.size() > 1)
				ret.erase(0, 1);
			return '-' + ret;
		}
		else if (str1.size() < str2.size()) {
			string ret = add_diff_sym(str2, str1);
			while (ret[0] == '0' && ret.size() > 1)
				ret.erase(0, 1);
			return ret;
		}
		else {
			if (str1 > str2) {
				string ret = add_diff_sym(str1, str2);
				while (ret[0] == '0' && ret.size() > 1)
					ret.erase(0, 1);
				return '-' + ret;
			}
			else {
				string ret = add_diff_sym(str2, str1);
				while (ret[0] == '0' && ret.size() > 1)
					ret.erase(0, 1);
				return ret;
			}
		}

	}

	else if (dsym == "+-") {
		if (str2.size() > str1.size()) {
			string ret = add_diff_sym(str2, str1);
			while (ret[0] == '0' && ret.size() > 1)
				ret.erase(0, 1);
			return '-' + ret;
		}
		else if (str2.size() < str1.size()) {
			string ret = add_diff_sym(str1, str2);
			while (ret[0] == '0' && ret.size() > 1)
				ret.erase(0, 1);
			return ret;
		}
		else {
			if (str2 > str1) {
				string ret = add_diff_sym(str2, str1);
				while (ret[0] == '0' && ret.size() > 1)
					ret.erase(0, 1);
				return '-' + ret;
			}
			else {
				string ret = add_diff_sym(str1, str2);
				while (ret[0] == '0' && ret.size() > 1)
					ret.erase(0, 1);
				return ret;
			}
		}

	}
	else {
		string ret = add_same_sym(str1, str2);
		return ret;
	}
}
int main(int argc, char* argv[])
{
	vector<string> data = Read_txt(argv[1]); //读取文件数据 
	int radix = argc >= 3 ? check_base(argv[2]) : 10; //对输入的文件进制数进行合法性检测
	int obj_radix = argc == 4 ? check_base(argv[3]) : radix;  //对输出的进制数进行合法性检测
	cout << "文件内容：" << endl;
	for (auto a : data)
		cout << a << endl;
	cout << "十进制相加结果：" << endl;
	string ret = Str_add(data[0], data[1], radix); // 实现文本的两个数字序列相加（十进制）
	cout << ret << endl;
	cout << "\n预期" << obj_radix << "进制结果：" << endl;
	string obj_ret = TentoBase_conversion(ret, obj_radix);  //将十进制结果转换为所要求的进制对应的结果
	cout << obj_ret << endl;
	return 0;

}
Wkingbai
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
超长正整数的加法C++
编程小鹏的博客
12-11 1096
2.以较短的超长整数为基准，从低位到高位，对应位转换成数字后相加，再加上前一位相加的进位，得到的和模上10再转换为字符即为当前位，得到的和整除10即为当前位的进位。1.用字符串输入两个超长整数，分别存放在两个字符串中，每一位对应一个字符串中的字符。输出只有一行，是两个长整数的运算结果，从高到低依次输出各位数字。从键盘读入两个整数，要考虑输入高位可能为0的情况（如00083）。编写程序实现两个超长正整数（每个最长80位数字）的加法运算。4.将结果数组反序输出（去掉高位多余的0）。
长整数加减法运算
CHN_Zgq's Blog
11-27 2677
长整数加减法运算 【问题描述】 设计一个实现任意长的整数进行加法和减法运算的演示程序。 【基本要求】 利用双向循环链表实现长整数的存储，每个结点含一个整型变量。输入和输出形式：按中国对于长整数的表示习惯，每四位一组，组间用逗号隔开。 【测试数据】 (1)0；0；应输出“0”。 (2)-2345,6789；-7654,3211；应输出“-1,0000,0000”。 (3)-9999,9999；1,0000,0000,0000；应输出“9999,0000,0001” (4)1,0001,0001；-1,0001
【C++11新特性：18】—— C++11 long long超长整形详解
holly的专栏
02-10 1347
c++11
【C++学习第九讲】C++ 整型介绍
wzk4869的博客
05-21 5634
【C++学习第九讲】C++ 整型介绍
C++计算2个整数的和。这两个整数都在1到100之间。
2301_76393304的博客
02-03 2820
计算2个整数的和。这两个整数都在1到100之间。
小白初学：C++变量之数据类型
qq_39986282的博客
08-27 512
C++内置的数据类型分为两种：基本类型和复合类型 1. 命名规则 变量存在的意义：方便管理内存空间 变量创建的语法：数据类型 变量名 = 变量初始值 Int a =10; 关键字：系统预先保留的单词； 不要用关键字给变量或者常量起名称； 标识符命名规则： 1、 不能是关键字； 2、 字母、数字、下划线； 3、 第一个字符必须为字母或者下划线； 4、 区分字母大小写； 5、 见名知意； 2. 数据...
C++基础与深度解析--peoject2 长整数加法（csdn）————程序.pdf
12-01
在本项目"C++基础与深度解析--project2 长整数加法"中，我们主要探讨了如何在C++中实现对大整数的加法运算，这通常涉及到处理超过标准整数类型（如int，long等）所能表示的数值范围。下面将详细介绍这个项目中的关键...
某某学院课程-C++ 基础与深度解析
01-20
某某学院课程-C++ 基础与深度解析
作业长整数加法.zip
11-28
本作业"作业长整数加法.zip"关注的是如何利用C++元编程来实现编译时的长整数加法，特别是针对编译期数组的操作。以下将详细阐述涉及的知识点： 1. **C++元编程基础**： - 元编程分为运行时元编程和编译时元编程。...
长整数计算器的设计与实现C++
12-30
在本课程设计中，我们探讨的是“长整数计算器”的设计与实现，主要采用C++编程语言，并结合了前端数据可视化技术。这个项目的核心目标是创建一个能够处理超过普通整型范围的大整数运算的计算器。以下是这个项目涉及...
用C++实现长整数的输入输出
05-30
输入两个长整数，对其进行加，减，乘，除的运算功能，并输出结果的程序
C++堆栈实现超长整数加法
06-07
本篇将深入探讨如何使用堆栈来实现超长整数的加法。 堆栈是一种后进先出（LIFO，Last In First Out）的数据结构，它允许在栈顶进行插入（push）和删除（pop）操作。在超长整数加法中，我们可以将每个数字位看作一个...
有链表实现长整数的加法
小蝌蚪的Blog
04-15 5096
课程题目：          设计一个程序实现两个任意长的整数求和运算。要求：          利用双向循环链表实现长整数的存储，每个节点含有一个整型变量。 输入形式按照中国对于长整数的表示习惯，没四位一组，组间用逗号隔开。思路：         为了达到上面的要求，我使用链表将长整数按照四位一组进行输入（每组用一个int表示就可以了）。然后对链表中的数字进行加法运算。   
编写程序实现两个超长正整数(每个最长80位数字)的加法运算。_万字长文！位运算面试看这篇就够了！...
weixin_39756696的博客
12-09 1867
祝大家五一快乐。今天是小浩算法 “365刷题计划” 位运算超长 - 整合篇。估计五一期间，大家也没有什么心思好好做题。所以我就把之前已经出过的位运算系列，进行了一次整合。整合工作很漫长，我对其中的所有图片都重新进行了绘制，同时也砍去了一些不适的内容。以下是最终整合后的目录，列出的全部内容都应该进行掌握：位运算基础位运算的奇淫技巧两数之和二的幂一的个数只出现一次的数字Ⅰ只出现一次的数字Ⅱ0...
C++中整型的尺寸区别
weixin_45067855的博客
08-10 863
整型（integral type）用于表示不同尺寸的整数。 1. C++语言规定： 一个int至少和一个short一样大； 一个long至少和一个int一样大； 一个long long至少和一个long一样大。 2. 整型分为： 基本整型int、短整型short、长整型long、long long（长整型，在C++11中新定义） 3. 数据储存单位： 位、字节、字 1字 = 8位 1字节 =...
c++中 int, long long, double 等数据类型的长度及范围整理
热门推荐
还我笑颜
11-23 10万+
先附上一个比较直观的表，长度表示字节:  byte: 字节  bit: 位 1. 短整型short：     所占内存大小：2byte=16bit；     所能表示范围：-32768~32767；(即-2^15~2^15-1)   2. 整型int：     所占内存大小：4byte=32bit；     所能表示范围：-2147483648~2147483647；(即-2^...
关于长整数（很长很长）的加法————几种思路
一只彩乌鸦
08-08 4045
长整数的加法 思路一 #include<stdio.h> #include<string.h> #define MAX_N 1000 int a[MAX_N]; int b[MAX_N]; char astr[MAX_N+2]; char bstr[MAX_N+2]; int main(void) { { //库函数memeset将地址a开始的sizeof(an...
【C++】深蓝学院课程：C++基础与深度解析 - 课程知识点目录
墨门
12-31 2117
Keywords: lambda lambda表达式 【C++】深蓝学院C++课程：C++基础与深度解析 - 课程知识点目录；
长整数加法运算
最新发布
05-30
长整数加法运算可以通过模拟手工计算的方式来实现。具体步骤如下： 1. 将两个长整数对齐，即在短的数前面补 0，使得两个数的位数相等。 2. 从低位开始，依次将两个数对应位上的数字相加，记得把前一位上的进位加上。 3. 如果相加的结果超过了 10，就要向高位进位。 4. 直到两个数的所有位都相加完毕，最终的结果就是两个数的和。 下面是一个 Python 代码实现长整数加法运算的例子： ```Python def addStrings(num1: str, num2: str) -> str: res = [] carry = 0 i = len(num1) - 1 j = len(num2) - 1 while i >= 0 or j >= 0: n1 = int(num1[i]) if i >= 0 else 0 n2 = int(num2[j]) if j >= 0 else 0 temp_sum = n1 + n2 + carry carry = temp_sum // 10 res.append(str(temp_sum % 10)) i -= 1 j -= 1 if carry: res.append(str(carry)) return ''.join(res[::-1]) ``` 其中，num1 和 num2 分别表示两个长整数，返回值是它们的和。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值