浅析《大数据运算》-加减乘除以及模除运算

最新推荐文章于 2022-05-13 11:51:33 发布
置顶 最新推荐文章于 2022-05-13 11:51:33 发布
阅读量2.1k 收藏 1
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/no_sying_nothing/article/details/51534586
版权


WAY?

为什么会有大数据运算？缘由？

在c++中常用的数据类型有 char:1 bit,short 2 bit，int 4 bit，long long 8 bit等等，以上数据类型标识的数据大小非常有限，如果遇到大于他们能表示的范围时，计算结果就会有误，日常生活中的计算器也是如此，我国计算两个比较大的数的运算，也会出现错误，或者不能正常显示，

例如计算123456789123456789*987654321987654321

计算结果如下：

wKiom1cOWmfwUN-7AACDSntjswo110.png

具体区别如下：

wKiom1cPnC2SqgGzAAA-e7l29rk790.png

分析：

在数据运算中会出现两种情况：一种是数据、且小计算结果不会溢出；另一种是数据溢出或者计算结果会溢出；

所以为了计算便捷，也为了节省运算量，我设置了如下两种储存数据方式，并且在计算也分情况不同而选择不同方法，形式如下：

wKiom1cPn6HTX6t5AABGnZr_rYg221.png

做了什么？

为了解决上述问题，我写了一个计算大数据四则运算以及求模的小项目，实现的功能有 + - * / %；


主要的接口以及实现代码如下：

程序头文件以及接口如下：

/*
*
*  项目名称：大数据运算
*  接口名称：BigData.h
*  作    者: 邹明
*  完成时间：2016.04.12
*
*/

#ifndef __BIG_DATA_H__
#define __BIG_DATA_H__

#include<iostream>
using namespace std;
#include<string.h>
#include<assert.h>

#define MAX_INT64 0x7FFFFFFFFFFFFFFF  //小数据能表示的最大值
#define MIN_INT64 0x8000000000000000   //小数据能表示的最小值

#define INIT 0xcccccccccccccccc

typedef long long INT64;
class BigData
{
public:
	BigData(INT64 value= INIT);
	BigData(const char*ptrData);

	//运算符重载
	BigData operator+(const BigData& bigdata);
	BigData operator-(const BigData& bigdata);
	BigData operator*(const BigData& bigdata);
	BigData operator/(const BigData& bigdata);
	BigData operator%(const BigData& bigdata);


private:
	std::string Add(std::string left, std::string right);
	std::string Sub(std::string left, std::string right);
	std::string Mul(std::string left, std::string right);
	std::string Div(std::string left, std::string right);
	std::string Mod(std::string left, std::string right);  //求模


	bool IsINT64OverFlow() const;  //判断是否越界
	void INT64ToString();  //数据转化为字符串
	bool IsLeftStrBig(const char *pLeft, int LSise, const char *pRight, int RSise);  //比较左操作数是否大于有操作数
	char SubLoop(char *pLeft, int LSise, const char *pRight, int RSise);   //除法时每次求商运算

	friend std::ostream&operator<<(std::ostream & cout, const BigData& bigdata);   //输出运算符重载

private:
	INT64 _value;  //整形数据形式
	string _strData;  //字符串数据形式
};

#endif

实现代码，文件名称BigData.cpp，下面文件晕包含于此内

构造函数，转化字符串，判断越界，输出运算符重载等函数

#include"BigData.h"

BigData::BigData(INT64 value)  //小数据构造函数
	:_value(value)
{
	INT64ToString();
}

BigData::BigData(const char*ptrData)//大数据构造函数
{
	//123456   //+1223356  //122334qwer   //qwee123   //0000qwer
	assert(ptrData);

	char *pstr = (char*)ptrData;
	char cSymbol = '+';
	if (('+' == *pstr) || ('-' == *pstr))
	{
		cSymbol = *pstr;
		pstr++;
	}
	else if (('0' <= *pstr)&&('9' >= *pstr))
	{
		cSymbol = '+';
	}
	else if (*pstr == ' ')
	{
		while (*pstr == ' ')
		{
			pstr++;
		}
		if (('+' == *pstr) || ('-' == *pstr))
		{
			cSymbol = *pstr;
			pstr++;
		}
		else if (('0' <= *pstr) && ('9' >= *pstr))
		{
			cSymbol = '+';
		}
	}
	else
	{
		return;
	}

	while (' ' == *pstr)
		pstr++;
	while ('0' == *pstr)
			pstr++;
	_strData.resize(strlen(ptrData)+1);
	_strData[0] = cSymbol;

	_value = 0;
	int iCount = 1;
	while ((*pstr >= '0') && (*pstr <= '9'))
	{
		_value = _value * 10 + (*pstr - '0');
		_strData[iCount] = *pstr;

		pstr++;
		iCount++;
	}
	_strData.resize(iCount);


	if (cSymbol == '-')
	{
		_value = 0 - _value;
	}

}

