高精度

 

 

/*

1.高精度加法

2.高精度减法 

3.高精度乘法 

4.高精度除以低精度 

5.高精度对低精度的取余 



必要时可以将全局的int替换成long long.除了main函数的返回值int

用到除法和取余的时候可能需要把全局的int替换成long long 

*/

#include <cstdio>

#include <iostream>

#include <cstring>

#include <climits>

using namespace std;



#define maxn 30000



struct bign

{

    int len, s[maxn];



    bign()

    {

        memset(s, 0, sizeof(s));

        len = 1;

    }

    

    bign(int num)

    {

        *this = num;

    }

    

    bign(const char* num) 

    {

        *this = num;

    }

    

    bign operator = (int num) 

    {

        char s[maxn];

        sprintf(s, "%d", num);

        *this = s;

        return *this;

    }

    

    bign operator = (const char* num) 

    {

        len = strlen(num);

        for (int i = 0; i < len; i++) s[i] = num[len-i-1] - '0';

        return *this;

    }

    

    string str() const 

    {

        string res = "";

        for (int i = 0; i < len; i++) res = (char)(s[i] + '0') + res;

        if (res == "") res = "0";

        return res;

    }

    

    /*去除前导0*/ 

    void clean() 

    {

        while(len > 1 && !s[len-1]) len--;

    }

    

    /*高精度的加法*/

    bign operator + (const bign& b) const

    {

        bign c;

        c.len = 0;

        for (int i = 0, g = 0; g || i < max(len, b.len); i++) 

        {

            int x = g;

            if (i < len) x += s[i];

            if (i < b.len) x += b.s[i];

            c.s[c.len++] = x % 10;

            g = x / 10;

        }

        return c;

    }

    

    /*高精度的减法*/ 

    bign operator - (const bign& b) 

    {

        bign c; c.len = 0;

        for (int i = 0, g = 0; i < len; i++) 

        {

            int x = s[i] - g;

            if (i < b.len) x -= b.s[i];

            if (x >= 0) 

                g = 0;

            else 

            {

                g = 1;

                x += 10;

            }

            c.s[c.len++] = x;

        }

        c.clean();

        return c;

    }

    

    /*高精度的乘法*/ 

    bign operator * (const bign& b) 

    {

        bign c; c.len = len + b.len;

        for (int i = 0; i < len; i++)

        for (int j = 0; j < b.len; j++)

        c.s[i+j] += s[i] * b.s[j];

        for (int i = 0; i < c.len-1; i++)

        {

            c.s[i+1] += c.s[i] / 10;

            c.s[i] %= 10;

        }

        c.clean();

        return c;

    } 

    

    /*高精度除以低精度*/    /*用到除法和取余的时候可能需要把全局的int替换成long long*/

    bign operator / (long long b) const

    {

        assert(b > 0);

        bign c;c.len = len;

        for (long long i = len-1, g = 0; i >= 0; --i)

        {

            long long x = 10*g+s[i];    //这里可能会超过int 故用long long 

            

            c.s[i] = x/b;                //这里可能会超过int

            

            g = x-c.s[i]*b;                //这里可能会超过int 

        }

        c.clean();

        return c;

    }

    

    /*高精度对低精度取余*/    /*用到除法和取余的时候可能需要把全局的int替换成long long*/

    bign operator % (long long b)

    {

        assert(b > 0);

        bign d = b;

        bign c = *this-*this/b*d;

        return c;

    }

    

    bool operator < (const bign& b) const

    {

        if (len != b.len) return len < b.len;

        for (int i = len-1; i >= 0; i--)

        if (s[i] != b.s[i]) return s[i] < b.s[i];

        return false;

    }

    

    bool operator > (const bign& b) const

    {

        return b < *this;

    }

    

    bool operator <= (const bign& b) 

    {

        return !(b > *this);

    }

    

    bool operator >= (const bign& b) 

    {

        return !(b < *this);

    }

    

    bool operator == (const bign& b) 

    {

        return !(b < *this) && !(*this < b);

    }

    

    bool operator != (const bign& b) 

    {

        return (b < *this) || (*this < b);

    }

    

    bign operator += (const bign& b) 

    {

        *this = *this + b;

        return *this;

    }

};



istream& operator >> (istream &in, bign& x) 

{

    string s;

    in >> s;

    x = s.c_str();

    return in;

}



ostream& operator << (ostream &out, const bign& x) 

{

    out << x.str();

    return out;

}