高精度压位（亿进制）模板

最新推荐文章于 2023-01-04 19:30:00 发布
最新推荐文章于 2023-01-04 19:30:00 发布
阅读量392 收藏
点赞数
分类专栏： 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/long_hen/article/details/105023965
版权 
#include<cstdio>
#include<cstring>
using namespace std;
typedef long long LL;
const int base = 1e8;
const int N = 1001;
int aux[N];//储存原始数据 
class HighPrecision{//高精度压位模板 
	private:
		int p[N], sz;//类的私有成员 
	public://区域一:
		void cin() {//读入函数 
			this -> clear();//清空对象 
			memset(aux, 0, sizeof(aux));
	        int tot = 0,x = 0, y, k = 1;
	        char ch = getchar();
	        
	        int fu = 1; //符号判断
	        for (; ch < '0' || ch > '9'; ch = getchar()) 
				if (ch == '-') fu *= -1;
				
	        for (; ch >= '0' && ch <= '9'; ch = getchar()){
	            if(tot==1&&aux[tot]==0)aux[tot] = ch - '0';
	            else aux[++tot] = ch - '0';//处理前缀零和读入零的情况 
	        }
	        sz = (tot + 7) / 8;//计算位数 
			y = (tot - 1) % 8 + 1;//最高位标记 
	        for (int i = tot; i >= y; i -= 8, x=0){
	        	for(int j=7;j>=0;--j){//压位(亿进制) 
	        		if(i <= j)continue;//最高位处理 
	        		x = x * 10 + aux[i - j];
				}
				p[k++] = x;//对每一位进行储存 
			}
			p[sz] *= fu;//标记符号 
	    }
		void cout(bool u = false){//读出函数 
			if(sz == 0) { printf("inf"); return;}//异常状况 
			printf("%d", p[sz]);//先输出首位带符号 
			for(int i = sz - 1; i; --i)
				printf("%08d", p[i]);
			if(u) printf("\n");//换行 
		} 
	public://区域二： 
		HighPrecision operator = (const int &d){//重载= (int)
			int b = d;
			
			int fu = 1;//符号判断 
			if(b < 0) b *= -1, fu = -1;
			
			this -> clear();//清空对象 
			do {//用do~while处理d为零的状况 
				p[++sz] = b % base;
				b /= base;
			} while(b);
			p[sz] *= fu;
        	return *this;
		}
		HighPrecision operator = (const LL &d){//重载= (long long) 
			LL b = d;
			
			int fu = 1;//符号判断			
			if (b < 0) b *= -1, fu = -1; 
			
			this -> clear();//清空对象 
			do {//用do~while处理d为零的状况 
				p[++sz] = b % base;
				b /= base;
			} while(b);
			p[sz] *= fu;//标记符号 
        	return *this;
		}
		HighPrecision operator + (const int &d){//重载+ (int)
			LL x = d;
			
			int fu = 1;//符号判断 
			HighPrecision c;
			if (p[sz] < 0 && x < 0) p[sz] *= -1, x *= -1, fu = -1;
			else if (p[sz] < 0) {p[sz] *= -1; return (c = x) - *this;}
			else if (x < 0) {x *= -1; return *this - x;}
			
			for (int i = 1; i <= sz && x; ++i) {//进位计算 
				x = x + p[i];
				p[i] = x % base;
				x = x / base;
			}
			if (x) p[++sz] = x;//进位 位数+1 
			p[sz] *= fu;
			return *this;
		}   
		HighPrecision operator + (const LL &d){//重载+ (long long)
			LL x = d;
			
			int fu = 1;//符号判断 
			HighPrecision c;
			if (p[sz] < 0 && x < 0) p[sz] *= -1, x *= -1, fu = -1;
			else if (p[sz] < 0) {p[sz] *= -1; return (c = x) - *this;}
			else if (x < 0) {x *= -1; return *this - x;}
			
			for (int i = 1; i <= sz && x; ++i) {//进位计算 
				x = x + p[i];
				p[i] = x % base;
				x = x / base;
			}
			if (x) p[++sz] = x;//进位 位数+1 
			p[sz] *= fu;
			return *this;
		}   
		HighPrecision operator + (const HighPrecision &d){//重载+ (HighPrecision)
			HighPrecision c, a = *this, b = d;
			
			int fu = 1;//符号判断 
			if (a.p[a.sz] < 0 && b.p[b.sz] < 0) a.p[a.sz] *= -1, b.p[b.sz] *= -1, fu = -1;
			else if (a.p[a.sz] < 0) {a.p[a.sz] *= -1; return b - a;}
			else if (b.p[b.sz] < 0) {b.p[b.sz] *= -1; return a - b;}
			
			if (a < b) a.swap(b);//a为大值,方便计算 
			if (b.sz < 3) {c = a + b.toLL(); c.p[c.sz] *= fu; return c;}//节省时间 
			LL x = 0;
			for(int i = 1; i <= a.sz; ++i) {
				x = x + a.p[i] + b.p[i];
				c.p[i] = x % base;
				x = x / base; 
			} 
			c.sz = a.sz;
			if (x) c.p[++c.sz] = x;//进位 位数+1 
			c.p[c.sz] *= fu;//标记符号 
			return c;
		}
		HighPrecision operator - (const HighPrecision &d){//重载- (HighPrecision)
			HighPrecision a = *this, c, b = d;
			
			int fu = 1;//符号判断 
			if(a.p[a.sz] < 0 && b.p[b.sz] < 0) a.p[a.sz] *= -1, b.p[b.sz] *= -1, fu *= -1;
			else if (a.p[a.sz] < 0) {a.p[a.sz] *= -1;c = a + b; c.p[c.sz] *= -1; return c;}
			else if (b.p[b.sz] < 0) {b.p[b.sz] *= -1; return a + b;}  
			
			LL x = 1, k = 0;
			if(a<b) a.swap(b), fu *= -1;
			if(a == b)return c = 0;//特殊情况直接输出 
			for(int i = 1; i <= a.sz; ++i){//借位计算 
				x = x + a.p[i] + base -1 - b.p[i]; 
				c.p[i] = x % base;
				x = x / base;   
			}
			for(c.sz = a.sz; c.p[c.sz] == 0; --c.sz);//计算c.sz 
			c.p[c.sz] *= fu;//符号标记 
			return c;
		}
		HighPrecision operator - (const int &d){//重载- (int)
			HighPrecision c;
			int b = d;
			
			int fu = 1;//符号判断 
			if(p[sz] < 0 && b < 0) p[sz] *= -1, b *= -1, fu *= -1;
			else if (p[sz] < 0) {p[sz] *= -1;c = *this + b; c.p[c.sz] *= -1; return c;}
			else if (b < 0) {b *= -1; return *this + b;}
			
			c=*this - (c = b);
			c.p[c.sz] *= fu;//符号标记 
			return c;
		}
		HighPrecision operator - (const LL &d){//重载- (long long)
			HighPrecision c;
			LL b = d;
			
			int fu = 1;//符号判断 
			if(p[sz] < 0 && b < 0) p[sz] *= -1, b *= -1, fu *= -1;
			else if (p[sz] < 0) {p[sz] *= -1;c = *this + b; c.p[c.sz] *= -1; return c;}
			else if (b < 0) {b *= -1; return *this + b;}
			
			c=*this - (c = b);
			c.p[c.sz] *= fu;//符号标记 
			return c;
		}
		HighPrecision operator * (const int &d){//重载* (int)
			HighPrecision a=*this,c;
			int b = d;
			
			int fu = 1;//符号判断 
			if(a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1; 
			if(b < 0) b *= -1, fu *= -1;
			
 			LL x = 0;
			if(b == 0||a.sz == 1 && a.p[a.sz] == 0) return c = 0;
			for(int i = 1; i <= a.sz; ++i){
				x = x + 1ll * a.p[i] * b;
				c.p[i] = x % base;
				x = x / base;
			}
			c.sz = a.sz;//计算c.sz 
			for(; x; x /= base){
				c.p[++c.sz] = x % base;
			}	
			c.p[c.sz] *= fu;//符号标记 
			return c;
		} 
		HighPrecision operator * (const HighPrecision &d){//重载* (HighPrecision)
			HighPrecision a =* this, b = d, c;
			
			int fu = 1;//符号判断 
			if(a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1; 
			if(b.p[b.sz] < 0) b.p[b.sz] *= -1, fu *= -1;
			
			if(a < b) a.swap(b);
			if(b.sz < 2) return a * b.toLL(fu);
			if(b.sz == 1 && b.p[b.sz] == 0) return c = 0;
			LL x=0;
			
			for (int i = 1; i < a.sz + b.sz || x; ++i){//按位依次求出 
				int l = 1, r = b.sz, k = i;
				if (i <= b.sz) r = i;
				if (i >  a.sz) l = i - a.sz + 1, k = a.sz;
				for(int j = l; j <= r; ++j, --k){
					x += 1ll * a.p[k] * b.p[j]; //注意数值范围 
				}
				c.p[++c.sz] = x % base;
				x = x / base;
			}
			c.p[c.sz] *= fu;//符号标记 
			return c;
		} 
		HighPrecision operator * (const LL &d){//重载* (long long)
			HighPrecision a=*this,c;
			LL b=d;
			
			int fu = 1;//符号判断 
			if(a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1; 
			if(b < 0) b *= -1, fu *= -1;
			
			if(d > 2e9) return a * (c = d);
 			LL x = 0;
			if(b == 0||a.sz == 1 && a.p[a.sz] == 0) return c = 0;
			for(int i = 1; i <= a.sz; ++i){
				x = x + 1ll * a.p[i] * b;
				c.p[i] = x % base;
				x = x / base;
			}
			c.sz = a.sz;//计算c.sz 
			for(; x; x /= base){
				c.p[++c.sz] = x%base;
			}	
			c.p[c.sz] *= fu; //符号标记 
			return c;
		}
		HighPrecision operator / (const int &d){//重载/ (int) 
			HighPrecision a=*this, c;
			int b=d;
			
			int fu = 1;//判断符号
			if (a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1;
			if (b < 0) b *= -1, fu *= -1; 
			
			LL x=0;
			if (b == 0) return c;//除数为零 抛出异常状况 
			for(int i = a.sz; i; --i){
				x = x * base + a.p[i];
				c.p[i] = x / b;
				x = x % b;
			} 
			for(c.sz = a.sz; c.p[c.sz] == 0 && c.sz > 1; --c.sz);
			c.p[c.sz] *= fu; //符号标记 
			return c;
		}
		HighPrecision operator / (const LL &d){//重载/ (long long)
			HighPrecision a=*this, c;
			LL b=d;
			
			int fu = 1;//判断符号
			if (a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1;
			if (b < 0) b *= -1, fu *= -1; 
			
			LL x=0;
			if (b == 0) return c;//除数为零 抛出异常状况 
			for(int i = a.sz; i; --i){
				x = x * base + a.p[i];
				c.p[i] = x / b;
				x = x % b;
			} 
			for(c.sz = a.sz; c.p[c.sz] == 0 && c.sz > 1; --c.sz); 
			c.p[c.sz] *= fu;//符号标记 
			return c;
		}
		HighPrecision operator / (const HighPrecision &d){//重载/ (HighPrecision) 
			HighPrecision a=*this,b=d,c,ce; 
			
			int fu = 1;//判断符号
			if (a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1;
			if (b.p[b.sz] < 0) b.p[b.sz] *= -1, fu *= -1; 
			
			if(b.sz == 1 && b.p[b.sz] == 0) return c;//除数为零 抛出异常状况 
			if (a <  b) return c = 0;//被除数小于除数 
			if (a == b) return c = 1;//被除数等于除数 
	        if (b.sz < 2) return a / b.toLL(fu);
	        for(int i = a.sz; i; --i){
	        	for(int j = ++ce.sz; j > 1; --j)//模拟进位 
	        		ce.p[j] = ce.p[j-1];
	        	ce.p[1] = a.p[i];
				if (ce < b) continue;//商为零 直接跳过 
				int l = 0, r = base, x;
				while(l <= r) {//二分查找商 
					int mid = l + r >> 1; 
					if (b  * mid <= ce) {
						x = mid;
						l = mid + 1;
					}
					else {
						r = mid - 1; 
					}
				} 
				c.p[i] = x; 
				ce = ce - b * x;
			}
			for(c.sz = a.sz; c.p[c.sz] == 0 && c.sz > 1; --c.sz);
			c.p[c.sz] *= fu; //符号标记 
	        return c;
		}
		HighPrecision operator % (const int &d){//重载% (int) 
			HighPrecision a=*this, c;
			int b=d;
			
			int fu = 1;//判断符号
			if (a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1;
			if (b < 0) b *= -1, fu *= -1; 
			
			LL x=0;
			if (d == 0) return c;//除数为零 抛出异常状况 
			for(int i = a.sz; i; --i){
				x = (x * base + a.p[i]) % b;
			} 
			return c = x * fu;
		}
		HighPrecision operator % (const LL &d){//重载% (long long)
			HighPrecision a=*this, c;
			LL b=d;
			
			int fu = 1;//判断符号
			if (a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1;
			if (b < 0) b *= -1, fu *= -1; 
			
			LL x=0;
			if (d == 0) return c;//除数为零 抛出异常状况 
			for(int i = a.sz; i; --i){
				x = (x * base + a.p[i]) % b;
			} 
			return c = x * fu;
		}
		HighPrecision operator % (const HighPrecision &d){//重载% (HighPrecision) 
			HighPrecision a=*this,b=d,ce; 
			
			int fu = 1;//判断符号
			if (a.p[a.sz] < 0) a.p[a.sz] *= -1, fu *= -1;
			if (b.p[b.sz] < 0) b.p[b.sz] *= -1, fu *= -1; 
			
			if (b.sz == 1 && b.p[b.sz] == 0) return ce;//除数为零 抛出异常状况 
			if (a <  b) return a;//被除数小于除数 
			if (a == b) return ce = 0;//被除数等于除数 
	        if (b.sz < 2) return a % b.toLL(fu);
	        for(int i = a.sz; i; --i){
	        	if (!(ce.sz == 1 && ce.p[ce.sz] == 0))
		        	for(int j = ++ce.sz; j > 1; --j)//模拟进位 
		        		ce.p[j] = ce.p[j-1];
	        	ce.p[1] = a.p[i];
				if (ce < b) continue;//商为零 直接跳过 
				int l = 0, r = base, x;
				while(l <= r) {//二分查找商 
					int mid = l + r >> 1;
					if (ce < b * mid) {
						r = mid - 1;
					}
					else {
						x = mid;
						l = mid + 1; 
					}
				} 
				ce = ce - b * x;
			} 
			ce.p[ce.sz] *= fu; //符号标记 
	        return ce;
		}
	public://区域三： 
		HighPrecision operator += (int &b) {return *this = *this + b;}
		HighPrecision operator -= (int &b) {return *this = *this - b;}
		HighPrecision operator *= (int &b) {return *this = *this * b;}
		HighPrecision operator /= (int &b) {return *this = *this / b;}
		HighPrecision operator %= (int &b) {return *this = *this % b;}
		HighPrecision operator += (LL  &b) {return *this = *this + b;}
		HighPrecision operator -= (LL  &b) {return *this = *this - b;}
		HighPrecision operator *= (LL  &b) {return *this = *this * b;}
		HighPrecision operator /= (LL  &b) {return *this = *this / b;}
		HighPrecision operator %= (LL  &b) {return *this = *this % b;}
		HighPrecision operator += (HighPrecision &b) {return *this = *this + b;}
	    HighPrecision operator -= (HighPrecision &b) {return *this = *this - b;}
	    HighPrecision operator *= (HighPrecision &b) {return *this = *this * b;}
	    HighPrecision operator /= (HighPrecision &b) {return *this = *this / b;}
	    HighPrecision operator %= (HighPrecision &b) {return *this = *this % b;}
	    bool operator <  (const int &b) const {HighPrecision c;return *this <  (c=b);}
	    bool operator <= (const int &b) const {HighPrecision c;return *this <= (c=b);}
	    bool operator >  (const int &b) const {HighPrecision c;return *this >  (c=b);}
	    bool operator >= (const int &b) const {HighPrecision c;return *this >= (c=b);}
	    bool operator == (const int &b) const {HighPrecision c;return *this == (c=b);}
	    bool operator != (const int &b) const {HighPrecision c;return *this != (c=b);}
	    bool operator <  (const LL  &b) const {HighPrecision c;return *this <  (c=b);}
	    bool operator <= (const LL  &b) const {HighPrecision c;return *this <= (c=b);}
	    bool operator >  (const LL  &b) const {HighPrecision c;return *this >  (c=b);}
	    bool operator >= (const LL  &b) const {HighPrecision c;return *this >= (c=b);}
	    bool operator == (const LL  &b) const {HighPrecision c;return *this == (c=b);}
	    bool operator != (const LL  &b) const {HighPrecision c;return *this != (c=b);}
		bool operator == (const HighPrecision &b) const {if(sz^b.sz)return false;
			for (int     i=sz;i;i--) if(p[i] ^ b.p[i]) return false;         return true ;}
		bool operator != (const HighPrecision &b) const {if(sz^b.sz)return true ;
			for (int     i=sz;i;i--) if(p[i] ^ b.p[i]) return true ;         return false;}
	    bool operator <  (const HighPrecision &b) const {if(sz^b.sz)return sz<b.sz;
			for (int     i=sz;i;i--) if(p[i] ^ b.p[i]) return p[i] < b.p[i]; return false;}
		bool operator <= (const HighPrecision &b) const {if(sz^b.sz)return sz<b.sz;
			for (int     i=sz;i;i--) if(p[i] ^ b.p[i]) return p[i] < b.p[i]; return true ;}
	    bool operator >  (const HighPrecision &b) const {if(sz^b.sz)return sz>b.sz;
			for (int     i=sz;i;i--) if(p[i] ^ b.p[i]) return p[i] > b.p[i]; return false;}
	    bool operator >= (const HighPrecision &b) const {if(sz^b.sz)return sz>b.sz;
			for (int     i=sz;i;i--) if(p[i] ^ b.p[i]) return p[i] > b.p[i]; return true ;}	    
	public://区域四:
		HighPrecision() {clear();}//重载构造函数 
		HighPrecision(int x) {*this = x;}
		HighPrecision(LL  x) {*this = x;} 
		void clear() {sz = 0; memset(p, 0, sizeof(p));}//清空函数 
		void swap(HighPrecision &b) {HighPrecision c = *this; *this = b; b = c;}//交换函数 
		LL toLL(int fu = 1) {//化值函数 
			LL x = 0;
			if (p[sz] < 0) 
				p[sz] *= -1, fu = -1;
			for(int i=sz;i;--i)
				x=x*base+p[i];
			return x * fu;
		}
//区域一：输入输出 、区域二：四则运算 、区域三：基础配置 、区域四：辅助函数 
} a, b;
int main(){
	a.cin(); b.cin();//输入 
	(a + b).cout(1); //A + B 
	(a - b).cout(1); //A - B
	(a * b).cout(1); //A * B
	(a / b).cout(1); //A / B
	(a % b).cout(1); //A % B
	return 0;
}
Daowuu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
高精度模板
11-16
高精度模板，整合了多篇文档，有高精度加法，高精度减法，高精度乘法，高精度除法，高精度取模法等模板...
【原创】高精度(压位储存)模板
Gregory99174的博客
05-20 93
无聊写了个高精度模板玩玩...... (以前有些地方写错了TAT) 1 /* 2 唐代李白 3 《江夏别宋之悌》 4 楚水清若空，遥将碧海通。人分千里外，兴在一杯中。 5 谷鸟吟晴日，江猿啸晚风。平生不下泪，于此泣无穷. 6 */ 7 #include <iostream> 8 #include <cstdio&...
C++中高精度模板全解析
Stone 不会喝水的博客
01-21 755
高精度 用字符串或字符数组输入， 用数组存储与运算， 用数组输出结果 高精度加法 #include<iostream> #include<cstring> using namespace std; char s1[505],s2[505]; int a[505],b[505],c[505]; int main(){ int m,n,v,t; std::ios...
压位的高精度大数模板
weixin_30466039的博客
01-26 87
#include<iostream> #include<cstdio> #include<cmath> #include<cstdlib> #include<algorithm> #include<cstring> #include<string> #include<vector&...
高精度压位模板
eliforsharon的博客
08-30 346
#include #include #include #include #include #include #define inf 1000000000] #define p 9 using namespace std; void _scanf(int &x){ char ch=getchar(); bool f=0; x=0; while(!isdigit(ch)) { if(ch==
高精度模板【重载运算符+压位】
weixin_30788239的博客
10-20 213
昨天做一道DP的题（矩阵取数游戏），本来是很简单的，但是要用高精度，又不想用__int128水过去（谁让NOIP不让），于是自己打了一个小时，最后成功挂了。。。 于是本蒟蒻痛定思痛，感觉高精度还是重载运算符好用啊，就花了几个小时打了一个自以为比较好记好用高精度模板： 注意暂不支持负数，如果发现有bug欢迎指出。 /*采用重载运算符，压B位 支持高精数赋值与输出、高精加(减)高精、高...
高精度计算（+-*/）（压位计算）（c++实现）
weixin_60257971的博客
11-24 929
进来的时候如果没看见除法，说明我也还不会，会了的话我会补充上去的。如果要看的除法的，得去看别人的了。 目录 初始化： 加法： 减法： 乘法： 输出：这个是重点！！！！！！！！！！！ 完整代码： 如果你是从我的“P1601 A+B Problem（高精）”这篇文章来的话，可以看一下压位计算，更加的快捷方便。 高精度计算就是因为超过了数据表达的类型，从用其他的方式来进行计算。 压位就是说将一长串的数字分割开来，来单独进行保存，从而不会发生超过范围。 初始化： 可以看到 k 其...
逝压位的高精度模板
mornstar_的博客
01-04 95
总的来说只是一时兴起，没想到写了这么久（）。不过总算是赶完了，全部数压的都是8位，long long，支持负数，高精度整除，取余，以及除了位运算的操作符都有。可惜的一点是没有用vector，数组大小得自己调，但是压的位数也可以调。代码整体还有许多瑕疵，但我不会，也没精力调，希望大家可以多提一点建议。代码就放在这里（也许以后可以讲一下压位高精？长就对了，高精度怎么可能短。
高精度模板（压位版）
qq_37816449的博客
10-29 529
（这次没偷懒，加减乘除模开方都有。。） 一直不想写压位，直到。。。。。。。。。。 遇到了一道会卡不压位高精度的题，心痛到无法呼吸 而且是在考试的时候。。。。。。。。。。 于是临时推，发现压位的输入输出真的是恶心 但是压位的优点也是明显的：速度快，内存低 缺点在于，如果让你保留一定位数的话，不到万不得已别写这玩意儿 以及在高精度除以整型时，如果整型过大，是会炸掉的。 关于
高精度类（压位）C++实现
06-03
高精度压位 #include #include #include using namespace std; const int maxleng=500; class BigInt { private: int leng; int num[maxleng]; public:
压位高精度模板，支持负数
04-25
自己写的压位高精度支持负数，保证无bug，单精高精运算时不会像其他人一样偷懒直接类型转换再运算，会很慢，可以+-*/%以及快速幂，压位大小可以自己改(不过输出流重载的地方也要改一下)
高精度运算(C++)模板
04-02
模板 仅供参考 最基本的 高精度 模板 万进制 压缩
常用算法模板_C++.zip
04-27
AC自动机，Dijkstra，Floyd，GCD，KMP，KMP扩展，Kruskal，LCM，LCS，LIS，Prim，SPFA，埃氏筛，背包，并查集，多边形面积，二分搜索，高精度加法，高精度阶乘，级角排序，进制转换，快速幂，判断线段相交，求三角形...
wide-decimal：Wide-Decimal实现了一个通用的C ++模板，用于最多约一百万个数字的大十进制浮点类型
02-14
宽十进制宽十进制为扩展精度十进制浮点类型实现通用C ++模板。 此C ++模板仅标头库实现了dec101_t大十进制浮点类型，例如dec101_t ， dec10001_t ， dec1000001_t等，其本质上可以像常规的内置浮点类型一样使用。 宽...
ACM算法模板和pku代码
11-09
高精度 计算几何 Graham扫描法 两线段交点 凸多边形面积 半平面交 计算几何库 数据结构 闭散列法整数hash 开散列法整数hash 字符串hash 堆 二维树状数组 Trie树 二叉查找树 线段树 RMQ LCA+RMQ SB-...
infrared-remote-candroid studiodemo
最新发布
05-05
android studio下载
高精度十进制转二进制
10-05
1. 将高精度十进制数从最高位开始不断除以2，得到商和余数。 2. 将余数记录下来，然后将商作为新的被除数，重复步骤1，直到商为0为止。 3. 将记录的余数按照从低位到高位的顺序排列，得到二进制数。 例如，将十进制...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值