AI 助理
备案控制台
开发者社区 大数据 文章 正文

大数模板

2017-11-06 1028
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 1.Java基本BigInteger：import java.util.*;import java.

1.Java基本BigInteger：

import java.util.*;
import java.math.*;

public class Test {
    public static void main(String[] args){
        //输入
        Scanner cin=new Scanner(System.in);
        BigInteger a=cin.nextBigInteger();  //BigInteger
        int b=cin.nextInt();    //Int
        double c=cin.nextDouble();  //Double
        String s=cin.nextLine();    //String
        String g=cin.next();
        while(cin.hasNext()){   //相当于!=EOF

        }

        //输出
        System.out.print(a);  //类似于cout<<…….;
        System.out.println(b);  //类似于cout<<……<<endl;
        System.out.printf("%d",c);  //类似于C中printf的功能

        //基础操作
        BigInteger Num=new BigInteger(s);   //将String转换为10进制BigInteger
        BigInteger Num1=new BigInteger(s,2);    //将指定进制String转换为10进制BigInteger

        BigInteger Add=a.add(Num);  //加
        BigInteger Substract=a.subtract(Num);   //减
        BigInteger Multiply=a.multiply(Num);    //乘
        BigInteger Divide=a.divide(Num);    //除
        BigInteger Remainder=a.remainder(Num);  //取余
        BigInteger Mod=a.mod(Num);
        BigInteger Pow=a.pow(b);    //次方b必须是Int
        BigInteger Gcd=a.gcd(Num);  //两BigInteger的最大公约数
        BigInteger Abs=a.abs();     //取绝对值
        BigInteger Max=a.max(Num);  //大值
        BigInteger Min=a.min(Num);  //小值
        boolean flag=a.equals(Num); //判等

        Num=BigInteger.ONE; //大数常量1
        Num=BigInteger.TEN; //大数常量10
        Num=BigInteger.ZERO;    //大数常量0
    }
}

2.Int型

#include <cstdio>  
#include <algorithm>  
#include <cmath>  
#include <iostream>  
#include <map>   
#include <queue>  
#include <cstdlib>  
#include <cstring>  
#include <string>  
#include <ctime>  
#include <vector>  

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;

const ll MOD = 1000000009;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const db PI = acos(-1);
const db ERR = 1e-8;

const int MAXN=9999; //最大存的最大数
const int MAXSIZE=9999; //重载中位数
const int DLEN=4;   //存的位数

class BigNum{ 
private: 
    int a[500];    //可以控制大数的位数 
    int len;       //大数长度
public: 
    BigNum(){
        len = 1;
        memset(a,0,sizeof(a));
    }   //构造函数
    BigNum(const int);       //将一个int类型的变量转化为大数
    BigNum(const char*);     //将一个字符串类型的变量转化为大数
    BigNum(const BigNum &);  //拷贝构造函数
    BigNum &operator=(const BigNum &);   //重载赋值运算符，大数之间进行赋值运算

    friend istream& operator>>(istream&,  BigNum&);   //重载输入运算符
    friend ostream& operator<<(ostream&,  BigNum&);   //重载输出运算符

    BigNum operator+(const BigNum &) const;   //重载加法运算符，两个大数之间的相加运算 
    BigNum operator-(const BigNum &) const;   //重载减法运算符，两个大数之间的相减运算 
    BigNum operator*(const BigNum &) const;   //重载乘法运算符，两个大数之间的相乘运算 
    BigNum operator/(const int   &) const;    //重载除法运算符，大数对一个整数进行相除运算

    BigNum operator^(const int  &) const;    //大数的n次方运算
    int    operator%(const int  &) const;    //大数对一个int类型的变量进行取模运算    
    bool   operator>(const BigNum & T)const;   //大数和另一个大数的大小比较
    bool   operator>(const int & t)const;      //大数和一个int类型的变量的大小比较