void BigData::INT64ToString()  //将数据的数值填充至字符串部分
{
	char cSymbl = '+';
	if (_value < 0)
	{
		cSymbl = '-';
	}
	//1234567
	//7654321
	_strData.append(1, cSymbl);
	INT64 temp = _value;
	if (temp < 0)
	{
		temp = 0 - temp;
	}
	while (temp)
	{
		_strData.append(1, temp % 10 + '0');
		temp /= 10;
	}
	char *pleft = (char*)_strData.c_str() + 1;
	char *pright = pleft + _strData.size() - 2;

	while (pleft < pright)
	{
		char tem = *pleft;
		*pleft = *pright;
		*pright = tem;
		pleft++;
		pright--;
	}

}

bool BigData::IsINT64OverFlow()const  //判断是否越界
{
	std::string temp("+9223372036854775807");
	if ('-' == _strData[0])
	{
		temp = "-9223372036854775808";
	}
	if (_strData.size() < temp.size())
	{
		return true;
	}
	else if ((_strData.size() == temp.size()) && (_strData <= temp))
	{
		return true;
	}
	return false;
}

//求商
char BigData::SubLoop(char *pLeft, int LSize, const char *pRight, int RSize)
{
	assert(pLeft);
	assert(pRight);
	char cRet = '0';
	while (true)
	{
		while ((*pLeft == '0')&&LSize>0)
		{
			pLeft++;
			LSize--;
		}
		if (!IsLeftStrBig(pLeft, LSize, pRight, RSize))
		{
			break;
		}
		for (int i = 1;i<=LSize; i++)
		{
			if ((LSize > RSize) && (i  == LSize))
			{
				break;
			}
			char ret = pLeft[LSize - i];
			ret -= pRight[RSize - i];
			if (ret < 0)
			{
				pLeft[LSize - i - 1] -= 1;
				ret += 10;
			}
			pLeft[LSize - i] = ret+'0';

		}
		cRet++;
	}
	return cRet;
}

//判断左操作数是否大于右操作数
bool BigData::IsLeftStrBig(const char *pLeft, int LSise, const char *pRight, int RSise)
{
	if (LSise > RSise ||
		((LSise == RSise) && (strcmp(pLeft, pRight) >= 0)))
	{
		return true;
	}
	return false;
}

//输出运算符重载
std::ostream&operator<<(std::ostream & _cout, const BigData& bigdata)
{
	if (bigdata.IsINT64OverFlow())
	{
		_cout << bigdata._value;
	}
	else
	{
		char *pData = (char*)bigdata._strData.c_str();
		if ('+' == pData[0])
		{
			pData++;
		}
		_cout << pData;
	}
	return _cout;
}

加运算

BigData BigData::operator+(const  BigData& bigdata)  //+ 加法运算符重载
{
	if (IsINT64OverFlow() && bigdata.IsINT64OverFlow())
	{
		if (_strData[0] != bigdata._strData[0])
		{
			return BigData(_value + bigdata._value);
		}
		else
		{
			INT64 temp_max = MAX_INT64 - _value;
			INT64 temp_min = MIN_INT64 - _value;

			//10 -3 =7  5
			//(-10)-(-3)=-7  -5
			if (((_value >= 0) && (temp_max >= bigdata._value)) ||
				((_value < 0) && (temp_min <= bigdata._value)))
			{
				return BigData(_value + bigdata._value);
			}
		}
	}

	if (_strData[0] == bigdata._strData[0])
	{
		return BigData(Add(_strData, bigdata._strData).c_str());
	}
	else
	{
		if(_strData[0] == '+')
		{
			string ptr(bigdata._strData);
			ptr[0] = '+';
			return Sub(_strData, ptr).c_str();
		}
		else
		{
			string ptr(_strData);
			ptr[0] = '+';
			return Sub(bigdata._strData, ptr).c_str();
		}
	}
}

