ACMDay13大整数加减乘除

最新推荐文章于 2022-04-10 15:45:26 发布
最新推荐文章于 2022-04-10 15:45:26 发布
阅读量308 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MaplePlane/article/details/95761741
版权

大整数加减乘除法还没搞定（本蒟蒻搞了一上午）233

/*
大整数加减乘除的参数均为正若需要用到负可在主函数中进行变换操作
*/


/*
大整数加减乘除的参数均为正若需要用到负可在主函数中进行变换操作
*/


#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
string s1, s2, s3;
int file = 0;
int P;
void Plus(string s4, string s5)
{
	s3.clear();
	int up = 0;
	int a, b, c;
	int i;
	for (i = 1; i <= min(s4.size(), s5.size()); i++)
	{
		a = (int)(s4[s4.size() - i] - '0');
		b = (int)(s5[s5.size() - i] - '0');
		c = a + b + up;
		up = c / 10;
		c = c % 10;
		s3.insert(s3.begin(), (char)(c + '0'));
	}
	if (up != 0)
	{
		if (s4.size() < s5.size())
			for (i; i <= s5.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				if (a + up < 10)
				{
					s5[s5.size() - i] = (char)((a + up) % 10 + '0');
					break;
				}
				s5[s5.size() - i] = (char)((a + up) % 10 + '0');
				up = (a + up) / 10;
				if (i == s5.size())
				{
					s5.insert(s5.begin(), (char)(up + '0'));
					break;
				}
			}
		else if (s4.size() > s5.size())
		{
			for (i; i <= s4.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				if (a + up < 10)
				{
					s4[s4.size() - i] = (char)((a + up) % 10 + '0');
					break;
				}
				s4[s4.size() - i] = (char)((a + up) % 10 + '0');
				up = (a + up) / 10;
				if (i == s4.size())
				{
					s4.insert(s4.begin(), (char)(up + '0'));
					break;
				}
			}
		}
		else
		{
			s4.insert(s4.begin(), (char)(up + '0'));
		}
	}
	if (s4.size() >= s5.size())
	{
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
	}
	if (s4.size() < s5.size())
	{
		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
	}
}