    void print();       //输出大数
}; 
BigNum::BigNum(const int b)     //将一个int类型的变量转化为大数
{ 
    int c,d = b;
    len = 0;
    memset(a,0,sizeof(a));
    while(d > MAXN)
    {
        c = d - (d / (MAXN + 1)) * (MAXN + 1); 
        d = d / (MAXN + 1);
        a[len++] = c;
    }
    a[len++] = d;
}
BigNum::BigNum(const char*s)     //将一个字符串类型的变量转化为大数
{
    int t,k,index,l,i;
    memset(a,0,sizeof(a));
    l=strlen(s);   
    len=l/DLEN;
    if(l%DLEN)
        len++;
    index=0;
    for(i=l-1;i>=0;i-=DLEN)
    {
        t=0;
        k=i-DLEN+1;
        if(k<0)
            k=0;
        for(int j=k;j<=i;j++)
            t=t*10+s[j]-'0';
        a[index++]=t;
    }
}
BigNum::BigNum(const BigNum & T) : len(T.len)  //拷贝构造函数
{ 
    int i; 
    memset(a,0,sizeof(a)); 
    for(i = 0 ; i < len ; i++)
        a[i] = T.a[i]; 
} 
BigNum & BigNum::operator=(const BigNum & n)   //重载赋值运算符，大数之间进行赋值运算
{
    int i;
    len = n.len;
    memset(a,0,sizeof(a)); 
    for(i = 0 ; i < len ; i++) 
        a[i] = n.a[i]; 
    return *this; 
}
istream& operator>>(istream & in,  BigNum & b)   //重载输入运算符
{
    char ch[MAXSIZE*4];
    int i = -1;
    in>>ch;
    int l=strlen(ch);
    int count=0,sum=0;
    for(i=l-1;i>=0;)
    {
        sum = 0;
        int t=1;
        for(int j=0;j<4&&i>=0;j++,i--,t*=10)
        {
            sum+=(ch[i]-'0')*t;
        }
        b.a[count]=sum;
        count++;
    }
    b.len =count++;
    return in;

}
ostream& operator<<(ostream& out,  BigNum& b)   //重载输出运算符
{
    int i;  
    cout << b.a[b.len - 1]; 
    for(i = b.len - 2 ; i >= 0 ; i--)
    { 
        cout.width(DLEN); 
        cout.fill('0'); 
        cout << b.a[i]; 
    } 
    return out;
}

BigNum BigNum::operator+(const BigNum & T) const   //两个大数之间的相加运算
{
    BigNum t(*this);
    int i,big;      //位数   
    big = T.len > len ? T.len : len; 
    for(i = 0 ; i < big ; i++) 
    { 
        t.a[i] +=T.a[i]; 
        if(t.a[i] > MAXN) 
        { 
            t.a[i + 1]++; 
            t.a[i] -=MAXN+1; 
        } 
    } 
    if(t.a[big] != 0)
        t.len = big + 1; 
    else
        t.len = big;   
    return t;
}
BigNum BigNum::operator-(const BigNum & T) const   //两个大数之间的相减运算 
{  
    int i,j,big;
    bool flag;
    BigNum t1,t2;
    if(*this>T)
    {
        t1=*this;
        t2=T;
        flag=0;
    }
    else
    {
        t1=T;
        t2=*this;
        flag=1;
    }
    big=t1.len;
    for(i = 0 ; i < big ; i++)
    {
        if(t1.a[i] < t2.a[i])
        { 
            j = i + 1; 
            while(t1.a[j] == 0)
                j++; 
            t1.a[j--]--; 
            while(j > i)
                t1.a[j--] += MAXN;
            t1.a[i] += MAXN + 1 - t2.a[i]; 
        } 
        else
            t1.a[i] -= t2.a[i];
    }
    t1.len = big;
    while(t1.a[t1.len - 1] == 0 && t1.len > 1)
    {
        t1.len--; 
        big--;
    }
    if(flag)
        t1.a[big-1]=0-t1.a[big-1];
    return t1; 
} 