std::string BigData::Add(std::string left, std::string right)
{
	int iLsize = left.size();
	int iRsize = right.size();
	char cSymbol = left[0]; //取得符号位
	if (iLsize < iRsize)
	{
		std::swap(left, right);
		std::swap(iLsize, iRsize);
	}

	std::string sRet;
	sRet.resize(iLsize + 1);
  
	char Step = 0;
	for (int i = 1; i < iLsize; i++)
	{
		char cRet = left[iLsize - i] - '0' + Step;
		if (i < iRsize)
		{
			cRet += (right[iRsize - i] - '0');
		}
		sRet[iLsize - i + 1] = cRet % 10 + '0';
		Step = cRet / 10;
	}
	sRet[1] = Step + '0';
	sRet[0]=cSymbol;
	return sRet;
}

减运算：

BigData BigData::operator-(const BigData& bigdata)  //- 减法运算符重载
{
	if (IsINT64OverFlow() && bigdata.IsINT64OverFlow())
	{
		if (_strData[0] == bigdata._strData[0])
		{
			return BigData(_value - bigdata._value);
		}
		else
		{
			INT64 temp_max = _value - MAX_INT64;
			INT64 temp_min = _value - MIN_INT64;

			//10 -3 =7  5
			//(-10)-(-3)=-7  -5
			if (((_value >= 0) && (temp_max <= bigdata._value)) ||
				((_value < 0) && (temp_min >= bigdata._value)))
			{
				return BigData(_value - bigdata._value);
			}
		}
	}
	if (_strData[0] == bigdata._strData[0])
	{
		return BigData(Sub(_strData, bigdata._strData).c_str());
	}
	else
	{
		string ptr(bigdata._strData);
		ptr[0] = _strData[0];
		return Add(_strData, ptr).c_str();
	}

}

std::string BigData::Sub(std::string left, std::string right)
{
	int iLsize = left.size();
	int iRsize = right.size();
	int Max_size = iLsize;
	std::string sRet;
	char cSymbol = left[0];   //取符号位

	if (iLsize <= iRsize)
	{	
		if ((iLsize == iRsize) && (strcmp(left.c_str() ,right.c_str())<0) && (left[0] == right[0]))
		{
			if ('+' == right[0])
			{
				cSymbol = '-';
			}
			else
			{
				cSymbol = '+';
			}
			Max_size = iRsize;
			std::swap(left, right);
			std::swap(iLsize, iRsize);
		}
	}
	else
	{
		cSymbol = left[0];
		Max_size = iLsize;
	}


	char Step = 0;
	sRet.assign(Max_size, 48);
	for (int i = 1; i < Max_size; i++)
	{
		char cRet = 0;
		if (0<(iLsize - i))
		{
			cRet = left[iLsize - i] - '0' + Step;
		}
		if (i < iRsize)
		{
			if (cRet < right[iRsize - i] - '0')
			{
				cRet += 10;
			}
			Step = 0 - (cRet-Step) / 10;
			cRet -= (right[iRsize - i] - '0');
		}

		sRet[Max_size - i ] = cRet + '0';
	}

	sRet[0] = cSymbol;
	return sRet;
}

乘运算：

BigData BigData::operator*(const BigData& bigdata)
{
	if ((0 == _value)||(0==bigdata._value))
	{
		return BigData(INT64(0));
	}
	if (IsINT64OverFlow() && bigdata.IsINT64OverFlow())
	{
		if (_strData[0] == bigdata._strData[0])
		{
			if (((_value > 0) && ((long long)MAX_INT64 / _value >= bigdata._value)) ||
				((_value < 0) && ((long long)MAX_INT64 / _value <= bigdata._value)))   //同号相乘 结果为正
			{
				return BigData(_value*bigdata._value);
			}
		}
		else
		{
			if (((_value > 0) && ((long long)MIN_INT64 / _value <= bigdata._value)) ||
				((_value < 0) && ((long long)MIN_INT64 / _value >= bigdata._value)))      //异号相乘 结果为负
			{
				return BigData(_value*bigdata._value);
			}
		}
	}
	
	return BigData(Mul(_strData, bigdata._strData).c_str());
}

