大数(板子整理)

转载 于 2019-08-18 10:24:52 发布
· 449 阅读 · 1 ·
版权
原文链接：https://ac.nowcoder.com/acm/contest/view-submission?submissionId=411,https://www.cnblogs.com/superxuezhazha/p/4761854.html
文章标签：

#java大数 #c++大数 #python3

知识总结

java大数 导入java.math.BigInteger类，然后就是BigInteger的常用函数了

多敲就能熟练，常用的不多，加减乘除取模吧

思路来源

https://www.cnblogs.com/superxuezhazha/p/4761854.html

常用用法

1.valueOf(parament); 将参数转换为制定的类型

  比如 int a=3;

  BigInteger b=BigInteger.valueOf(a);

  则b=3;

  String s=”12345”;

  BigInteger c=BigInteger.valueOf(s);

  则c=12345；


2.add(); 大整数相加

BigInteger a=new BigInteger(“23”);

BigInteger b=new BigInteger(“34”);

a.      add(b);


3.subtract(); 相减

4.multiply(); 相乘

5.divide();    相除取整

6.remainder(); 取余

7.pow();   a.pow(b)=a^b

8.gcd();   最大公约数

9.abs(); 绝对值

10.negate(); 取反数

11.mod(); a.mod(b)=a%b=a.remainder(b);

12.max(); min();

13.public int compareTo();

14.boolean equals(); 是否相等

15.BigInteger构造函数：

BigInteger a,b;

a=a.add(b);

a=a.substract(b);

a=a.multiply(b);

a=a.divied(b);

a=a.gcd(b);

板子整理

import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner cin=new Scanner (new BufferedInputStream(System.in));
        PrintWriter cout=new PrintWriter(System.out);
        BigInteger a,b,c,d;
        a=cin.nextBigInteger();
        b=cin.nextBigInteger();
        c=cin.nextBigInteger();
        d=cin.nextBigInteger();
        if(a.compareTo(b)<0)//此时由于a<b，则返回值小于0；
        {
            System.out.println("a<b");
        }
        if(b.equals(c))//此时由于b==c,则返回值等于0；
        {
            System.out.println("b==c");
        }
        if(d.compareTo(c)>0)//此时由于d>c，则返回值大于0；  
        {
            System.out.println("d>c");
        }
        int t;
        t=cin.nextInt();
        int eg=1;
        while(t>0)
        {
            BigInteger eight=new BigInteger("8");
            BigInteger seven=new BigInteger("7");
            BigInteger one=new BigInteger("1");
            String inp;
            inp=cin.next();
            BigInteger n=new BigInteger(inp);
            BigInteger ans;
            BigInteger ans2;
            ans=n.multiply(n).multiply(eight);
            ans2=n.multiply(seven);
            ans=ans.subtract(ans2);
            ans=ans.add(one);
            cout.println("Case #"+eg+": "+ans);
            ++eg;
            --t;
            
        }
        cout.flush();
    }

}

C++大数

牛客多校，借鉴了国防科技大学队伍的板子，万分感谢