BigNum BigNum::operator*(const BigNum & T) const   //两个大数之间的相乘运算 
{ 
    BigNum ret; 
    int i,j,up; 
    int temp,temp1;   
    for(i = 0 ; i < len ; i++)
    { 
        up = 0; 
        for(j = 0 ; j < T.len ; j++)
        { 
            temp = a[i] * T.a[j] + ret.a[i + j] + up; 
            if(temp > MAXN)
            { 
                temp1 = temp - temp / (MAXN + 1) * (MAXN + 1); 
                up = temp / (MAXN + 1); 
                ret.a[i + j] = temp1; 
            } 
            else
            { 
                up = 0; 
                ret.a[i + j] = temp; 
            } 
        } 
        if(up != 0) 
            ret.a[i + j] = up; 
    } 
    ret.len = i + j; 
    while(ret.a[ret.len - 1] == 0 && ret.len > 1)
        ret.len--; 
    return ret; 
} 
BigNum BigNum::operator/(const int & b) const   //大数对一个整数进行相除运算
{ 
    BigNum ret; 
    int i,down = 0;   
    for(i = len - 1 ; i >= 0 ; i--)
    { 
        ret.a[i] = (a[i] + down * (MAXN + 1)) / b; 
        down = a[i] + down * (MAXN + 1) - ret.a[i] * b; 
    } 
    ret.len = len; 
    while(ret.a[ret.len - 1] == 0 && ret.len > 1)
        ret.len--; 
    return ret; 
}
int BigNum::operator %(const int & b) const    //大数对一个int类型的变量进行取模运算    
{
    int i,d=0;
    for (i = len-1; i>=0; i--)
    {
        d = ((d * (MAXN+1))% b + a[i])% b;  
    }
    return d;
}
BigNum BigNum::operator^(const int & n) const    //大数的n次方运算
{
    BigNum t,ret(1);
    int i;
    if(n<0)
        exit(-1);
    if(n==0)
        return 1;
    if(n==1)
        return *this;
    int m=n;
    while(m>1)
    {
        t=*this;
        for( i=1;i<<1<=m;i<<=1)
        {
            t=t*t;
        }
        m-=i;
        ret=ret*t;
        if(m==1)
            ret=ret*(*this);
    }
    return ret;
}
bool BigNum::operator>(const BigNum & T) const   //大数和另一个大数的大小比较
{ 
    int ln; 
    if(len > T.len)
        return true; 
    else if(len == T.len)
    { 
        ln = len - 1; 
        while(a[ln] == T.a[ln] && ln >= 0)
            ln--; 
        if(ln >= 0 && a[ln] > T.a[ln])
            return true; 
        else
            return false; 
    } 
    else
        return false; 
}
bool BigNum::operator >(const int & t) const    //大数和一个int类型的变量的大小比较
{
    BigNum b(t);
    return *this>b;
}

void BigNum::print()    //输出大数
{ 
    int i;   
    cout << a[len - 1]; 
    for(i = len - 2 ; i >= 0 ; i--)
    { 
        cout.width(DLEN); 
        cout.fill('0'); 
        cout << a[i]; 
    } 
    cout << endl;
}

3.String型

string sum(string s1,string s2)  //大数加法  
{  
    if(s1.length()<s2.length())  
    {  
        string temp=s1;  
        s1=s2;  
        s2=temp;  
    }  
    int i,j;  
    for(i=s1.length()-1,j=s2.length()-1;i>=0;i--,j--)  
    {  
        s1[i]=char(s1[i]+(j>=0?s2[j]-'0':0));
        if(s1[i]-'0'>=10)  
        {  
            s1[i]=char((s1[i]-'0')%10+'0');  
            if(i) s1[i-1]++;  
            else s1='1'+s1;  
        }  
    }  
    return s1;  
}  

string sub(string a,string b)//减法
{
    string c;
    bool ok=0;
    int len1=a.length();
    int len2=b.length();
    int len=max(len1,len2);
    for(int i=len1;i<len;i++)
        a="0"+a;
    for(int i=len2;i<len;i++)
        b="0"+b;
    if(a<b)
    {
        string temp=a;
        a=b;
        b=temp;
        ok=1;
    }
    for(int i=len-1;i>=0;i--)
    {
        if(a[i]<b[i]) 
        {
            a[i-1]-=1;
            a[i]+=10;
        }
        char temp=a[i]-b[i]+'0';
        c=temp+c;
    }
    int pos=0;
    while(c[pos]=='0' && pos<len) pos++;
    if(pos==len) return "0"; 
    if(ok) return "-"+c.substr(pos);
    return c.substr(pos);
}

