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

大数模板

2017-11-06 1042
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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
范文帝
目录
相关文章
acdante
|
Oracle 关系型数据库
Oracle OGG 单表重新初始化同步的两种思路
OGG 单表重新初始化同步的两种思路
acdante
4413 0
hello533
|
24天前
|
传感器 监控 JavaScript
千套单片机\stm32毕设课设题目及资料案列-干货分享
为帮助电子工程领域的学习者顺利毕业或掌握更多专业知识，我们精心整理了一系列单片机和STM32相关的题目及资料案例。这些资源覆盖了从毕业设计到课程设计的各个方面，包括但不限于智能小车、温度控制系统、无线通信、智能家居等多个领域。每项设计都配有详细的原理图、仿真图以及完整的文档资料，旨在帮助学生深入理解理论知识的同时，提高实际动手操作能力。无论是初学者还是有一定基础的学生，都能从中找到适合自己的项目进行实践探索。
hello533
92 8
sunrr
|
4月前
|
存储 弹性计算 运维
阿里云容器服务Kubernetes版（ACK）部署与管理体验评测
阿里云容器服务Kubernetes版（ACK）是一个功能全面的托管Kubernetes服务，它为企业提供了快速、灵活的云上应用管理能力。
sunrr
168 2
小蚂蚁XMY
|
6月前
|
小程序 开发者 索引
微信小游戏如何接入多种类型的广告？
微信小游戏如何接入多种类型的广告？
小蚂蚁XMY
260 1
落寞的鱼
|
数据安全/隐私保护
CTF 隐写工具Steghide
CTF 隐写工具Steghide
落寞的鱼
459 0
游客mgyx2kmo6h5zo
|
安全 Ubuntu 测试技术
kali介绍
本篇主要介绍Kali系统和用于渗透测试的靶机系统，内容包括kali的发展过程、kali的功能、kali系统的安装和基本设置，以及目前流行的几种靶机系统介绍
游客mgyx2kmo6h5zo
7211 0
kali介绍
浅羽技术
|
IDE 前端开发 关系型数据库
吐血推荐｜2万字总结Mac所有应用程序、软件工具和相关资料
现在随着互联网的发展，越来越多的公司都鼓励Mac办公，属实MacOS系统对于我们的工作开发效率有很大提升，所以我们需要收集各种类别非常好用的 Mac 应用程序、软件以及工具。作为一个资深...
浅羽技术
896 0
中间件小哥
|
运维 Kubernetes API
Kubernetes operator 模式开发实践
0. 前言 近日我们在开发符合我们业务自身需求的微服务平台时，使用了 Kubernetes 的 Operator Pattern 来实现其中的运维系统，在本文，我们将实现过程中积累的主要知识点和技术细节做了一个整理。
中间件小哥
2782 5
whiletrue
|
消息中间件 Java Kafka
为什么要用java重写logstash
         写之前，这里先打个广告，java 版本的logstash已经开源，git地址 https://github.com/dtstack。          现在ELK很流行，能快速搭建一套日志采集系统。其实自己一开始就不理解为什么后端日志采集这一层logstash 是用ruby来编写
whiletrue
11728 0
隐林
|
SQL Web App开发 存储
帮助企业做好MaxCompute大数据平台成本优化的最佳实践
阿里云大数据计算服务MaxCompute通过灵活性、简单性和创新为您企业的业务环境带来了变革，但是您企业是否通过其实现了原本预期的节省成本的目标呢?本文中，我们将为广大读者诸君介绍优化您企业MaxCompute开销的一些关键性的策略。
隐林
5527 0