ACMDay13大整数加减乘除

ACM_大数运算 模板&&讲解&&各大oj题目 c语言版大数相加,大数相减,大数相乘,大数相除,大数阶乘,大数求模,大数幂,已通过各大OJ测试,有讲解有练习,有模板,有测试。。。。。 阅读详情

大整数加减乘除法还没搞定(本蒟蒻搞了一上午)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;
		}
	}
}

大整数运算之 大整数加法、减法、乘法 其实大整数的问题都是在像我们打草稿的时候列竖式一样的,不要告诉我你不知道什么叫竖式~!其实我开始也不知道它叫这个名字; 所谓竖式,就是你打草稿算算术的方法,小学知识;比如你写 11+9: 11 +   9 ---------- 20 数A,B,求和,求差;数的长度不超过1000; 贴个代码,先输入一个数,代表数据的组数n,然后输入n组A B #inc 阅读详情

相关推荐

Pixel 6 Pro刷Android 13变砖自救指南:fastboot全分区擦除与手动刷入教程

本文提供了一份详细的Pixel 6 Pro在Android 13升级过程中变砖后的自救指南。针对因super分区锁死或动态分区异常导致的无法启动问题,文章核心介绍了通过fastboot命令手动擦除关键分区并逐一刷入官方镜像的完整救砖流程,帮助用户实现系统重建与恢复。

weixin_29208327的博客 373

ACM内部函数--数学问题--大数相减

在这里我们为了方便起见,所以只设置成了大数减小数,在调用此方法之前需要进行判断,如果是小数减大数,只需要在前面加一个负号就行了 #include #include #include #include using namespace std; const int N=1005; /** 大数相减 str1:减数数组 str2:被减数数组 result:结果数组 */ v

戎码人生 691

sdio wifi 移植

介绍 简单来说,sdio起源自sd标准,顾名思义就是sd的IO接口(interface)的意思,更具体的说明,sd本来是记忆卡的标准,但是现在也可以把SD卡拿来插上一些外围设备接口使用,这个就是就叫做sdio。 而且sdio本身是一种相当单纯的技术,通过sd的IO引脚来连接外部外围,并且通过sd的IO数据接位与外围传输数据,而且sd协会也推出很完整的sdio stack 驱动程序,使得sdio外围得开发与应用变得非常热门 这里我们要移植的是RTL8822cs的sdio WiFi 模块,将其移植到rk3

Enosji的博客 9611

acm作业重点分析2——大整数运算

1.BUCTOJ 2169 大整数加法 题目描述:计算两个大整数的和。大整数是指超过了c,c++表示范围的整数。 输入格式:输入包括两个大整数,每个大整数不超过100位,用空格或者换行隔开 输出格式:输出两个大整数的和 自己构造测试数据: 简单:1 1 有进位的情况:9 1 复杂:888 999 边界情况:一百个9 一百个1 重点分析:(大整数加法由于位数太多超出long和int范围所以只能用字符串来计算) 首先为了好计算个位数需对应下标0(就是最初的那两重循环) 然后将两者加和结果

FightingTsinghua的博客 661

Qt多线程实战:如何优雅地处理Modbus设备通信中的线程安全问题

本文深入探讨了在Qt框架下实现Modbus设备通信时的多线程安全问题,提供了优雅的解决方案。通过生产者-消费者模型、任务队列与锁机制等设计模式,有效解决了界面卡顿、数据包错乱等问题。文章还详细介绍了对象生命周期管理、信号槽连接类型选择等关键实现细节,帮助开发者构建稳定可靠的Modbus通信模块。

weixin_30897233的博客 484

Ubuntu 20.04 系统备份和还原

最近大家Ubuntu开发环境,经常出现搭着搭着系统就挂了,于是开始琢磨了Ubuntu系统的备份和还原,以备不时之需,Linux环境搭建实在是有点太细,好多情况下,就算曾经搭建过一遍,再次搭建有些包还是忘了安装,做好备份是十分必要的。 经过了一番研究,Ubuntu备份有很多方式:根目录tar、dd、Systemback(1.0版本已经不维护了,2.0版本收费)等等,最终决定使用 —— Timesift, 因为方便一些。 文章参考:小马虎的救星——Timeshift Timeshift Timeshift,是L

Z_Paper的博客 2万+

大数运算模板

#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

蓦然回首 452

手势控制 Python !Leap Motion Python 开发教程 (二)

手势控制 Python !Leap Motion Python 开发教程 (二) 现在进入正题,我来给大家总结一下我在使用 Leap Motion 开发过程中的经验以及学到的东西,其中我会概括以及翻译官方给出的注释,为了让这些注释更加通俗易懂,让大家更好理解。 回顾 在上一篇文章中我们讲了如何配置 Leap Motion 的 Python 2.7 的开发环境,如果您还没有配置好您的开发环境,可以参...

成畅的博客 3193

ACM大数相减

#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

qq_22125259的博客 645

OpenCV实战之人脸美颜美型(八)——大眼(上)

从大众审美的角度来看,眼睛适当的“变大”会让人显得更加年轻。因此美型中就有一项大眼功能,其效果就是让眼睛适当变大,这章内容就围绕着大眼算法展开。

On my way 1211

【Claude Code 源码解析教程】总体大纲

本教程旨在深入解析 Anthropic Claude Code 项目的源码架构和实现细节。Claude Code 是一个基于 TypeScript + Bun 构建的 AI 编程助手 CLI 工具,代号 "Tengu",具有复杂的多模块架构和丰富的功能特性。本教程基于Claude Code 的源码分析来生成,将帮助您全面掌握 Claude Code 的源码架构和实现细节,为开发类似 AI 编程助手工具奠定坚实基础。