std::string BigData::Mul(std::string left, std::string right)
{
	char cSymbol = '+'; //设置符号位
	int iLsize = left.size();
	int iRsize = right.size();
	if (left[0] == right[0])
		cSymbol = '+';
	else
		cSymbol = '-';
	if (iLsize > iRsize)
	{
		std::swap(left, right);
		std::swap(iLsize, iRsize);
	}
	std::string sRet;
	int t = 1;
	if (((left[1] - '0')*(right[1] - '0') +(left[1] - '0')*(right[1] - '0')%10)<10)
	{
		t = 2;
	}
	else
		t = 1;
	//sRet.resize(iLsize + iRsize - t);
	sRet.assign(iLsize + iRsize - t,'0');
	int sizeRet = iLsize + iRsize - 1;
	sRet[0] = cSymbol;

	int i = 1, j = 1;
	for (i = 1, j = 1; i < iLsize; i++)
	{
		char step = 0;
		char cleft = left[iLsize - i] - '0';
		for (int j = 1; j < iRsize; j++)
		{
			char cRet = cleft*(right[iRsize - j] - '0') + step + (sRet[sizeRet - i - j + 1] - '0');
			step = cRet / 10;
			sRet[sizeRet - i - j + 1] = cRet%10 + '0';
			if ((j+1)==iRsize)
				sRet[sizeRet - i - j] = step+'0';
		}

	}
	return sRet;
}

除运算：

BigData BigData::operator/(const BigData& bigdata)
{
	if (bigdata._strData[1] == '0')
	{
		cout << "除数为 0 " << endl;
		assert(0);
	}
	if (_strData[1] == 0)
		return INT64(0);
	if ((IsINT64OverFlow()) && bigdata.IsINT64OverFlow())
	{
		return _value / bigdata._value;
	}
	if (_strData.size() < bigdata._strData.size())
	{
		return INT64(0);
	}
	else if (_strData.size() == bigdata._strData.size())
	{
		if (strcmp(_strData.c_str() + 1, bigdata._strData.c_str() + 1) < 0)
			return INT64(0);
		if (strcmp(_strData.c_str() + 1, bigdata._strData.c_str() + 1) == 0)
		{
			if (_strData[0] == bigdata._strData[0])
				return INT64(1);
			else
				return INT64(-1);
		}
	}
	return BigData(Div(_strData, bigdata._strData).c_str());
}

std::string BigData::Div(std::string left, std::string right)
{
	string sRet;
	sRet.append(1, '+');
	if (left[0] != right[0])
	{
		sRet[0] = '-';
	}

	char *pLeft = (char *)(left.c_str() + 1);
	char *pRight = (char *)(right.c_str() + 1);
	int DataLen = right.size() - 1;
	int Lsize = left.size() - 1;
	for (int i = 0; i < Lsize; i++)
	{
		if (!IsLeftStrBig(pLeft, DataLen, pRight, right.size()-1))
		{
			sRet.append(1, '0');
			DataLen++;
		}
		else
		{
			sRet.append(1, SubLoop(pLeft, DataLen, pRight, right.size() - 1));
		}

		if (DataLen + i>Lsize)
		{
			break;
		}

		if (*pLeft == '0')
		{
			pLeft++;
		}
		else
		{
			DataLen = right.size();
		}

	}		
	return sRet;
}

摸除运算：

BigData BigData:: operator%(const BigData& bigdata)
{
	if (bigdata._strData[1] == '0')
	{
		cout << "除数为 0 或对0求模" << endl;
		assert(0);
	}
	if (_strData[1] == 0)
		return INT64(0);
	if ((IsINT64OverFlow()) && bigdata.IsINT64OverFlow())
	{
		return _value % bigdata._value;
	}
	if (_strData.size() < bigdata._strData.size())
	{
		return BigData(_strData.c_str());
	}
	else if (_strData.size() == bigdata._strData.size())
	{
		if (strcmp(_strData.c_str() + 1, bigdata._strData.c_str() + 1) < 0)
			return INT64(0);
		if (strcmp(_strData.c_str() + 1, bigdata._strData.c_str() + 1) == 0)
		{
				return INT64(0);
		}
	}
	return BigData(Mod(_strData, bigdata._strData).c_str());
}