string Multiply(string s,int x)  //大数乘以整形数  
{  
    reverse(s.begin(),s.end());  
    int cmp=0;  
    for(int i=0;i<s.size();i++)  
    {  
        cmp=(s[i]-'0')*x+cmp;  
        s[i]=(cmp%10+'0');  
        cmp/=10;  
    }  
    while(cmp)  
    {  
        s+=(cmp%10+'0');  
        cmp/=10;  
    }  
    reverse(s.begin(),s.end());  
    return s;  
}  

string Multfa(string x,string y)  //大数乘法  
{  
    string ans;  
    for(int i=y.size()-1,j=0;i>=0;i--,j++)  
    {  
        string tmp=Mult(x,y[i]-'0');  
        for(int k=0;k<j;k++)  
            tmp+='0';  
        ans=sum(ans,tmp);  
    }  
    return ans;  
}  

string Multiply(string s,long x)  //大数乘以整形数  
{  
    reverse(s.begin(),s.end());  
    long cmp=0;  
    for(int i=0; i<s.size(); i++)  
    {  
        cmp=(s[i]-'0')*x+cmp;  
        s[i]=(cmp%10+'0');  
        cmp/=10;  
    }  
    while(cmp)  
    {  
        s+=(cmp%10+'0');  
        cmp/=10;  
    }  
    reverse(s.begin(),s.end());  
    return s;  
}  

string Except(string s,int x)  //大数除以整形数  
{  
    int cmp=0,ok=0;  
    string ans="";  
    for(int i=0;i<s.size();i++)  
    {  
        cmp=(cmp*10+s[i]-'0');  
        if(cmp>=x)  
        {  
            ok=1;  
            ans+=(cmp/x+'0');  
            cmp%=x;  
        }  
        else{  
            if(ok==1)  
                ans+='0';
        }  
    }  
    return ans;  
}  

int mod(string s,int x)//大数取余
{
    int len=s.length();
    int ans=0;
    for(int i=0;i<len;i++)
    {
        ans=(ans*10+s[i]-'0')%x;
    }
    return ans;
}

string factorial(string s,int n)   //浮点数的n次方  
{  
    if(n==0)  
        return "1";  
    string cmp="",count="";  
    long x=0,point=0;  
    for(int i=0; i<s.size(); i++)  
        if(s[i]!='.')  
        {  
            cmp+=s[i];  
            x=x*10+(s[i]-'0');  
        }  
        else  
            point=s.size()-1-i;  
    for(int i=1; i<n; i++)  
    {  
        cmp=Multiply(cmp,x);  
    }  
    int ans_point=cmp.size()-n*point;  
    if(ans_point<0)  
    {  
        count+='.';  
        for(int i=ans_point; i!=0; i++)  
            count+='0';  
    }  
    string::iterator it=cmp.begin();  
    if(ans_point>=0&&ans_point<cmp.size())  
        cmp.insert(it+ans_point,'.');  
    count+=(Remove_later(cmp));  
    return count;  
}  

string Remove_later(string s)   //删除一个字符串的后倒0  
{  
    for(int i=s.size()-1; i>=0; i--)  
    {  
        if(s[i]=='0')  
            s.erase(i);  
        else  
            break;  
    }  
    return s;  
}  

string solve(string s)//判等
{
    int len=s.length();
    bool ok=false;
    int x=0,y=len-1;
    for(int i=0;i<len;i++)
    {
        if(s[i]=='.')
        {
            ok=true;
            break;
        }
    }
    if(ok)
    {
        for(;y>=x;y--)
            if(s[y]!='0') break;
        if(s[y]=='.') y--;
    }
    for(;x<len-1;x++)
        if(s[x]!='0') break;
    if(s[x]=='.') x--;
    return s.substr(x,y-x+1);
}

