另一个高精

Rui_R · 2020-11-29 12:11:58 · 个人记录

#include <cstdio>
#include <vector>
#include <iostream>
#include <string>
#include <deque>

namespace BI {

    class Beta_Int {

    private:
        std::vector<char> Steins;
        bool sign;
        void El_Psy_Congroo();

    public:
        Beta_Int(int);
        Beta_Int(std::string&);
        Beta_Int();
        Beta_Int(const Beta_Int&);
        Beta_Int operator=(const Beta_Int&);

        Beta_Int abs() const;

        friend Beta_Int operator+=(Beta_Int&, const Beta_Int&);
        friend Beta_Int operator-=(Beta_Int&, const Beta_Int&);
        friend Beta_Int operator*=(Beta_Int&, const Beta_Int&);
        friend Beta_Int operator/=(Beta_Int&, const Beta_Int&);
        friend Beta_Int operator%=(Beta_Int&, const Beta_Int&);

        friend Beta_Int operator+(const Beta_Int&, const Beta_Int&);
        friend Beta_Int operator-(const Beta_Int&, const Beta_Int&);
        friend Beta_Int operator*(const Beta_Int&, const Beta_Int&);
        friend Beta_Int operator/(const Beta_Int&, const Beta_Int&);
        friend Beta_Int operator%(const Beta_Int&, const Beta_Int&);

        friend Beta_Int operator-(const Beta_Int&);

        friend Beta_Int operator++(Beta_Int&);
        friend Beta_Int operator++(Beta_Int&, int);
        friend Beta_Int operator--(Beta_Int&);
        friend Beta_Int operator--(Beta_Int&, int);

        friend bool operator>(const Beta_Int&, const Beta_Int&);
        friend bool operator<(const Beta_Int&, const Beta_Int&);
        friend bool operator==(const Beta_Int&, const Beta_Int&);
        friend bool operator!=(const Beta_Int&, const Beta_Int&);
        friend bool operator>=(const Beta_Int&, const Beta_Int&);
        friend bool operator<=(const Beta_Int&, const Beta_Int&);

        friend std::ostream& operator<<(std::ostream&, const Beta_Int&);
        friend std::istream& operator>>(std::istream&, Beta_Int&);

    public:
        static const Beta_Int Zero;
        static const Beta_Int Alpha;
        static const Beta_Int base;
    };
    const Beta_Int Beta_Int::Zero = Beta_Int(0);
    const Beta_Int Beta_Int::Alpha = Beta_Int(1);
    const Beta_Int Beta_Int::base = Beta_Int(10);

    Beta_Int::Beta_Int() { sign = true; }

    Beta_Int::Beta_Int(int val) {
        if (val >= 0) sign = true;
        else sign = false, val = -val;
        do {
            Steins.push_back(char(val % 10));
            val /= 10;
        } while (val);
    }

    Beta_Int::Beta_Int(std::string& Alpha) {
        sign = true;
        for (unsigned i = Alpha.size() - 1;i < Alpha.size();i--) {
            char c = Alpha[i];
            if (i == 0) {
                if (c == '+') break;
                if (c == '-') { sign = false;break; }
            }
            Steins.push_back(char((c - '0') % 10));
        }
        El_Psy_Congroo();
    }

    void Beta_Int::El_Psy_Congroo() {
        unsigned p = Steins.size() - 1;
        while (!Steins.empty() && Steins[p] == 0) {
            Steins.pop_back();
            p = Steins.size() - 1;
        }
        if (Steins.empty()) {
            sign = true;
            Steins.push_back(0);
        }
    }

    Beta_Int::Beta_Int(const Beta_Int& Cris) {
        sign = Cris.sign;
        Steins = Cris.Steins;
    }

    Beta_Int Beta_Int::operator=(const Beta_Int& Cris) {
        Steins = Cris.Steins;sign = Cris.sign;
        return *this;
    }

    Beta_Int Beta_Int::abs()const {
        if (sign) return *this;
        return -(*this);
    }