/*#include<iostream>
#include<cstdio>
#include<vector>
#include<cmath>
#include<cstring>
#include<algorithm>*/
typedef long long ll;
typedef unsigned long long ull;
const double PI = 4.0*atan(1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int NINF = -INF -1;
const int BASE = 1000000000;
const int BASEDIGITS = 9;
using namespace std;
struct bint
{
    vector<int> s;
    char sign;
    bint(): s(), sign(1) {}
    bint(const ll &v): s(), sign(v < 0 ? -1 : 1)
    {
        for (ll t = v < 0 ? -v : v; t; t /= BASE)
        {
            s.push_back(t % BASE);
        }
    }
    bint(const string &v): s(), sign(1)
    {
        int beg = 0;
        for (; beg < (int)v.size() && (v[beg] == '-' || v[beg] == '+'); beg++)
        {
            if (v[beg] == '-')
            {
                sign = -1;
            }
        }
        for (int i = (int)v.size() - 1, x, j; i >= beg; i -= BASEDIGITS)
        {
            for (x = 0, j = max(beg, i - BASEDIGITS + 1); j <= i; x = x * 10 + v[j++] - '0');
            s.push_back(x);
        }
        trim();
    }
    bint &operator=(const bint &v)
    {
        sign = v.sign;
        s = v.s;
        return *this;
    }
    bint &operator+=(const bint &v)
    {
        if (sign == v.sign)
        {
            for (int i = 0, is = 0, len = max(s.size(), v.s.size()); i < len || is; i++)
            {
                if (i == (int)s.size())
                {
                    s.push_back(0);
                }
                s[i] += is + (i < (int)v.s.size() ? v.s[i] : 0);
                if ((is = s[i] >= BASE))
                {
                    s[i] -= BASE;
                }
            }
            return *this;
        }
        else
        {
            return *this -= -v;
        }
    }
    bint &operator-=(const bint &v)
    {
        if (sign == v.sign)
        {
            if (cmp(v, 0) != -1)
            {
                for (int i = 0, is = 0; i < (int)v.s.size() || is; i++)
                {
                    s[i] -= is + (i < (int)v.s.size() ? v.s[i] : 0);
                    if ((is = s[i] < 0))
                    {
                        s[i] += BASE;
                    }
                }
                trim();
                return *this;
            }
            else
            {
                return *this = -(bint(v) -= *this);
            }
        }
        else
        {
            return *this += -v;
        }
    }
    bint &operator*=(const bint &v)
    {
        vector<ll> num(s.size() + v.s.size());
        for (int i = 0; i < (int)s.size(); i++)
        {
            for (int j = 0; j < (int)v.s.size(); j++)
            {
                num[i + j] += (ll)s[i] * v.s[j];
                if (num[i + j] >= BASE)
                {
                    num[i + j + 1] += num[i + j] / BASE;
                    num[i + j] %= BASE;
                }
            }
        }
        sign *= v.sign;
        s.resize(num.size());
        for (int i = 0; i < (int)num.size(); i++)
        {
            s[i] = num[i];
        }
        trim();
        return *this;
    }
    bint &operator/=(const bint &v)
    {
        return *this = divmod(*this, v).first;
    }
    bint &operator%=(const bint &v)
    {
        return *this = divmod(*this, v).second;
    }
    bint operator-()const
    {
        bint ret(*this);
        ret.sign = -sign;
        return ret;
    }
    bint operator+(const bint &v)const
    {
        return bint(*this) += v;
    }
    bint operator-(const bint &v)const
    {
        return bint(*this) -= v;
    }
    bint operator*(const bint &v)const
    {
        return bint(*this) *= v;
    }
    bint operator/(const bint &v)const
    {
        return divmod(*this, v).first;
    }
    bint operator%(const bint &v)const
    {
        return divmod(*this, v).second;
    }
    bint operator^(const ll &v)const
    {
        bint ret(1), t(*this);
        for (ll b = v; b; b >>= 1)
        {
            if (b & 1)
            {
                ret *= t;
            }
            t *= t;
        }
        return ret;
    }
 
    friend pair<bint, bint> divmod(const bint &a, const bint &b)
    {
        int norm = BASE / (b.s.back() + 1);
        bint x = a.abs().mul(norm), y = b.abs().mul(norm), q, r;
        q.s.resize(x.s.size());
        for (int i = (int)x.s.size() - 1; i >= 0; i--)
        {
            r = r.mul(BASE);
            r += x.s[i];
            int s1 = r.s.size() <= y.s.size() ? 0 : r.s[y.s.size()];
            int s2 = r.s.size() + 1 <= y.s.size() ? 0 : r.s[y.s.size() - 1];
            int d = ((ll)BASE * s1 + s2) / y.s.back();
            r -= y.mul(d);
            while (r.cmp(0, 1) == -1)
            {
                r += y;
                --d;
            }
            q.s[i] = d;
        }
        q.sign = a.sign * b.sign;
        q.trim();
        r.sign = a.sign;
        r.trim();
        return make_pair(q, r.div(norm));
    }
    bint mul(int v)const
    {
        bint ret(*this);
        if (v < 0)
        {
            ret.sign = -ret.sign;
            v = -v;
        }
        for (int i = 0, is = 0; i < (int)ret.s.size() || is; i++)
        {
            if (i == (int)s.size())
            {
                ret.s.push_back(0);
            }
            ll a = ret.s[i] * (ll)v + is;
            is = a / BASE;
            ret.s[i] = a % BASE;
        }
        ret.trim();
        return ret;
    }
    bint div(int v)const
    {
        bint ret(*this);
        if (v < 0)
        {
            ret.sign = -ret.sign;
            v = -v;
        }
        for (int i = (int)ret.s.size() - 1, rem = 0; i >= 0; i--)
        {
            ll a = ret.s[i] + rem * (ll)BASE;
            ret.s[i] = a / v;
            rem = a % v;
        }
        ret.trim();
        return ret;
    }
    int mod(int v)const
    {
        if (v < 0)
        {
            v = -v;
        }
        int m = 0;
        for (int i = (int)s.size() - 1; i >= 0; i--)
        {
            m = (s[i] + m * (ll)BASE) % v;
        }
        return m * sign;
    }
    bool operator<(const bint &v)const
    {
        return cmp(v) < 0;
    }
    bool operator>(const bint &v)const
    {
        return cmp(v) > 0;
    }
    bool operator<=(const bint &v)const
    {
        return cmp(v) <= 0;
    }
    bool operator>=(const bint &v)const
    {
        return cmp(v) >= 0;
    }
    bool operator==(const bint &v)const
    {
        return cmp(v) == 0;
    }
    bool operator!=(const bint &v)const
    {
        return cmp(v) != 0;
    }
    int cmp(const bint &v, bool is = 1)const
    {
        if (is)
        {
            if (sign > v.sign)
            {
                return 1;
            }
            if (sign < v.sign)
            {
                return -1;
            }
        }
        int d = sign > 0 || !is ? 1 : -1;
        if (s.size() > v.s.size())
        {
            return d;
        }
        if (s.size() < v.s.size())
        {
            return -d;
        }
        for (int i = (int)s.size() - 1; i >= 0; i--)
        {
            if (s[i] > v.s[i])
            {
                return d;
            }
            if (s[i] < v.s[i])
            {
                return -d;
            }
        }
        return 0;
    }
    bint abs()const
    {
        bint ret(*this);
        ret.sign *= ret.sign;
        return ret;
    }
    void trim()
    {
        while (!s.empty() && !s.back())
        {
            s.pop_back();
        }
        if (s.empty())
        {
            sign = 1;
        }
    }
    void print()const
    {
        if (sign == -1)
        {
            putchar('-');
        }
        printf("%d", s.empty() ? 0 : s.back());
        for (int i = (int)s.size() - 2; i >= 0; i--)
        {
            printf("%09d", s[i]);
        }
    }
    friend istream &operator>>(istream &in, bint &v)
    {
        string s;
        in >> s;
        v = s;
        return in;
    }
 
    string toString()const
    {
        if (s.empty())
        {
            return "0";
        }
        string ret, x;
        if (sign == -1)
        {
            ret += '-';
        }
        for (int o = s[s.size() - 1]; o; o /= 10)
        {
            x += o % 10 + '0';
        }
        for (int i = (int)x.size() - 1; i >= 0; i--)
        {
            ret += x[i];
        }
        for (int i = (int)s.size() - 2; i >= 0; i--)
        {
            x.clear();
            for (int j = 0, p = s[i]; j < BASEDIGITS; j++, p /= 10)
            {
                x += p % 10 + '0';
            }
            for (int j = BASEDIGITS - 1; j >= 0; j--)
            {
                ret += x[j];
            }
        }
        return ret;
    }
    operator bool()const
    {
        return s.size() && !(s.size() == 1 && !s[0]);
    }
 
    bint sqrt()const
    {
        bint ret, t(*this);
        ret.s.resize((t.s.size() + 1) >> 1);
        for (int i = (int)ret.s.size() - 1; i >= 0; i--)
        {
            int l = 0, r = BASE - 1, mid = ret.s[i] = (l + r + 1) >> 1;
            while (l < r)
            {
                if (comp(ret, mid, i - 1, t))
                {
                    r = mid - 1;
                }
                else
                {
                    l = mid;
                }
                mid = ret.s[i] = (l + r + 1) >> 1;
            }
            sub(t, ret, mid, i - 1);
            ret.s[i] += mid;
        }
        for (int i = 0; i < (int)ret.s.size(); i++)
        {
            ret.s[i] >>= 1;
        }
        ret.trim();
        return ret;
    }
    void sub(bint &a, const bint &b, const int &k, const int &d)const
    {
        for (int i = d + 1, l = b.s.size() + d; i <= l; i++)
        {
            ll tmp = a.s[i] - (ll)b.s[i - d - 1] * k;
            if (tmp < 0)
            {
                a.s[i + 1] += (tmp - BASE + 1) / BASE;
                a.s[i] = tmp - (tmp - BASE + 1) / BASE * BASE;
            }
            else
            {
                a.s[i] = tmp;
            }
        }
        for (int i = b.s.size() + d + 1; i < (int)a.s.size() && a.s[i] < 0; i++)
        {
            a.s[i + 1] += (a.s[i] - BASE + 1) / BASE;
            a.s[i] -= (a.s[i] - BASE + 1) / BASE * BASE;
        }
        a.trim();
    }
    bool comp(const bint &a, const int &c, const int &d, const bint &b)const
    {
        int l = -(BASE << 1);
        ll t = 0;
        if (b.s.size() < a.s.size() + d && c)
        {
            return true;
        }
        for (int i = (int)b.s.size() - 1; i > d; i--)
        {
            t = t * BASE + (ll)(i - d - 1 < (int)a.s.size() ? a.s[i - d - 1] : 0) * c - b.s[i];
            if (t > 0)
            {
                return true;
            }
            if (t < l)
            {
                return false;
            }
        }
        for (int i = d - 1; i >= 0; i--)
        {
            t = t * BASE - b.s[i];
            if (t > 0)
            {
                return true;
            }
            if (t < l)
            {
                return false;
            }
        }
        return t > 0;
    }
};

Python3大数

python3的整数，是不限长度的类型

所以python3里的代码，默认大数

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值