高精度算法以及运算符的重定义

最新推荐文章于 2022-07-28 22:05:00 发布
最新推荐文章于 2022-07-28 22:05:00 发布
阅读量224 收藏
点赞数
分类专栏： 数学 文章标签： 算法 c语言 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51634651/article/details/120519985
版权
这篇博客介绍了高精度计算的基本操作，包括加法、减法、乘法和除法，并提供了C++的实现代码示例。文章还提到了Python在高精度计算中的简便性，并展示了Python的高精度除法实现。此外，博客讨论了如何在C++中自定义高精度数据类型以及相关的运算符重载，这对于进行多次高精度计算很有帮助。
摘要由CSDN通过智能技术生成

复习一下高精度~~
1.高精度加法

#include<bits/stdc++.h>
using namespace std;
const int maxn=100010;
int a[maxn],b[maxn],w[maxn];

void File_in_and_out();
void scan_num1_and_num2();
void Plus();
void print_ans();

int main()
{
	//File_in_and_out();
	scan_num1_and_num2();
	Plus();
	print_ans();
	return 0;
}

void File_in_and_out()
{
	freopen("plus.in","r",stdin);
	freopen("plus.out","w",stdout);
}

void scan_num1_and_num2()
{
	string num1,num2;
	cin>>num1;
	cin>>num2;
	a[0]=num1.length();
	b[0]=num2.length();
	for(int i=0;i<=a[0]-1;i++)
	{
		a[a[0]-i]=num1[i]-'0';
	}
	for(int i=0;i<=b[0]-1;i++)
	{
		b[b[0]-i]=num2[i]-'0';
	}
}

void Plus()
{
	int ex=0;
	for(int i=1;i<=a[0] || i<=b[0];i++)
	{
		w[i]=(a[i]+b[i]+ex)%10;
		ex=(a[i]+b[i]+ex)/10;
		w[0]++;
	}
	if(ex!=0) 
	{
		w[++w[0]]=ex;
	}
}

void print_ans()
{
	for(int i=w[0];i>=1;i--)
	{
		printf("%d",w[i]);
	}
}

对比一下Python的

a=input()
b=input()
a=int(a)
b=int(b)
print(a+b)

（Python真好用 ）
2.高精度减法

#include<bits/stdc++.h>
using namespace std;
int sign=0;
string a,b;
const int maxn=100010;
int num1[maxn],num2[maxn],ans[maxn];

void scan();
void reduce();
void print();

int main()
{
	scan();
	reduce();
	print();
	return 0;
}

void scan()
{
	cin>>a;
	cin>>b;
	num1[0]=a.length();
	num2[0]=b.length();
	if(num1[0]<num2[0] || (num1[0]==num2[0]&&a<b))
	{
		string n;
		int num;
		n=a;
		a=b;
		b=n;
		num=num1[0];
		num1[0]=num2[0];
		num2[0]=num;
		sign=-1;
	}
	for(int i=1;i<=num1[0];i++)
	{
		num1[i]=a[num1[0]-i]-'0';
		//printf("%d:%d\n",i,num1[i]);
	}
	for(int i=1;i<=num2[0];i++)
	{
		num2[i]=b[num2[0]-i]-'0';
		//printf("%d:%d\n",i,num2[i]);
	}
}

void reduce()
{
	int i=1;
	while(i<=num1[0] || i<=num2[0])
	{
		if(num1[i]<num2[i])
		{
			num1[i+1]--;
			num1[i]=num1[i]+10;
		}
		ans[i]=num1[i]-num2[i];
		i++;
	}
	ans[0]=i;
	while(ans[ans[0]]==0 && ans[0]>1)
	{
		ans[0]--;
	}
}

void print()
{
	if(sign==-1) printf("-");
	for(int i=ans[0];i>=1;i--)
	{
		printf("%d",ans[i]);
	}
}

3.高精度乘法

#include<bits/stdc++.h>
using namespace std;
const int maxn=20010;
int num1[maxn],num2[maxn],ans[maxn];

void File_Input_and_Output();
void scan();
void multiplication();
void print();