rengang66的博客 387

大数四则运算

#include&lt;iostream&gt; #include&lt;cstdlib&gt; #include&lt;cstring&gt; using namespace std; #define M 1000000000000000 //大数加法 //将数字以字符串的形式传入add加法函数,在函数内部完成字符串-&gt;数组的转换, //然后在数组中逐位进行相加,再判断该位相加后是否需要...

ACM_Colas_125的博客 437

华为OD机试 新系统 双机位C卷 往年真题 机考题库(持续收录中)以及算法考点详解(Python/JS/C/C++)

刷的越多,抽中的概率越大,每一题都有详细的答题思路、详细的代码注释发现新题目,随时更新。

学Java,找哪吒 5万+

大数相减的算法

#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

summerFanL的博客 873

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

大数(加、减、乘、除、低精度*大数)模板详解(C++)

一、大数四个基本操作 首先,我们来了解什么是大数,大数就是指用我们平常常见的高级语言(如:c 、c++)的基本数据类型的最大长度都装不下的数据,例如(1234567899876543211234567896542132165465),这些只能用字符数组(char[])或者字符串(string)来处理,大数操作最基础的四个操作就是:大数加法、大数减法、大数乘法、大数除法。下面我来详细介绍下四个基

氵青-风的博客 5461

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

大数运算(3)——大数减法

大数的减法与大数加法的方法有相似之处的,都是模拟人工运算的,从最低位开始运算,一直到最高位。 其方法是: 首先,要判断减数和被减数哪一个位数长,减数位数长是正常减;被减数位数长,则被减数减减数,最后还要加上负号;两数位数长度相等时,最好比较一下哪一个数字大,否则负号处理会很繁琐,用大的减去小的,最后加上负号; 其次,处理每一项时要,如果前一位相减有借位,就先减去上一位的借位,无则不减;再去判

静之吾心的博客 4096

Ac日记——大整数减法 openjudge 1.6 11

11:大整数减法 总时间限制:1000ms内存限制:65536kB描述 求两个大的正整数相减的差。 输入共2行,第1行是被减数a,第2行是减数b(a > b)。每个大整数不超过200位,不会有多余的前导零。输出一行,即所求的差。样例输入 9999999999999999999999999999999999999 9999999999999 样例输出 9999999...

weixin_34290096的博客 731

ACM简单处理大数加法方法

在ACM刷题中,处理大数问题,如大数加法,减法,乘法,

LHS的专栏 3122

大数运算的算法

在数学运算的过程中 ,经常碰到这样的问题:参与运算的 数字很大或者对运算结果的精度要求很高。无论何种计算机 语言 ,在描述数据类型时都有一定的精度和位数要求 ,比如说 16 位整型数 (int) 所能表示的范围为 - 32768~32767 ,实数 (float)所能表示的精度为小数点后 8 位等 ,每种类型的数据都 有其精度和位数限制。超过 20 位有效数字的数值一般就无 法表示了。所以 ,在上

我的ACM 1万+

大数减法模板

#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]; ...

WINDZLY的博客 696

oj之大数相减

题目:两个大于32位的正整数str,str1相减,求str-str1。 这个题目首先把str,str1以字符串的形式输入,反排序之后,比较str,str1的大小,首先长度长的数字一定大于长度短的,如果str的度 得str为大数,str1为小数,输出‘-’,然后用resize函数补‘0‘使得两个字符串等长,在依次分类判断出str>str1 长度,str==str1的情况,一旦str>s

hj1214ing的博客 933

大整数运算模板(减法)

大整数运算模板(减法) 大整数减法(str_a - str_b = str_c) #include #include #define N 1009 void sub(char str_a[],char str_b[],char str_c[]) {  char

ACM 1002

ACM内部函数--数学问题--大数相乘

简述 这是2012年蓝桥杯全国软件大赛预赛(C++本科组)第6题,有图片可知是个简单的大数计算的问题。 题目描述     对于32位字长的机器,大约超过20亿,用int类型就无法表示了,我们可以选择int64类型,但无论怎样扩展,固定的整数类型总是有表达的极限!如果对超级大整数进行精确运算呢?一个简单的办法是:仅仅使用现有类型,但是把大整数的运算化解为若干小整数的运算,即所谓

戎码人生 1162

C++实现大数运算(加减乘除求余)

前言: 只有部分GCC编译器支持int128,而我们平常使用的软件,最大只有_int64.当这些不够用时,我们该怎么办? 我本身想写代码实现整数型大数据的加减乘除和求余,结果写着写着想着连小数运算的也一起写上(反正加的代码不多) 电脑是死的,人是活的,当数据超出范围时,我们可以想其他方法去算,在这里,我使用string类来存数据,string类的容量足够大,相信够一般大数据使用了吧。 编译软...

cai_niaocainiao的博客 2万+

大数的四则运算模板(高精度加减乘除)

普通大数运算对于不同的题目要求,在main函数里修改就可以了const int MAXSIZE = 200; void Add(char *str1, char *str2, char *str3); void Minus(char *str1, char *str2, char *str3); void Mul(char *str1, char *str2, char *str3); void...

I_believe_CWJ的博客 750
上一篇: ACMDay11
下一篇: 费马定理在算法取模中的应用
MaplePlane
博客等级 码龄7年 9粉丝 21原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值