void Reduce(string s4, string s5)
{
	s3.clear();
	int a, b, c;
	int down = 0;
	if (s4.size() > s5.size())
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			b = (int)(s5[s5.size() - i] - '0');
			if (a < b)
			{
				if ((int)(s4[s4.size() - i - 1] - '0') > 0)
				{
					s4[s4.size() - i - 1] = (char)((int)(s4[s4.size() - i - 1] - '0') - 1 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
				else
				{
					int j = s4.size() - i - 2;
					for (j; j >= 0; j--)
					{
						if ((int)(s4[j] - '0') > 0)
						{
							s4[j] = (char)((int)(s4[j] - '0') - 1 + '0');
							break;
						}
					}
					for (j = j + 1; j <= s4.size() - i - 1; j++)
						s4[j] = char(9 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			else
			{
				c = a - b;
				s3.insert(s3.begin(), (char)(c + '0'));
			}
		}
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
		string s6;
		for (int i = 0; i < s3.size(); i++)
			s6 = s6 + '0';
		if (s3.size() > 1 && s3 != s6)
		{
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin() + 1, s3.begin() + m);
		}
		else if (s3[0] == '0')
			s3 = "0";
	}
	else if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			b = (int)(s4[s4.size() - i] - '0');
			if (a < b)
			{
				if ((int)(s5[s5.size() - i - 1] - '0') > 0)
				{
					s5[s5.size() - i - 1] = (char)((int)(s5[s5.size() - i - 1] - '0') - 1 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
				else
				{
					int j = s5.size() - i - 2;
					for (j; j >= 0; j--)
					{
						if ((int)(s5[j] - '0') > 0)
						{
							s5[j] = (char)((int)(s5[j] - '0') - 1 + '0');
							break;
						}
					}
					for (j = j + 1; j <= s5.size() - i - 1; j++)
						s5[j] = char(9 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			else
			{
				c = a - b;
				s3.insert(s3.begin(), (char)(c + '0'));
			}
		}

		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
		s3.insert(s3.begin(), '-');
		string s6;
		for (int i = 0; i < s3.size() - 1; i++)
			s6 = s6 + '0';
		s6.insert(s6.begin(), '-');
		if (s3.size() > 2 && s3 != s6)
		{
			int m;
			for (m = 1; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 1)
				s3.erase(s3.begin() + 1, s3.begin() + m);
		}
		else if (s3[1] == '0')
			s3 = "0";
	}
	else if (s4.size() == s5.size())
	{
		if (s4 > s5)
		{
			for (int i = 1; i <= s5.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				b = (int)(s5[s5.size() - i] - '0');
				if (a < b)
				{
					if ((int)(s4[s4.size() - i - 1] - '0') > 0)
					{
						s4[s4.size() - i - 1] = (char)((int)(s4[s4.size() - i - 1] - '0') - 1 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
					else
					{
						int j = s4.size() - i - 2;
						for (j; j >= 0; j--)
						{
							if ((int)(s4[j] - '0') > 0)
							{
								s4[j] = (char)((int)(s4[j] - '0') - 1 + '0');
								break;
							}
						}
						for (j = j + 1; j <= s4.size() - i - 1; j++)
							s4[j] = char(9 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
				}
				else
				{
					c = a - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			string s6;
			for (int i = 0; i < s3.size(); i++)
				s6 = s6 + '0';
			if (s3.size() > 1 && s3 != s6)
			{
				int m;
				for (m = 0; m < s3.size(); m++)
				{
					if (s3[m] != '0')
						break;
				}
				if (m > 0)
					s3.erase(s3.begin() + 1, s3.begin() + m);
			}
			else if (s3[0] == '0')
				s3 = "0";
		}
		if (s4 < s5)
		{
			for (int i = 1; i <= s4.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				b = (int)(s4[s4.size() - i] - '0');
				if (a < b)
				{
					if ((int)(s5[s5.size() - i - 1] - '0') > 0)
					{
						s5[s5.size() - i - 1] = (char)((int)(s5[s5.size() - i - 1] - '0') - 1 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
					else
					{
						int j = s5.size() - i - 2;
						for (j; j >= 0; j--)
						{
							if ((int)(s5[j] - '0') > 0)
							{
								s5[j] = (char)((int)(s5[j] - '0') - 1 + '0');
								break;
							}
						}
						for (j = j + 1; j <= s5.size() - i - 1; j++)
							s5[j] = char(9 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
				}
				else
				{
					c = a - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			s3.insert(s3.begin(), '-');
			string s6;
			for (int i = 0; i < s3.size() - 1; i++)
				s6 = s6 + '0';
			s6.insert(s6.begin(), '-');
			if (s3.size() > 2 && s3 != s6)
			{
				int m;
				for (m = 1; m < s3.size(); m++)
				{
					if (s3[m] != '0')
						break;
				}
				if (m > 1)
					s3.erase(s3.begin() + 1, s3.begin() + m);
			}
			else if (s3[1] == '0')
				s3 = "0";
		}
		else
			s3 = "0";
	}
}

void Multiplication(string s4, string s5)
{
	if (s4[0] == '-')
	{
		s1.erase(s1.begin(), s1.begin() + 1);
		file++;
	}
	if (s5[0] == '-')
	{
		s2.erase(s2.begin(), s2.begin() + 1);
		file++;
	}
	s3.clear();
	int a, b, c, d;
	int up = 0;
	s3 = "0";
	if (s4[0] == '0' || s5[0] == '0')
		return;
	string s6;
	if (s4.size() >= s5.size())
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			for (int j = 1; j <= s4.size(); j++)
			{
				b = (int)(s4[s4.size() - j] - '0');
				c = a * b + up;
				s6.insert(s6.begin(), (char)(c % 10 + '0'));
				up = c / 10;
			}
			if (up != 0) {
				s6.insert(s6.begin(), (char)(up + '0'));
				up = 0;
			}
			for (int j = i - 1; j > 0; j--)
			{
				s6 = s6 + '0';
			}
			Plus(s3, s6);
			s6.clear();
		}
	}
	if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			for (int j = 1; j <= s5.size(); j++)
			{
				b = (int)(s5[s5.size() - j] - '0');
				c = a * b + up;
				s6.insert(s6.begin(), (char)(c % 10 + '0'));
				up = c / 10;
			}
			if (up != 0) {
				s6.insert(s6.begin(), (char)(up + '0'));
				up = 0;
			}
			for (int j = i - 1; j > 0; j--)
			{
				s6 = s6 + '0';
			}
			Plus(s3, s6);
			s6.clear();
		}
	}
	if (file == 1)
		s3.insert(s3.begin(), '-');
}

next_permutation()就是一个求一个排序的下一个排列的函数，可以遍历全排列

与之完全相反的函数还有prev_permutation（就是一个求一个排序的上一个排列的函数）
（本蒟蒻今天写火星人这道题一直以为是进制后来看到这个之后才发现是全排列）

ios::sync_with_stdio(false);关闭缓冲流能大大节省时间

改进版减法：

void Now_Reduce(string s4, string s5)
{
	s3.clear();
	int a, b, c;
	int down = 0;
	if (s4.size() > s5.size())//大于零的情况
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			b = (int)(s5[s5.size() - i] - '0');
			if (a > b)
			{
				c = a - b+down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = 0;
			}
			else if (a == b)
			{
				if (down < 0)
				{
					c = 9;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
				else
				{
					s3.insert(s3.begin(), '0');
				}
			}
			else if (a < b)
			{
				c = a - b + 10 + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = -1;
			}
		}
		if (down != 0)
		{
			for (int i = s4.size() - s5.size()-1; i >= 0; i--)
			{
				if (s4[i] > '0')
				{
					s4[i] = (char)(s4[i] - 1);
					down = 0;
					break;
				}
				else
				{
					s4[i] = '9';
				}
			}
		}
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
		int m;
		for (m = 0; m < s3.size(); m++)
		{
			if (s3[m] != '0')
				break;
		}
		if (m > 0)
			s3.erase(s3.begin(), s3.begin() + m);
	}
	if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			b = (int)(s4[s4.size() - i] - '0');
			if (a > b)
			{
				c = a - b + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = 0;
			}
			else if (a == b)
			{
				if (down < 0)
				{
					c = 9;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
				else
				{
					s3.insert(s3.begin(), '0');
				}
			}
			else if (a < b)
			{
				c = a - b + 10 + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = -1;
			}
		}
		if (down != 0)
		{
			for (int i = s5.size() - s4.size() - 1; i >= 0; i--)
			{
				if (s5[i] > '0')
				{
					s5[i] = (char)(s5[i] - 1);
					down = 0;
					break;
				}
				else
				{
					s5[i] = '9';
				}
			}
		}
		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
		int m;
		for (m = 0; m < s3.size(); m++)
		{
			if (s3[m] != '0')
				break;
		}
		if (m > 0)
			s3.erase(s3.begin(), s3.begin() + m);
		s3.insert(s3.begin(), '-');
	}
	if (s4.size() == s5.size())
	{
		if (s4 > s5)
		{
			for (int i = 1; i <= s5.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				b = (int)(s5[s5.size() - i] - '0');
				if (a > b)
				{
					c = a - b + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = 0;
				}
				else if (a == b)
				{
					if (down < 0)
					{
						c = 9;
						s3.insert(s3.begin(), (char)(c + '0'));
						down = -1;
					}
					else
					{
						s3.insert(s3.begin(), '0');
					}
				}
				else if (a < b)
				{
					c = a - b + 10 + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
			}
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin(), s3.begin() + m);
		}
		if (s4 == s5)
			s3 = "0";
		if (s4 < s5)
		{
			for (int i = 1; i <= s4.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				b = (int)(s4[s4.size() - i] - '0');
				if (a > b)
				{
					c = a - b + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = 0;
				}
				else if (a == b)
				{
					if (down < 0)
					{
						c = 9;
						s3.insert(s3.begin(), (char)(c + '0'));
						down = -1;
					}
					else
					{
						s3.insert(s3.begin(), '0');
					}
				}
				else if (a < b)
				{
					c = a - b + 10 + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
			}
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin(), s3.begin() + m);
			s3.insert(s3.begin(), '-');
		}
	}
}

完整的大整数加减乘除：

/*
大整数加减乘除的参数均为正若需要用到负可在主函数中进行变换操作
*/


#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
string s1, s2, s3;
int file = 0;

void Plus(string s4, string s5)
{
	s3.clear();
	int up = 0;
	int a, b, c;
	int i;
	for (i = 1; i <= min(s4.size(), s5.size()); i++)
	{
		a = (int)(s4[s4.size() - i] - '0');
		b = (int)(s5[s5.size() - i] - '0');
		c = a + b + up;
		up = c / 10;
		c = c % 10;
		s3.insert(s3.begin(), (char)(c + '0'));
	}
	if (up != 0)
	{
		if (s4.size() < s5.size())
			for (i; i <= s5.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				if (a + up < 10)
				{
					s5[s5.size() - i] = (char)((a + up) % 10 + '0');
					break;
				}
				s5[s5.size() - i] = (char)((a + up) % 10 + '0');
				up = (a + up) / 10;
				if (i == s5.size())
				{
					s5.insert(s5.begin(), (char)(up + '0'));
					break;
				}
			}
		else if (s4.size() > s5.size())
		{
			for (i; i <= s4.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				if (a + up < 10)
				{
					s4[s4.size() - i] = (char)((a + up) % 10 + '0');
					break;
				}
				s4[s4.size() - i] = (char)((a + up) % 10 + '0');
				up = (a + up) / 10;
				if (i == s4.size())
				{
					s4.insert(s4.begin(), (char)(up + '0'));
					break;
				}
			}
		}
		else
		{
			s4.insert(s4.begin(), (char)(up + '0'));
		}
	}
	if (s4.size() >= s5.size())
	{
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
	}
	if (s4.size() < s5.size())
	{
		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
	}
}

void Reduce(string s4, string s5)
{
	s3.clear();
	int a, b, c;
	int down = 0;
	if (s4.size() > s5.size())
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			b = (int)(s5[s5.size() - i] - '0');
			if (a < b)
			{
				if ((int)(s4[s4.size() - i - 1] - '0') > 0)
				{
					s4[s4.size() - i - 1] = (char)((int)(s4[s4.size() - i - 1] - '0') - 1 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
				else
				{
					int j = s4.size() - i - 2;
					for (j; j >= 0; j--)
					{
						if ((int)(s4[j] - '0') > 0)
						{
							s4[j] = (char)((int)(s4[j] - '0') - 1 + '0');
							break;
						}
					}
					for (j = j + 1; j <= s4.size() - i - 1; j++)
						s4[j] = char(9 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			else
			{
				c = a - b;
				s3.insert(s3.begin(), (char)(c + '0'));
			}
		}
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
		string s6;
		for (int i = 0; i < s3.size(); i++)
			s6 = s6 + '0';
		if (s3.size() > 1 && s3 != s6)
		{
			int m;
			for (m = 1; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 1)
				s3.erase(s3.begin() + 1, s3.begin() + m);
		}
		else if (s3[0] == '0')
			s3 = "0";
	}
	else if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			b = (int)(s4[s4.size() - i] - '0');
			if (a < b)
			{
				if ((int)(s5[s5.size() - i - 1] - '0') > 0)
				{
					s5[s5.size() - i - 1] = (char)((int)(s5[s5.size() - i - 1] - '0') - 1 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
				else
				{
					int j = s5.size() - i - 2;
					for (j; j >= 0; j--)
					{
						if ((int)(s5[j] - '0') > 0)
						{
							s5[j] = (char)((int)(s5[j] - '0') - 1 + '0');
							break;
						}
					}
					for (j = j + 1; j <= s5.size() - i - 1; j++)
						s5[j] = char(9 + '0');
					c = a + 10 - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			else
			{
				c = a - b;
				s3.insert(s3.begin(), (char)(c + '0'));
			}
		}

		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
		s3.insert(s3.begin(), '-');
		string s6;
		for (int i = 0; i < s3.size() - 1; i++)
			s6 = s6 + '0';
		s6.insert(s6.begin(), '-');
		if (s3.size() > 2 && s3 != s6)
		{
			int m;
			for (m = 1; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 1)
				s3.erase(s3.begin() + 1, s3.begin() + m);
		}
		else if (s3[1] == '0')
			s3 = "0";
	}
	else if (s4.size() == s5.size())
	{
		if (s4 > s5)
		{
			for (int i = 1; i <= s5.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				b = (int)(s5[s5.size() - i] - '0');
				if (a < b)
				{
					if ((int)(s4[s4.size() - i - 1] - '0') > 0)
					{
						s4[s4.size() - i - 1] = (char)((int)(s4[s4.size() - i - 1] - '0') - 1 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
					else
					{
						int j = s4.size() - i - 2;
						for (j; j >= 0; j--)
						{
							if ((int)(s4[j] - '0') > 0)
							{
								s4[j] = (char)((int)(s4[j] - '0') - 1 + '0');
								break;
							}
						}
						for (j = j + 1; j <= s4.size() - i - 1; j++)
							s4[j] = char(9 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
				}
				else
				{
					c = a - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			string s6;
			for (int i = 0; i < s3.size(); i++)
				s6 = s6 + '0';
			if (s3.size() > 1 && s3 != s6)
			{
				int m;
				for (m = 1; m < s3.size(); m++)
				{
					if (s3[m] != '0')
						break;
				}
				if (m > 1)
					s3.erase(s3.begin() + 1, s3.begin() + m);
			}
			else if (s3[0] == '0')
				s3 = "0";
		}
		if (s4 < s5)
		{
			for (int i = 1; i <= s4.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				b = (int)(s4[s4.size() - i] - '0');
				if (a < b)
				{
					if ((int)(s5[s5.size() - i - 1] - '0') > 0)
					{
						s5[s5.size() - i - 1] = (char)((int)(s5[s5.size() - i - 1] - '0') - 1 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
					else
					{
						int j = s5.size() - i - 2;
						for (j; j >= 0; j--)
						{
							if ((int)(s5[j] - '0') > 0)
							{
								s5[j] = (char)((int)(s5[j] - '0') - 1 + '0');
								break;
							}
						}
						for (j = j + 1; j <= s5.size() - i - 1; j++)
							s5[j] = char(9 + '0');
						c = a + 10 - b;
						s3.insert(s3.begin(), (char)(c + '0'));
					}
				}
				else
				{
					c = a - b;
					s3.insert(s3.begin(), (char)(c + '0'));
				}
			}
			s3.insert(s3.begin(), '-');
			string s6;
			for (int i = 0; i < s3.size() - 1; i++)
				s6 = s6 + '0';
			s6.insert(s6.begin(), '-');
			if (s3.size() > 2 && s3 != s6)
			{
				int m;
				for (m = 1; m < s3.size(); m++)
				{
					if (s3[m] != '0')
						break;
				}
				if (m > 1)
					s3.erase(s3.begin() + 1, s3.begin() + m);
			}
			else if (s3[1] == '0')
				s3 = "0";
		}
		else
			s3 = "0";
	}
}

void Now_Reduce(string s4, string s5)
{
	s3.clear();
	int a, b, c;
	int down = 0;
	if (s4.size() > s5.size())//大于零的情况
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			b = (int)(s5[s5.size() - i] - '0');
			if (a > b)
			{
				c = a - b + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = 0;
			}
			else if (a == b)
			{
				if (down < 0)
				{
					c = 9;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
				else
				{
					s3.insert(s3.begin(), '0');
				}
			}
			else if (a < b)
			{
				c = a - b + 10 + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = -1;
			}
		}
		if (down != 0)
		{
			for (int i = s4.size() - s5.size() - 1; i >= 0; i--)
			{
				if (s4[i] > '0')
				{
					s4[i] = (char)(s4[i] - 1);
					down = 0;
					break;
				}
				else
				{
					s4[i] = '9';
				}
			}
		}
		s4.erase(s4.end() - s5.size(), s4.end());
		s4 = s4 + s3;
		s3 = s4;
		int m;
		for (m = 0; m < s3.size(); m++)
		{
			if (s3[m] != '0')
				break;
		}
		if (m > 0)
			s3.erase(s3.begin(), s3.begin() + m);
	}
	if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			b = (int)(s4[s4.size() - i] - '0');
			if (a > b)
			{
				c = a - b + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = 0;
			}
			else if (a == b)
			{
				if (down < 0)
				{
					c = 9;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
				else
				{
					s3.insert(s3.begin(), '0');
				}
			}
			else if (a < b)
			{
				c = a - b + 10 + down;
				s3.insert(s3.begin(), (char)(c + '0'));
				down = -1;
			}
		}
		if (down != 0)
		{
			for (int i = s5.size() - s4.size() - 1; i >= 0; i--)
			{
				if (s5[i] > '0')
				{
					s5[i] = (char)(s5[i] - 1);
					down = 0;
					break;
				}
				else
				{
					s5[i] = '9';
				}
			}
		}
		s5.erase(s5.end() - s4.size(), s5.end());
		s5 = s5 + s3;
		s3 = s5;
		int m;
		for (m = 0; m < s3.size(); m++)
		{
			if (s3[m] != '0')
				break;
		}
		if (m > 0)
			s3.erase(s3.begin(), s3.begin() + m);
		s3.insert(s3.begin(), '-');
	}
	if (s4.size() == s5.size())
	{
		if (s4 > s5)
		{
			for (int i = 1; i <= s5.size(); i++)
			{
				a = (int)(s4[s4.size() - i] - '0');
				b = (int)(s5[s5.size() - i] - '0');
				if (a > b)
				{
					c = a - b + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = 0;
				}
				else if (a == b)
				{
					if (down < 0)
					{
						c = 9;
						s3.insert(s3.begin(), (char)(c + '0'));
						down = -1;
					}
					else
					{
						s3.insert(s3.begin(), '0');
					}
				}
				else if (a < b)
				{
					c = a - b + 10 + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
			}
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin(), s3.begin() + m);
		}
		if (s4 == s5)
			s3 = "0";
		if (s4 < s5)
		{
			for (int i = 1; i <= s4.size(); i++)
			{
				a = (int)(s5[s5.size() - i] - '0');
				b = (int)(s4[s4.size() - i] - '0');
				if (a > b)
				{
					c = a - b + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = 0;
				}
				else if (a == b)
				{
					if (down < 0)
					{
						c = 9;
						s3.insert(s3.begin(), (char)(c + '0'));
						down = -1;
					}
					else
					{
						s3.insert(s3.begin(), '0');
					}
				}
				else if (a < b)
				{
					c = a - b + 10 + down;
					s3.insert(s3.begin(), (char)(c + '0'));
					down = -1;
				}
			}
			int m;
			for (m = 0; m < s3.size(); m++)
			{
				if (s3[m] != '0')
					break;
			}
			if (m > 0)
				s3.erase(s3.begin(), s3.begin() + m);
			s3.insert(s3.begin(), '-');
		}
	}
}
void Multiplication(string s4, string s5)
{
	if (s4[0] == '-')
	{
		s1.erase(s1.begin(), s1.begin() + 1);
		file++;
	}
	if (s5[0] == '-')
	{
		s2.erase(s2.begin(), s2.begin() + 1);
		file++;
	}
	s3.clear();
	int a, b, c, d;
	int up = 0;
	s3 = "0";
	if (s4[0] == '0' || s5[0] == '0')
		return;
	string s6;
	if (s4.size() >= s5.size())
	{
		for (int i = 1; i <= s5.size(); i++)
		{
			a = (int)(s5[s5.size() - i] - '0');
			for (int j = 1; j <= s4.size(); j++)
			{
				b = (int)(s4[s4.size() - j] - '0');
				c = a * b + up;
				s6.insert(s6.begin(), (char)(c % 10 + '0'));
				up = c / 10;
			}
			if (up != 0) {
				s6.insert(s6.begin(), (char)(up + '0'));
				up = 0;
			}
			for (int j = i - 1; j > 0; j--)
			{
				s6 = s6 + '0';
			}
			Plus(s3, s6);
			s6.clear();
		}
	}
	if (s4.size() < s5.size())
	{
		for (int i = 1; i <= s4.size(); i++)
		{
			a = (int)(s4[s4.size() - i] - '0');
			for (int j = 1; j <= s5.size(); j++)
			{
				b = (int)(s5[s5.size() - j] - '0');
				c = a * b + up;
				s6.insert(s6.begin(), (char)(c % 10 + '0'));
				up = c / 10;
			}
			if (up != 0) {
				s6.insert(s6.begin(), (char)(up + '0'));
				up = 0;
			}
			for (int j = i - 1; j > 0; j--)
			{
				s6 = s6 + '0';
			}
			Plus(s3, s6);
			s6.clear();
		}
	}
	if (file == 1)
		s3.insert(s3.begin(), '-');
}
void Division(string s4, string s5)
{
	int lg;
	s3.clear();
	if (s4.size() < s5.size())
	{
		s3 = "0";
		return;
	}
	if (s4.size() == s5.size())
	{
		string q;
		int i;
		for (i = 1;; i++)
		{
			q = i + '0';
			Multiplication(s5, q);
			if (s3.size() > s4.size())
				break;
			else if (s3 > s4&&s3.size() == s4.size())
				break;
		}
		s3.clear();
		s3 = i - 1 + '0';
		return;
	}
	if (s4.size() > s5.size())
	{
		long long r = s4.size();
		string w;
		while (s4.size() >= s5.size())
		{
			string s7;
			for (int i = 0; i < s4.size(); i++)
				s7 = s7 + '0';
			if (s7 == s4)
				break;
			if (s4[0] == '0')
			{
				w = w + '0';
				s4.erase(s4.begin(), s4.begin() + 1);
				continue;
			}
			string s6(s4, 0, s5.size());
			if (s6 >= s5)
			{
				if (w.size() > 0)
				{
					for (int j = 0; j < lg-2; j++)
						w = w + '0';
				}
				int i = 0;
				string q;
				for (i = 1;; i++)
				{
					q = i + '0';
					Multiplication(s5, q);
					if (s3.size() > s6.size())
						break;
					else if (s3 > s6&&s3.size() == s6.size())
						break;
				}
				w = w + (char)(i - 1 + '0');
				Now_Reduce(s3, s5);
				Now_Reduce(s6, s3);
				if (s3 != "0")
					s4.replace(s4.begin(), s4.begin() + s5.size(), s3);
				else
					s4.erase(s4.begin(), s4.begin() + s5.size());
				lg = s5.size() - s3.size();
			}
			else if (s4.size() >= s5.size() + 1)
			{
				if (w.size() > 0)
				{
					for (int j = 0; j < lg-1; j++)
						w = w + '0';
				}
				string s6(s4, 0, s5.size() + 1);
				int i = 0;
				string q;
				for (i = 1;; i++)
				{
					q = i + '0';
					Multiplication(s5, q);
					if (s3.size() > s6.size())
						break;
					else if (s3 > s6&&s3.size() == s6.size())
						break;
				}
				w = w + (char)(i - 1 + '0');
				Now_Reduce(s3, s5);
				Now_Reduce(s6, s3);
				if (s3 != "0")
					s4.replace(s4.begin(), s4.begin() + s5.size(), s3);
				else
					s4.erase(s4.begin(), s4.begin() + s5.size() + 1);
				lg = s5.size() - s3.size();
			}
			else
				break;
		}
		if (s4.size() > 0)
		{
			for (int j = 0; j < s4.size(); j++)
				w = w + '0';
			s3 = w;
			return;
		}
		else
		{
			s3 = w;
			return;
		}
	}
}
MaplePlane
关注
ACM_大数运算 模板&&讲解&&各大oj题目
希望更好
05-01 9347
c语言版大数相加,大数相减，大数相乘，大数相除，大数阶乘，大数求模，大数幂，已通过各大OJ测试，有讲解有练习，有模板，有测试。。。。。
大整数运算之 大整数加法、减法、乘法
i_fuqiang的专栏
01-10 5258
其实大整数的问题都是在像我们打草稿的时候列竖式一样的，不要告诉我你不知道什么叫竖式~！其实我开始也不知道它叫这个名字； 所谓竖式，就是你打草稿算算术的方法，小学知识；比如你写 11+9： 11 +   9 ---------- 20 数A，B，求和，求差；数的长度不超过1000； 贴个代码，先输入一个数，代表数据的组数n，然后输入n组A B #inc
ACM大数相减
qq_22125259的博客
09-15 553
#include #include using namespace std; //定义MAX_SIZE #define MAX_SIZE 200 //定义两个char[]来存放输入的string类型 char charArrOne[MAX_SIZE+10]; char charArrTwo[MAX_SIZE+10]; int intArrOne[MAX_SIZE+10]; int intArrTw
ACM内部函数--数学问题--大数相减
戎码人生
04-08 616
在这里我们为了方便起见，所以只设置成了大数减小数，在调用此方法之前需要进行判断，如果是小数减大数，只需要在前面加一个负号就行了 #include #include #include #include using namespace std; const int N=1005; /** 大数相减 str1:减数数组 str2:被减数数组 result:结果数组 */ v
ACM内部函数--数学问题--大数相乘
戎码人生
04-08 1074
简述 这是2012年蓝桥杯全国软件大赛预赛（C++本科组）第6题，有图片可知是个简单的大数计算的问题。 题目描述     对于32位字长的机器，大约超过20亿，用int类型就无法表示了，我们可以选择int64类型，但无论怎样扩展，固定的整数类型总是有表达的极限！如果对超级大整数进行精确运算呢？一个简单的办法是：仅仅使用现有类型，但是把大整数的运算化解为若干小整数的运算，即所谓
大整数加减乘除指数运算课程设计数据结构（源代码+实验报告，期末成绩优秀）
02-03
非对称密码在加密和解密时，是把加密的数据当作一个大的正整数来处理，这样就涉及到大整数的加、减、乘、除和指数运算等，同时，还需要对大整数进行输出。请采用相应的数据结构实现大整数的加、减、乘、除和指数运算...
tnt_大整数加减乘除_
10-03
这个名为“tnt_大整数加减乘除_”的项目显然专注于实现大整数的基础运算，包括加法、减法、乘法和除法。下面将详细介绍这些知识点及其在实际应用中的重要性。 首先，大整数运算超越了常规的整型数据类型（如int或...
大整数加减乘除运算
12-10
以上就是大整数加减乘除运算的基本原理和实现方法，实际应用中还需结合特定的编程语言和库，例如Python的`decimal`模块、Java的`BigInteger`类等，它们提供了封装好的大整数操作接口，方便开发者使用。
C++实现的大整数加减乘除
02-28
C++实现的大整数加减乘法，已经测试了，并且在oj平台上测试通过
大数相减的算法
summerFanL的博客
08-01 768
#include #include #include using namespace std; string sub(string s,string str) { int temp; reverse(s.begin(),s.end()); reverse(str.begin(),str.end()); for (int i = 0; i < s.length(); i++) { te
acm作业重点分析2——大整数运算
FightingTsinghua的博客
04-10 535
1.BUCTOJ 2169 大整数加法 题目描述：计算两个大整数的和。大整数是指超过了c，c++表示范围的整数。 输入格式：输入包括两个大整数，每个大整数不超过100位，用空格或者换行隔开 输出格式：输出两个大整数的和 自己构造测试数据： 简单：1 1 有进位的情况：9 1 复杂：888 999 边界情况：一百个9 一百个1 重点分析：（大整数加法由于位数太多超出long和int范围所以只能用字符串来计算） 首先为了好计算个位数需对应下标0（就是最初的那两重循环） 然后将两者加和结果
大数(加、减、乘、除、低精度*大数)模板详解（C++）
氵青-风的博客
03-06 4965
一、大数四个基本操作 首先，我们来了解什么是大数，大数就是指用我们平常常见的高级语言（如：c 、c++）的基本数据类型的最大长度都装不下的数据，例如（1234567899876543211234567896542132165465），这些只能用字符数组（char[]）或者字符串（string）来处理，大数操作最基础的四个操作就是：大数加法、大数减法、大数乘法、大数除法。下面我来详细介绍下四个基
大数运算模板
蓦然回首
08-24 392
#include <iostream> #include <algorithm> #include <stdio.h> #include <string.h> using namespace std; #define MAX_DIGIT 500//大数运算：加法 int Add(int *a,int *b,int *&result) { if(a==NULL || b==NULL || re
大数四则运算
ACM_Colas_125的博客
10-20 368
#include&lt;iostream&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; using namespace std; #define M 1000000000000000 //大数加法 //将数字以字符串的形式传入add加法函数，在函数内部完成字符串-&gt;数组的转换， //然后在数组中逐位进行相加，再判断该位相加后是否需要...
大数减法模板
WINDZLY的博客
04-15 624
#include<bits/stdc++.h> typedef long long ll; using namespace std; ll a[100000],b[100000]; ll z[200000],l; void sub() { for(int i = 0; i < l; i ++) { z[i] = a[i] - b[i]; ...
大数运算(3)——大数减法
静之吾心的博客
08-25 3759
大数的减法与大数加法的方法有相似之处的，都是模拟人工运算的，从最低位开始运算，一直到最高位。 其方法是： 首先，要判断减数和被减数哪一个位数长，减数位数长是正常减；被减数位数长，则被减数减减数，最后还要加上负号；两数位数长度相等时，最好比较一下哪一个数字大，否则负号处理会很繁琐，用大的减去小的，最后加上负号； 其次，处理每一项时要，如果前一位相减有借位，就先减去上一位的借位，无则不减；再去判
ACM简单处理大数加法方法
LHS的专栏
07-22 2997
在ACM刷题中，处理大数问题，如大数加法，减法，乘法，
大数运算的算法
热门推荐
我的ACM
10-10 1万+
在数学运算的过程中 ,经常碰到这样的问题:参与运算的 数字很大或者对运算结果的精度要求很高。无论何种计算机 语言 ,在描述数据类型时都有一定的精度和位数要求 ,比如说 16 位整型数 (int) 所能表示的范围为 - 32768～32767 ,实数 (float)所能表示的精度为小数点后 8 位等 ,每种类型的数据都 有其精度和位数限制。超过 20 位有效数字的数值一般就无 法表示了。所以 ,在上
Ac日记——大整数减法 openjudge 1.6 11
weixin_34290096的博客
12-04 644
11:大整数减法 总时间限制:1000ms内存限制:65536kB描述 求两个大的正整数相减的差。 输入共2行，第1行是被减数a，第2行是减数b(a > b)。每个大整数不超过200位，不会有多余的前导零。输出一行，即所求的差。样例输入 9999999999999999999999999999999999999 9999999999999 样例输出 9999999...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值