BigNumbers

class BigNumber
{
    BigNumber subNumber(int n) //used for long division, gets the number composed by the first n most significant digits
    {
        BigNumber s;
        for (int i = _container.size() - n; i < _container.size(); i++)
        {
            s._container.push_back(_container[i]);
        }
        return s;
    }
    vector<int> _container;
public:
    BigNumber(){};
    BigNumber(int x)
    {
        while (x > 0)
        {
            _container.push_back(x % 10);
            x /= 10;
        }
    }
    BigNumber(string s) //assumes base 10
    {
        for (int i = s.size() - 1; i >= 0; i--)
        {
            _container.push_back(s[i] - '0');
        }
    }

    vector<int> getContainer()
    {
        return  _container;
    }

    BigNumber operator+(const BigNumber& other)
    {
        BigNumber result(0);
        int resultLength = max(_container.size(), other._container.size());
        int carry = 0;
        for (int i = 0; i < resultLength; i++)
        {
            int addResult = (i < _container.size() ? _container[i] : 0) + (i < other._container.size() ? other._container[i] : 0);
            result._container.push_back((addResult + carry) % 10);
            carry = (addResult + carry) / 10;
        }
        while (carry > 0)
        {
            result._container.push_back(carry % 10);
            carry /= 10;
        }
        return result;
    }

    BigNumber operator-(const BigNumber& other)
    {
        BigNumber result(0);
        if (this->operator<(other))
        {
            return result;
        }
        int carry = 0;
        for (int i = 0; i < _container.size(); i++)
        {
            int subResult = (_container[i] - carry) - (i < other._container.size() ? other._container[i] : 0);
            if (subResult < 0)
            {
                subResult += 10;
                carry = 1;
            }
            else
            {
                carry = 0;
            }
            result._container.push_back(subResult);
        }
        while (result._container.back() == 0 && result._container.size() > 1)
        {
            result._container.pop_back();
        }
        return result;
    }

    BigNumber operator*(const BigNumber& other)
    {
        BigNumber result(0);
        vector<int> min = _container.size() < other._container.size() ? this->_container : other._container;
        vector<int> max = _container.size() < other._container.size() ? other._container : this->_container;

        for (int i = 0; i < min.size(); i++)
        {
            BigNumber sum(0);
            int carry = 0;
            for (int j = 0; j < i; j++)
            {
                sum._container.push_back(0);
            }
            for (int j = 0; j < max.size(); j++)
            {
                int mulRes = min[i] * max[j];
                sum._container.push_back((mulRes + carry) % 10);
                carry = (mulRes + carry) / 10;
            }
            while (carry > 0)
            {
                sum._container.push_back(carry % 10);
                carry /= 10;
            }
            result = result + sum;
        }
        return result;
    }

    BigNumber operator/(BigNumber& other) // a div b using the long division algorithm, b must be lower than MAX_INT so that I can use int division instead of repeated subtraction
    {
        BigNumber result = 0;
        int dividend = other.to_int();
        if (this->operator<(other))
        {
            return BigNumber(0);
        }
        int current = other._container.size();
        BigNumber partial = this->subNumber(current);

        if (partial < other)
        {
            current++;
            partial = (partial * BigNumber(10)) + BigNumber(_container[_container.size() - current]);
        }

        while (current <= _container.size())
        {
            //add next digit
            int val = partial.to_int() / dividend;
            result._container.insert(result._container.begin(), val);
            partial = partial - BigNumber(val * dividend);
            current++;
            if (current > _container.size())
            {
                break;
            }
            partial = (partial * BigNumber(10)) + BigNumber(_container[_container.size() - current]);
        }

        return result;
    }

    BigNumber convertToBase(int base) // converts the number from base 10 to another base
    {
        BigNumber result;
        BigNumber baseBig(base);

        BigNumber q = *this;
        if (q < BigNumber(1))
        {
            return BigNumber(0);
        }
        BigNumber q2 = this -> operator/(baseBig);

        while (q > 0)
        {
            BigNumber r = q - (q2 * baseBig);
            result._container.push_back(r.to_int());
            q = q2;
            q2 = q / baseBig;
        }
        return result;
    }

    bool operator >(const BigNumber& other)
    {
        if (_container.size() != other._container.size())
        {
            return _container.size() > other._container.size();
        }
        else
        {
            for (int i = _container.size() - 1; i >= 0; i--)
            {
                if (_container[i] == other._container[i])
                {
                    continue;
                }
                if (_container[i] > other._container[i])
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            return false;
        }
    }

    bool operator <(const BigNumber& other)
    {
        return !(this->operator> (other)) && !(this->operator==(other));
    }

    bool operator ==(const BigNumber& other)
    {
        return _container == other._container;
    }

    bool operator >=(const BigNumber& other)
    {
        return this->operator> (other) || this->operator== (other);
    }
    bool operator <=(const BigNumber& other)
    {
        return this->operator<(other) || this->operator==(other);
    }

    int to_int()
    {
        int result = 0;
        int p = 0;
        for (int i = _container.size() - 1; i >= 0; i--)
        {
            result = result * 10 + _container[i];
        }
        return result;
    }
};