bool equal(string s1,string s2)
{
    if(s1[0]=='-' && s2[0]=='-') 
    {
        s1=s1.substr(1);
        s2=s2.substr(1);
    }
    else if(s1[0]=='-' || s2[0]=='-')
    {
        if(s1[0]=='-') s1=s1.substr(1);
        if(s2[0]=='-') s2=s2.substr(1);
        s1=solve(s1);
        s2=solve(s2);
        if(s1=="0" && s2=="0") return true;
        return false;
    }
    if(s1[0]=='+') s1=s1.substr(1);
    if(s2[0]=='+') s2=s2.substr(1);
    s1=solve(s1);
    s2=solve(s2);
    if(s1==s2) return true;
    return false;
}
文章标签：
人工智能
BI
范文帝
目录
相关文章
coder一枚
|
11月前
|
弹性计算
阿里云服务器流量价格表（手动整理）
阿里云服务器流量怎么收费？地域不同流量价格也不同，北京、杭州、深圳等地域流量价格0.8元/GB，中国香港流量价格是1元每GB，阿里云百科网分享公网带宽按使用流量计费不同地域节点的收费价格表
coder一枚
354 2
阿里云服务支持
|
算法 Java 大数据
访问HBase经常出现报错：ServerNotRunningYetException: Server xxx.xxx.xxx is not running yet
访问HBase经常出现报错：ServerNotRunningYetException: Server xxx.xxx.xxx is not running yet
阿里云服务支持
227 0
vohelon
|
存储 SQL 分布式计算
ApsaraDB业务架构图
ApsaraDB业务架构图
vohelon
253 0
瓜子三百克
|
JavaScript
nuxt安装与IP端口配置nuxt安装与IP端口配置
一、Nuxt安装与运行 二、IP端口冲突与解决 三、使用终端查看某个端口号对应的进程和杀死进程 四、端口/IP端口配置
瓜子三百克
954 0
nuxt安装与IP端口配置nuxt安装与IP端口配置
果果小师弟
|
Ubuntu Linux Shell
嵌入式最强调试终端神器—MobaXterm
现今软件市场上有很多终端工具，比如：secureCRT、Putty等等。secureCRT其实也是一款很强大的终端工具，但它是收费软件，一般公司不允许使用。Putty，非常小巧，免费软件，但是不支持标签，开多个会话的话就需要开多个窗口，窗口切换不方便。这两个软件的界面都不太美观。
果果小师弟
556 0
嵌入式最强调试终端神器—MobaXterm
云效平台
|
运维 监控 安全
80%的时间在救火，传统运维如何快速成长不被淘汰？
自从《应对双11挑战,阿里巴巴自动化运维体系的演进和建设》文章发布以来，就引来了众多运维从业者的关注，大家不禁思考，无人化运维离我们有多远？我们如何成为运维领域的专家，不被淘汰？阿里巴巴运维中台技术专家宋意，整合了云效2.0运维产品StarOps，教大家如何利用工具把人从日常重复工作中解脱出来，向专业垂直领域纵深发展，逐步成长为领域专家。
云效平台
8722 0
云栖小秘书
|
机器学习/深度学习 大数据 数据处理
专访阿里巴巴林伟：三项世界级挑战背后的思考、实践和经验
今年双11，阿里云大数据平台扛住了巨大的技术挑战，主要体现在实时数据处理技术以及超大规模的离线数据处理两方面，来自阿里巴巴的资深技术专家林伟将为大家介绍双11前中后大数据计算平台对于整个双11的成功提供了哪些不可或缺的支持。
云栖小秘书
15009 0
游客jhk3u5um6zngg
|
Dart Java 开发工具
Flutter之环境配置与项目搭建
Flutter之环境配置与项目搭建
游客jhk3u5um6zngg
1975 0
德哥
|
SQL 关系型数据库 OLAP
PostgreSQL sharding : citus 系列5 - worker节点网络优化
标签 PostgreSQL , citus , pgbouncer , 网络优化 , worker节点 背景 citus 节点间的网络需求： 1、cn节点访问所有worker节点。oltp业务的访问较频繁。
德哥
1510 0
EdgePlus
|
运维 网络协议 调度
阿里视频云曾福华：世界杯百T级CDN智能流量调度系统的实战分享
在刚刚落幕的重庆云栖上，阿里云高级技术专家仔晟为现场观众带来议题《百T级CDN智能流量调度系统的实战分享》，重点介绍了在世界杯直播业务场景之下，阿里云CDN的产品架构、技术方案与客户实践。
EdgePlus
9985 0