int main()
{
//	File_Input_and_Output();
// 	int n;
// 	scanf("%d",&n);
// 	for(int i=1;i<=n;i++)
// 	{	
	memset(num1,0,sizeof(num1));
	memset(num2,0,sizeof(num2));
	memset(ans,0,sizeof(ans));
	scan();
	multiplication();
	print();
// 	}
	return 0; 
}

void File_Input_and_Output()
{
	freopen("Mutiplication.in","r",stdin);
	freopen("Mutiplication.out","w",stdout);
}

void scan()
{
	string a,b;
	cin>>a;
	cin>>b;
	num1[0]=a.length();
	num2[0]=b.length();
	for(int i=0;i<=num1[0]-1;i++)
		num1[num1[0]-i]=a[i]-'0';
	for(int i=0;i<=num2[0]-1;i++)
		num2[num2[0]-i]=b[i]-'0';
}

void multiplication()
{
	for(int i=1;i<=num1[0];i++)
	{
		int x=0;
		for(int j=1;j<=num2[0];j++)
		{
			ans[i+j-1]=ans[i+j-1]+x+num1[i]*num2[j];
			x=ans[i+j-1]/10;
			ans[i+j-1]=ans[i+j-1]%10;
		}
		ans[i+num2[0]]=x;
		ans[0]=num1[0]+num2[0];
		while(ans[ans[0]]==0 && ans[0]>1)
		{
			ans[0]--;
		}
	}
}

void print()
{
	for(int i=ans[0];i>=1;i--)
	{
		printf("%d",ans[i]);
	}
	printf("\n");
}

4.高精度除法
(1).高精度除以单精度（高精度运算里最短的代码）

#include<string>
#include<iostream>
using namespace std;
string a,c;
int b,i,d;
int main()
{
    cin >> a >> b;
    for (;i<a.length();i++) a[i]-=48;
    for (i=0;i<a.length();i++) c.push_back((d*10+a[i])/b+48),d=(d*10+a[i])%b;
    for (i=0;c[0]==48;i++)c.erase(c.begin(),c.begin()+1);
    cout << c;
    return 0; 
}

(2).高精度除以高精度
C++的还不会（学会了补上 不太可能会去学），拿Python的凑一下~~