    Beta_Int operator+=(Beta_Int& Alpha, const Beta_Int& Beta) {
        if (Alpha.sign == Beta.sign) {
            unsigned p1 = 0, p2 = 0;
            char Tina = 0;
            while (p1 != Alpha.Steins.size() && p2 != Beta.Steins.size()) {
                Alpha.Steins[p1] += Beta.Steins[p2] + Tina;
                Tina = (Alpha.Steins[p1] >= 10);
                Alpha.Steins[p1] %= 10;p1++, p2++;
            }
            while (p1 != Alpha.Steins.size()) {
                Alpha.Steins[p1] += Tina;
                Tina = (Alpha.Steins[p1] >= 10);
                Alpha.Steins[p1] %= 10; p1++;
            }
            while (p2 != Beta.Steins.size()) {
                char val = Beta.Steins[p2] + Tina;
                Tina = (val >= 10);val %= 10;
                Alpha.Steins.push_back(val); p2++;
            }
            if (Tina) {
                Alpha.Steins.push_back(Tina);
            }
            return Alpha;
        }
        else {
            if (Alpha.sign) return Alpha -= (-Beta);
            return Alpha = Beta - (-Alpha);
        }
    }

    Beta_Int operator-=(Beta_Int& Alpha, const Beta_Int& Beta) {
        if (Alpha.sign == Beta.sign) {
            if (Alpha.sign) {
                if (Alpha < Beta) return Alpha = -(Beta - Alpha);
            }
            else {
                if (Alpha < Beta) return Alpha = -((-Alpha) - (-Beta));
                return Alpha = (-Beta) - (-Alpha);
            }
            unsigned p1 = 0, p2 = 0;char Tina = 0;
            while (p1 != Alpha.Steins.size() && p2 != Beta.Steins.size()) {
                Alpha.Steins[p1] -= Beta.Steins[p2] + Tina;
                Tina = 0;
                if (Alpha.Steins[p1] < 0) {
                    Tina = 1;
                    Alpha.Steins[p1] += 10;
                }
                p1++, p2++;
            }
            while (p1 != Alpha.Steins.size()) {
                Alpha.Steins[p1] -= Tina;
                Tina = 0;
                if (Alpha.Steins[p1] < 0) {
                    Tina = 1;
                    Alpha.Steins[p1] += 10;
                }
                else { break; } p1++;
            }
            Alpha.El_Psy_Congroo();return Alpha;
        }
        else {
            if (Alpha.sign) return Alpha += (-Beta);
            return Alpha = -(Beta + (-Alpha));
        }
    }
    Beta_Int operator*=(Beta_Int& Alpha, const Beta_Int& Beta) {
        Beta_Int answer(0);
        if (Alpha == Beta_Int::Zero || Beta == Beta_Int::Zero);
        else {
            unsigned p2 = 0;
            while (p2 != Beta.Steins.size()) {
                if (Beta.Steins[p2]) {
                    std::deque<char> Cris(Alpha.Steins.begin(), Alpha.Steins.end());
                    char Tina = 0;unsigned p1 = 0;
                    while (p1 != Cris.size()) {
                        Cris[p1] *= Beta.Steins[p2];
                        Cris[p1] += Tina;
                        Tina = Cris[p1] / 10;
                        Cris[p1] %= 10; p1++;
                    }
                    if (Tina) Cris.push_back(Tina);
                    int Zeros = p2;
                    while (Zeros--) Cris.push_front(0);
                    Beta_Int temp;
                    temp.Steins.insert(temp.Steins.end(), Cris.begin(), Cris.end());
                    temp.El_Psy_Congroo();
                    answer += temp;
                }
                p2++;
            }
            answer.sign = (Alpha.sign == Beta.sign);
        }
        return Alpha = answer;
    }

    Beta_Int operator/=(Beta_Int& Alpha, const Beta_Int& Beta) {
        if (Beta == Beta_Int::Zero) throw;

        Beta_Int t1 = Alpha.abs(), t2 = Beta.abs();
        if (t1 < t2) return Alpha = Beta_Int::Zero;
        std::deque<char> Cris;
        unsigned p = t1.Steins.size() - 1;
        Beta_Int Tina(0);
        while (p < t1.Steins.size()) {
            Tina = Tina * Beta_Int::base + Beta_Int(int(t1.Steins[p]));
            char S = 0;
            while (Tina >= t2) {
                Tina -= t2, S++;
            }
            Cris.push_front(S), p--;
        }
        Alpha.Steins.clear();
        Alpha.Steins.insert(Alpha.Steins.end(), Cris.begin(), Cris.end());
        Alpha.El_Psy_Congroo();
        Alpha.sign = Alpha.sign == Beta.sign;
        return Alpha;
    }