std::string BigData::Mod(std::string left, std::string right)
{

	char cSymbol = left[0];
	BigData n1(left.c_str() + 1);
	BigData n2(right.c_str() + 1);
	BigData n3 = n1 / n2;
	BigData n4 = n3*n2;
	BigData sRet(n1 - n4);
	sRet._strData[0] = cSymbol;
	return sRet._strData;
}


测试用例，文件名test.cpp

#include"BigData.h"

void Test1()
{
	BigData n1(123456);

	BigData b2("12346678");
	BigData b3("+12346678");
	BigData b4("-123466");
	BigData b5("+");
	BigData b6("    ");
	BigData b7("12346aaaa");
	BigData b8("+asd12346678");
	BigData b9("000012346678");

	cout << "n1:" << n1 << endl;
	cout << "b2:" << b2 << endl;
	cout << "b3:" << b3 << endl;
	cout << "b4:" << b4 << endl;
	cout << "b5:" << b5 << endl;
	cout << "b6:" << b6 << endl;
	cout << "b7:" << b7 << endl;
	cout << "b8:" << b8 << endl;
	cout << "b9:" << b9 << endl;
}
void testAdd()
{
	BigData b1("-45353");
	BigData b2("37353753");
	BigData b3("-   9223372036854775808");
	BigData b4("     9223372036854775800");
	BigData b5("    -9223372036854775810");
	BigData b6("9223372036854775900");

	//1、都在INT64范围内
	cout << (b1 + b1) << endl;
	cout << (b2 + b2) << endl;
	cout << (b1 + b2) << endl;
	cout << "b4:" << b4 << endl;
	cout << (b1 + b4) << endl;

	cout << b3 << endl;
	cout << (b1 + b3) << endl;
	cout << (b2 + b4) << endl;

	//2、都不在INT64范围内
	cout << (b2 + b5) << endl;
	cout << (b1 + b6) << endl;
	cout << (b6 + b1) << endl;

}

void testSub()
{
	BigData b1("-45353");
	BigData b2("37353753");
	BigData b3("-9223372036854775808");
	BigData b4("9223372036854775800");
	BigData b5("-9223372036854775810");
	BigData b6("9223372036854775900");
	//1、都在INT64范围内
	cout << (b1 - b2) << endl;
	cout << (b2 - b1) << endl;
	cout << (b3 - b1) << endl;
	cout << (b1 - b4) << endl;
	cout << (b3 - b2) << endl;
	cout << (b4 - b1) << endl;
	cout << (b1 - b3) << endl;
	cout << (b2 - b4) << endl;
	cout << endl;

	//2、一个在一个不在<运算后在范围内，运算后不在范围内>

	cout << (b5 - b1) << endl;
	cout << (b1 - b5) << endl;
	cout << endl;
	cout << (b6 - b2) << endl;
	cout << (b2 - b6) << endl;
	cout << endl;
	cout << (b6 - b5) << endl;
	cout << (b5 - b6) << endl;
	cout << (b2 - b5) << endl;
	cout << (b1 - b6) << endl;
	cout << (b6 - b1) << endl;
}


void testMul()
{
	BigData b1("-45353");
	BigData b2("37353753");
	BigData b3("-9223372036854775808");
	BigData b4(" 9223372036854775800");
	BigData b5("-9223372036854775810");
	BigData b6(" 9223372036854775900");
	//1、都在INT64范围内
	cout << (BigData("999") * BigData("22222222222222222222222222222")) << endl;

	cout << (b2 * b1) << endl;
	cout << (b1 * b2) << endl;
	cout << (b1 * BigData("0")) << endl;
	cout << (BigData("0") * b2) << endl;
	cout << endl;
	cout << (b3 * b1) << endl;
	cout << (b1 * b3) << endl;
	cout << (b1 * b4) << endl;
	cout << (b4 * b1) << endl;
	cout << (b3 * b2) << endl;
	cout << (b2 * b4) << endl;
	cout << endl;

	//2、一个在一个不在<运算后在范围内，运算后不在范围内>

	cout << (BigData("0") * b6) << endl;
	cout << (b5 * BigData("0")) << endl;
	cout << (b5 * b1) << endl;
	cout << (b1* b5) << endl;
	cout << endl;
	cout << (b6 * b2) << endl;
	cout << (b2 * b6) << endl;
	cout << endl;
	cout << (b6 * b5) << endl;
	cout << (b5 * b6) << endl;
	cout << (b2 * b5) << endl;
	cout << endl;
	cout << (b1 * b6) << endl;
	cout << (b6 * b1) << endl;
}