a , b = int(input()),int(input())
print (a // b)

（Python真香）

5.重定义运算符
我写的这个只适用于输入是低精度（你也可以自己把输入的运算符也一重载），然后结果是高（低）精度的输出，多次进行高精度运算会比较方便。
（注意数据的位数，我只开了500位，而且只写了乘法和除法的 加法和减法就随缘吧）
P1045 [NOIP2003 普及组] 麦森数
P1080 [NOIP2012 提高组] 国王游戏
这两个题可以试试水

// ============================================================
// #pragma GCC optimize(2)
// #pragma GCC optimize(3,"Ofast","inline")
// ============================================================
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <bitset>
#include <map>
#include <utility>
using namespace std;

const int maxn=1e6+10;
const int INF=0x3f3f3f3f;
const int mod=1e9+7;
const double eps=1e-6;

//
template<class T>
inline void read(T &res)
{
	char c;
	T flag=1;
	while((c=getchar())<'0'||c>'9') if(c=='-') flag=-1; res=c-'0';
	while((c=getchar())>='0'&&c<='9') res=res*10+c-'0'; res*=flag;
}

template<class T>
void write(T res)
{
    if(res<0) res=-res,putchar('-');
    if(res>=10) write(res/10);
    putchar('0'+res%10);
}
//

struct high_accuracy
{
    int data[510];
    high_accuracy()
    {
        memset(data,0,sizeof(data));
        data[0]=1;
    }
    high_accuracy(int x)     //这个是读入赋值
    {
        memset(data,0,sizeof(data));
        data[0] = 1;
        int digit = 1;
        while(x)
        {
            data[digit++] = x % 10;
            x /= 10;
        }
        data[0] = --digit;
    }
    high_accuracy operator *(const high_accuracy &x)    //高精乘
    {
        high_accuracy ans;
        int digit;
        for(int i = 1;i <= data[0];i++)
        {
            int ex = 0;
            for(int j = 1;j <= x.data[0];j++)
            {
                ans.data[i+j-1] = ans.data[i+j-1] + ex + data[i] * x.data[j];
                ex = ans.data[i+j-1] / 10;
                ans.data[i+j-1] = ans.data[i+j-1] % 10;
            }
            ans.data[i + x.data[0]] = ex;
            ans.data[0] = data[0] + x.data[0];
            while(ans.data[ans.data[0]]==0 && ans.data[0]>1)
            {
                ans.data[0]--;
            }
        }
        return ans;
    }
    high_accuracy operator /(const int &x)      //高精度除以低精度
	{
        high_accuracy ans;
        ans.data[0]=data[0];
        int rest = 0;
        for (int i = data[0]; i >= 1; i--) 
		{ 
            rest = rest * 10 + data[i];
            ans.data[i] = rest / x;
            rest %= x;
        }
        while (!ans.data[ans.data[0]] && ans.data[0]>1) ans.data[0]--; 
        return ans;
    }
};

ostream& operator << (ostream& out,const high_accuracy &x)        //这个可以直接输出ans
{
    for(int i = x.data[0];i >= 1;i--) out << x.data[i] ;
    return out;
}

int main()
{
    clock_t c1 = clock();
    /*----------------------------------------------------------*/
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
    //============================================================
    #ifdef LOCAL
        freopen("in.in","r",stdin);
        freopen("out.out","w",stdout);
    #endif
    //============================================================
    int a,b;
    cin >> a >> b;
    high_accuracy k(a);  //这样赋值
    cout << k << endl;   //这样输出
end:
    cerr << "Time Used:" << clock()-c1 << "ms" << endl;
    return 0;
}
Tr.TheDing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言中的重定向符号<与>总结
行者无疆
04-16 5308
首先说一下重定向运算符所遵循的规则： 1、重定向运算符将一个可执行（executable）程序（包括标准的操作系统命令）与一个数据文件连接起来，不能用于两个数据文件间的连接或者两个程序间的连接； 2、输入与输出文件被限定为 3、一般情况下操作符两边是不需要有空格的。 比如此文件编译后的可执行文件叫做test.exe #include int main (void){ ch
高精度高性能PI值计算程序设计和验证
zhangfuliang93的博客
06-05 2084
一、PI的计算方法 程序中实现了4类14种PI的计算方法，每种方法都实测过，确保计算结果的准确性，所有方法至少试验过1~10万位的求解，输出有效数字完全相同，并与y-cruncher等标准程序输出结果进行了对照。 Method 1-7为类Machin公式，也就是反正切函数的Taylor级数；程序中实现了传统累加法和P2B3模型法（P2B3模型的含义在后面章节有专门介绍） Method 10-16为类BBP级数，包括标准BBP级数、Fabrice Bellard级数，程序实现了传统累加法和P2B3/BB
c++类的单目和双目运算符的重定义
weixin_30822451的博客
11-25 305
这个里面需要注意的是对于双目运算符，像是加号，如果是复数加整数是一种情况，而整数加复数又是另一种情况，所以需要重定义两次。 而对于单目运算符，如果是前缀的，直接重定义就可以了，但是如果是后缀的，我们在声明的时候，加上一个 int 就行了。 #include <iostream> using namespace std; class D...
C++运算符重载
KamikazePilot的博客
07-28 721
C++的运算符重载笔记
C++: 运算符重载
e.g.:
04-06 1316
C++中允许在同一作用域中的某个运算符指定多个定义。 通过重定义（重载）C++内置的运算符，使用自定义类型的运算符。 重载的运算符由关键字 operator 要重载的运算符符号构成的。重载运算符需要一个返回类型和一个参数列表。 //两个Box相加 Box operator+(const Box&); Box operator+(const Box&，const Box&); 可重载运算符列表： 运算符 符号 双目算术运算符 + (加)，-(减), (乘)，/(除)，
C++结构体排序个人总结（运算符重定义，比较器）
Roy在编程
04-18 2569
前几天做蓝桥杯题目有一题有用到结构体排序，刚开始使用比较器，然后sort（）排序一下就可以，后来参考别人的代码发现还可以用运算符重定义，着实省事很多，省的再在结构体外面写一个比较器的方法，所以现在总结一下： 第一种：结构体内重定义 （‘    ’符号），然后sort就可以排序，初步估计sort方法是根据‘   ’符号排序，还未问老师，暂未证实，废话不多说，直接上代码 #include"iost
Accel：高精度视频语义分割
xinw，jegonzal}@ eecs.berkeley.edu摘要我们提出了Accel，这是一种新型的语义视频分割系统，通过结合两个网络分支的预测，以低推理成本实现了高精度：（1）参考分支，其提取参考关键帧上的高细节特征，并且使用帧到...
高精度语义分割的实例掩码投影
5178IMP：用于高精度语义分割的实例掩码投影傅承洋亚历山大山Berg Facebook AI摘要在这项工作中，我们提出了一个新的运营商，称为实例掩码投影（IMP），预测实例分割作为一个新的功能，语义分割项目。它还支持反向...
BigInteger （亿进制高精度）类设计实验报告
Shudderwock 的博客
03-22 251
课程设计题目：BigInteger（亿进制高精度）类设计实验 一、问题描述 C/C++ 语言中的 int 类型能表示的整数范围是−231-2^{31}−231~231−12^{31}-1231−1，unsigned int 类型能表示的整数范围是 000~232−12^{32}-1232−1，即 000~429496729542949672954294967295，所以，int 和 unsigned int 类型都不能存储超过10位的整数。有些问题需要处理的整数远远不止10位，这种大整数用C/C++语言的基
协同过滤算法中处理重磅炸弹偏见的方法及其效果
收到2021年2021年10月29日修订2021年11月28日接受2021年12月23日在线提供关键词：推荐系统协同过滤流行度偏差超精度度量A B S T R A C T协同过滤推荐算法容易受到流行度偏差的影响，将最受欢迎的项目重复地包含到...
高精度加法
xiayiding的博客
05-09 180
高精度是一种算法，通常用于计算long long 以上的不支持的数据。 虽然有时可以用unsigned long long ，但unsigned long long的范围是(0,2^32)。 不足以计算更大的数。 如果题目范围在0~18446744073709551615只间，那么，是可以使用的unsigned __int64的。 可题目给得更大了呢？ 那就需要用到高精度了，高精度可以利用字符串（string）来完成。 看一道最简单的题： 题目描述 求两个不超过200位的非负整数的和
C++重载运算符的高精度模板
Bing_News的博客
02-11 1154
#include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;string&gt; #include&lt;cstring&gt; using namespace std; bool c=false; class high_pricision{ public: int a[100001],lenth; void read() { ...
重载运算符---（超详细的保姆级教程）
热门推荐
一起刷题一起进步昂
07-22 1万+
运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。--百度将系统预定义的运算符，用于用户自定义的数据类型，这就是运算符重载。运算符重载的实质就是函数重载–b站通俗一点来说，就是编译软件本身的运算符不符合我们想要的运算符定义，我们需要重新定义运算符来达到我们的目的。比如我们定义一个名为xlx77的结构体，当我们想直接输出一个结构体的时候是不被允许的，我们就可以重新定义.........
C++重载，重写与重定义
人工智蟑的博客
12-09 361
总结了C++中函数重载，运算符重载，重写与重定义，以及其中的注意事项。
运算符重载的概念和规则
qq_36314864的博客
06-15 1979
运算符重载的概念 为什么我们需要运算符重载？因为自定义数据类型有时也需要使用运算符进行某些运算，比如加法运算，但是预定义的运算符的操作数只能是基本数据类型，所以自定义数据类型的运算需要进行运算符重载。 例如，有日期类Date声明如下： class Date { public: Date(int nYear, int nMonth, int nDay) { m_nYear=nYear; m_nMonth=nMonth; m_nDay=nDay; } // 构造函数 void show();
C++语言之重载运算符()/[]/++/-＞等运算符
随意的风的专栏
07-04 2620
operator操作符一文包括两种用法，一种是operatoroverloading(操作符重载)，一种是operatorcasting(操作隐式转换)。这是C++和pascal扩展运算符功能的方法，虽然样子古怪，但也可以理解一方面要使运算符的使用方法与其原来一致，另一方面扩展其功能只能通过函数的方式（c++中，“功能”都是由函数实现的)。为什么使用操作符重载？上面注意说明了利用operator关键字进行一些操作符的重新定义，使之更加满足自己业务的需要。httpshttpshttps。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值