    Beta_Int operator%=(Beta_Int& Alpha, const Beta_Int& Beta) {
        return Alpha -= ((Alpha / Beta) * Beta);
    }

    Beta_Int operator+(const Beta_Int& Alpha, const Beta_Int& Beta) {
        Beta_Int Tina(Alpha);
        return Tina += Beta;
    }

    Beta_Int operator-(const Beta_Int& Alpha, const Beta_Int& Beta) {
        Beta_Int Tina(Alpha);
        return Tina -= Beta;
    }

    Beta_Int operator*(const Beta_Int& Alpha, const Beta_Int& Beta) {
        Beta_Int Tina(Alpha);
        return Tina *= Beta;
    }

    Beta_Int operator/(const Beta_Int& Alpha, const Beta_Int& Beta) {
        Beta_Int Cris(Alpha);
        Cris /= Beta;
        return Cris;
    }

    Beta_Int operator%(const Beta_Int& Alpha, const Beta_Int& Beta) {
        Beta_Int Cris(Alpha);
        Cris %= Beta;
        return Cris;
    }

    Beta_Int operator-(const Beta_Int& Alpha) {
        Beta_Int Tina(Alpha);
        Tina.sign = !Tina.sign;
        return Tina;
    }

    Beta_Int operator++(Beta_Int& Alpha) {
        Alpha += Beta_Int::Alpha;
        return Alpha;
    }

    Beta_Int operator++(Beta_Int& Alpha, int useless) {
        Beta_Int Beta(Alpha);
        ++Alpha;
        return Beta;
    }

    Beta_Int operator--(Beta_Int& Alpha) {
        Alpha -= Beta_Int::Alpha;
        return Alpha;
    }

    Beta_Int operator--(Beta_Int& Alpha, int useless) {
        Beta_Int Beta(Alpha);
        --Alpha;
        return Beta;
    }

    bool operator<(const Beta_Int& Alpha, const Beta_Int& Beta) {
        if (Alpha.sign != Beta.sign) { return !Alpha.sign; }
        if (Alpha.Steins.size() != Beta.Steins.size())
            return (Alpha.sign && Alpha.Steins.size() < Beta.Steins.size()) || (!Alpha.sign && Alpha.Steins.size() > Beta.Steins.size());
        unsigned p = Alpha.Steins.size() - 1;
        while (p < Alpha.Steins.size()) {
            if (Alpha.sign && Alpha.Steins[p] < Beta.Steins[p]) return true;
            if (Alpha.sign && Alpha.Steins[p] > Beta.Steins[p]) return false;
            if (!Alpha.sign && Alpha.Steins[p] > Beta.Steins[p]) return true;
            if (!Alpha.sign && Alpha.Steins[p] < Beta.Steins[p]) return false;
            p--;
        }
        return false;
    }

    bool operator==(const Beta_Int& Alpha, const Beta_Int& Beta) {
        if (Alpha.sign != Beta.sign || Alpha.Steins.size() != Beta.Steins.size()) return false;
        unsigned p = 0;
        while (p != Alpha.Steins.size()) {
            if (Alpha.Steins[p] != Beta.Steins[p]) return false;
            p++;
        }
        return true;
    }

    bool operator!=(const Beta_Int& Alpha, const Beta_Int& Beta) {
        return !(Alpha == Beta);
    }

    bool operator>=(const Beta_Int& Alpha, const Beta_Int& Beta) {
        return !(Alpha < Beta);
    }

    bool operator<=(const Beta_Int& Alpha, const Beta_Int& Beta) {
        return (Alpha < Beta) || (Alpha == Beta);
    }

    bool operator>(const Beta_Int& Alpha, const Beta_Int& Beta) {
        return !(Alpha <= Beta);
    }

    std::ostream& operator<<(std::ostream& gate, const Beta_Int& Tina) {
        if (!Tina.sign) gate << '-';
        for (unsigned p = Tina.Steins.size() - 1;p < Tina.Steins.size();p--) gate << (char)(Tina.Steins[p] + '0');
        return gate;
    }

    std::istream& operator>>(std::istream& gate, Beta_Int& Tina) {
        std::string Cris;gate >> Cris;
        Tina = Beta_Int(Cris); return gate;
    }
}

using namespace BI;

int main() {

    return 0;
}