void testDiv()
{
	BigData b1("-45353");
	BigData b2("37353753");
	BigData b3("-9223372036854775808");
	BigData b4(" 9223372036854775800");
	BigData b5("-9223372036854775810");
	BigData b6(" 9223372036854775900");
	BigData b7("-1231123203367738338252");


	//1、排除除数为0
	cout << (b1 / BigData(0)) << endl;

	//2、在范围内

	cout << (b1 / b2) << endl;
	cout << (b2 / b1) << endl;


	//3、不在范围内<左（被除数）比右（除数）小为0，左比右大>
	cout << (b2 / b5) << endl;
	cout << (b2 / b6) << endl;

	cout << (b5 / b2) << endl;
	cout << (b6 / b2) << endl;
	cout << (b6 / b1) << endl;
	cout << (b5 / b1) << endl;

	cout << b7 / b1 << endl;
}

void testMod()
{
	BigData b1("-45353");
	BigData b2("37353753");
	BigData b3("-9223372036854775808");
	BigData b4(" 9223372036854775800");
	BigData b5("-9223372036854775810");
	BigData b6(" 9223372036854775900");
	BigData b7("-1231123203367738338252");

	//1、排除除数为0
	cout << (b1 / BigData(0)) << endl;

	//2、在范围内

	cout << (b1 % b2) << endl;
	cout << (b2 % b1) << endl;


	//3、不在范围内
	cout << (b2 % b5) << endl;
	cout << (b2 % b6) << endl;

	cout << (b5 % b2) << endl;

	cout << (b6 % b2) << endl;
	cout << (b6 % b1) << endl;
	cout << (b5 % b1) << endl;

	cout << b7 % b1 << endl;
}


int main()
{
	//testAdd();  //测试+
	//testSub();   //测试-
	//testMul();   //测试 *
	//testDiv();   //测试 /
	testMod();     //测试%

	system("pause");
	return 0;
}

运行结果：

加运算：

wKiom1cOX5_DYjVTAAAbrv2WOdQ015.png

减运算：

wKioL1cOYJiRkx7wAAAjBWwNSG0390.png

乘运算：

wKioL1cOYOLz5B8UAAAlotxrdRI744.png

除运算：

wKiom1cOYHGhcUsOAAATwfHKRsE538.png

模除运算：

wKiom1cOYLqSv9B9AAASuG2tiMM474.png

以上代码均为原创，实现了与小数据运算同样的功能，如果发现错误，欢迎各位读者批评指正，谢谢

本文出自 “分享中进步” 博客，请务必保留此出处http://xmwen1.blog.51cto.com/10730069/1763620

no_sying_nothing
关注
大数运算——加减乘除
败毒的博客
01-07 1166
大数运算产生的原因就是因为int，double类型表示范围都有限，无法表示过长的数字比如：2345468454567865415467864453437。 因此也就无法进行四则运算，为了实现这种运算，大数运算产生了。 其实也很简单，既然基本数据类型放不下这些数据，那就用数组存放呗。 定义char c[100000000],总能放下这么大的数了吧，当然因为这些数是用数组保存的，那么对它们进行运算也...
大数运算包含加，减，乘，除，取模，幂运算，模幂运算。支持十进制运算，二进制运算.zip
02-21
大数运算包含加，减，乘，除，取模，幂运算，模幂运算。支持十进制运算，二进制运算；支持文件运算，键盘输入运算，若有需要，可提供实验报告
大数据的加减乘除实现（用的vector）
qq_51711403的博客
03-12 422
```cpp /* *该头文件用于实现大数据计算，用于实现python的大数，因为之后可能会用到大数据计算 *ADT *我没有写两个大数据的乘法，因为它相当于许多个小乘法的组合 *我不会写两个大数据的除法（呜呜呜~~.我太菜了） * 该文件的接口为BigData类模板，有加减乘除和比较的实现 */ #ifndef _BIGDATA_INCLUDED_ #define _BIGDATA_INCLUDED_ #include<vector> #include<string&.
大数取模运算，快速幂取模运算
热门推荐
Jeff_的博客
10-02 2万+
1.快速幂取模 http://www.cnblogs.com/yinger/archive/2011/06/08/2075043.html 快速幂取模就是在O(logn)内求出a^n mod b的值。算法的原理是ab mod c=(a mod c)(b mod c)mod c  long exp_mod(long a,long n,long b) { long t; if(...
嵌入式加减乘除预算效率
最新发布
09-02
综上所述，嵌入式系统中可以通过减少除法和乘方运算、使用位操作指令、选择小的数据类型等方法来提高加减乘除运算的效率。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[....
gnu-ld链接脚本浅析.pdf
01-31
链接脚本支持各种算术运算和逻辑运算符，例如加减乘除、比较运算等。 #### 十二、暗含的连接脚本 链接器有一个默认的内置连接脚本，可通过`ld --verbose`查看。使用`-T`选项可以指定自定义的链接脚本来替代默认...
浅析VB程序设计.doc
06-20
通过响应不同按键的事件，执行相应的计算逻辑，如加减乘除、开方、求倒数等。 在VB中，通常会创建一个窗体（Form），在窗体上添加必要的控件（如按钮CommandButton，文本框TextBox等），然后编写每个控件的事件处理...
《Matlab软件应用》课程教学浅析.zip
10-16
学生将学习如何进行矩阵运算，例如矩阵的加减乘除、求逆、特征值与特征向量等。此外，还将涉及函数的定义、求解方程组、积分和微分等问题。 在符号计算方面，Matlab提供了Symbolic Math Toolbox，使得符号运算成为...
总结TS中常用的运算符
zccst的专栏
04-03 3907
最近在使用ts开发项目，开发中经常有想用某个操作符但是因掌握不熟不知道该用哪个，本文就整理了使用ts在日常开发中常用的运算符和操作符，理解记忆之余便于温故知新 一、 ？. 可选链运算符，对null和undefined可及时停止运算，可解放es5繁琐的判断逻辑，如: // ts const val = a?.b //es5 var val = a === null || a.b 复制代码 支持的语法如下： obj?.prop // 尝试访问可能不存在的属性 obj?.[exp] // 同上，计
C# 大数据的加减乘除
06-13
当数据进行自增时，经常数据会变为很大，进行自增时出现了超出范围的异常。解决这个问题的方案。
超大整数出除法的C语言实现
12-16
好啊。可以欣赏哈俺们的作品，谢谢
【大数据】大数据字符串的加减乘除
菜鸟成长记
08-06 2044
在日常计算中，一般来说，数据不会太大，即使再大long long 8个字节也够用，但是现在来说数据很大，一般的数据类型都表示不了，那么就用字符串来表示数据。那么就有字符串数据的加减乘除运算。基本结构BigData.h有两种成员变量; long long _value; string _strData;两种构造函数：字符串，int 构造函数已经处理过字符串，正数的字符串是，”+…….”,负数
大数除法 C语言
liangkk的博客
07-25 2万+
大数除法的核心：把除法运算转化为减法运算
3.ts运算符
Asanxina的博客
05-13 1357
1.算数运算符 1.1 + 1.2 - 1.3 * 1.4 / 1.5 % 取模 （余数） 1.6 ++ 自增 // y 初始值为5 x = ++y // x = 6 y = 6 // 前自增 是先自增 1 ，再使用 x = y++ // x = 5 y = 6 // 后自增 是先使用 ，再自增1 1.7 -- 自减 x = --y // x = 4 y = 4 x = y-- // x = 5 y = 4 2
大数据的运算加减乘除
weixin_33785972的博客
04-12 185
BigData.h:#ifndef__BIG_DATA_H__ #define__BIG_DATA_H__ #include<assert.h> #include<string> typedeflonglongINT64; //#defineMININT64-9223372036854775808//编译器检查有错 // ...
PAT1017 A除以B (20)
eCode代码加工厂
10-06 661
本题要求计算A/B，其中A是不超过1000位的正整数，B是1位正整数。
C++实现大数据的加法、减法和乘法
u011137205的专栏
06-08 3303
最近在做大数据的四则运算，
java实现大数字的加减乘除
u014298282的博客
11-18 5124
java代码实现 大数字的 加减乘除 一：加法 基本上是模拟了人工的算法，比如1234+987 a.先把位数补齐一致，变成：1234 + 0987 b.从各位开始运算，每次用一个变量记录是否要进位 c.遍历所有的位置就完成了加法； 代码如下：` public class 大数加法 { public static void main(String[] args) { //输入2个字符串类型的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值