itoggovno

template<class T>
void delete_zeros(vector<T> &polynom) {
    vector<T> result = polynom;
    for (size_t i = polynom.size() - 1; i > 0; i--) {
        if (result[i] == T()) {
            result.pop_back();
        } else {
            break;
        }
    }
    polynom = result;
}

template <typename T>
class Polynomial {
private:
    vector<T> polynom;
public:
    Polynomial(const vector<T>& pol) {
        polynom = pol;
        delete_zeros(polynom);
    }

    Polynomial(const T& object) {
        polynom.push_back(object);
    }

    template<typename Iter>
    Polynomial(const Iter& begin, const Iter& end) {
        polynom = vector<T>(begin, end);
        delete_zeros(polynom);
    }

    Polynomial() {
        polynom.emplace_back();
    }

    vector<T> get_polynom() const {
        return polynom;
    }

    size_t get_size() const {
        return polynom.size();
    }

    template <class A, class B>
    friend Polynomial<T> operator - (const A& a, const B& b) {
        vector<T> preres;
        auto pol1 = Polynomial<T>(a);
        auto pol2 = Polynomial<T>(b);
        if (pol1.get_size() >= pol2.get_size()) {
            for (size_t i = 0; i < pol2.get_size(); i++) {
                preres.push_back(pol1.polynom[i] - pol2.polynom[i]);
            }
            for (size_t i = pol2.get_size() + 1; i < pol1.get_size(); i++) {
                preres.push_back(pol1.polynom[i]);
            }
        } else {
            for (size_t i = 0; i < pol1.get_size(); i++) {
                preres.push_back(pol1.polynom[i] - pol2.polynom[i]);
            }
            for (size_t i = pol1.get_size() + 1; i < pol2.get_size(); i++) {
                preres.push_back(T() - pol2.polynom[i]);
            }
        }

        return Polynomial<T>(preres);
    }

    template <class A>
    Polynomial<T> &operator-=(const A &a) {
        auto pol = Polynomial<T>(a);
        *this = *this - pol;
        return *this;
    }

    template <class A, class B>
    friend Polynomial<T> operator + (const A& a, const B& b) {
        vector<T> preres;
        auto pol1 = Polynomial<T>(a);
        auto pol2 = Polynomial<T>(b);
        if (pol1.get_size() >= pol2.get_size()) {
            for (size_t i = 0; i < pol2.get_size(); i++) {
                preres.push_back(pol1.polynom[i] + pol2.polynom[i]);
            }
            for (size_t i = pol2.get_size() + 1; i < pol1.get_size(); i++) {
                preres.push_back(pol1.polynom[i]);
            }
        } else {
            for (size_t i = 0; i < pol1.get_size(); i++) {
                preres.push_back(pol1.polynom[i] + pol2.polynom[i]);
            }
            for (size_t i = pol1.get_size() + 1; i < pol2.get_size(); i++) {
                preres.push_back(pol2.polynom[i]);
            }
        }

        return Polynomial<T>(preres);
    }

    template <class A>
    Polynomial<T> &operator+=(const A& a) {
        auto pol = Polynomial<T>(a);
        *this = *this + pol;
        return *this;
    }

  /*  vector<T> multiply(vector<T> A, vector<T> B) {
        size_t m = A.size();
        size_t n = B.size();
        vector<T> prod;
        for (size_t i = 0; i < m + n - 1; i++) {
            prod.push_back(T());
        }
        for (size_t i = 0; i< m; i++) {
            for (size_t j = 0; j < n; j++) {
                prod[i + j] += A[i] * B[j];
            }
        }
        return prod;
    }*/

    template<typename A>
    bool operator == (const A& a) const {
        auto pol = Polynomial<T>(a);
        return equal((*this).polynom.begin(), (*this).polynom.end(),
            pol.polynom.begin(), pol.polynom.end());
    }

   /* template<typename S>
    bool operator==(const S &other1) const {
        Polynomial other(other1);
        return equal((*this).coeff.begin(), (*this).coeff.end(),
            other.coeff.begin(), other.coeff.end());
    }*/

    template<typename A>
    bool operator!=(const A& a) const {
        Polynomial<T> pol(a);
        return !(pol == *this);
    }

   /* void operator *= (Polynomial<T> pol) {
        vector<T> result_coeff = multiply(polynom, pol.polynom);
        polynom = result_coeff;
        this->delete_zeros();
    }

    void operator *= (T pol) {
        for (size_t i = 0; i < polynom.size(); i++) {
            polynom[i] *= pol;
        }
        this->delete_zeros();
    }



    Polynomial<T> operator * (Polynomial<T> pol) const {
        vector<T> preres = this->polynom;
        Polynomial<T> result(preres);
        result *= pol;
        return result;
    }

    Polynomial<T> operator * (T pol) const {
        vector<T> preres = this->polynom;
        for (size_t i = 0; i < polynom.size(); i++) {
            preres[i] *= pol;
        }
        Polynomial<T> result(preres);
        return result;
    }
*/

    template<typename A>
    T operator[](const A &id) const {
        if (static_cast<size_t > (id) >= (*this).polynom.size()) {
            return T();
        }
        return (*this).polynom[static_cast<size_t > (id)];
    }

   /* T operator ()(T id) const {
        if (id == T()) {
            return polynom[0];
        } else {
            T x = T(1);
            T result = T();
            for (size_t i = 0; i < polynom.size(); i++) {
                result += x * polynom[i];
                x *= id;
            }
            return result;
        }
    }*/

    int Degree() const {
        if (polynom.size() == 1 && polynom[0] == T()) {
            return -1;
        } else {
            return static_cast<int>(polynom.size() - 1);
        }
    }



    auto begin() const {
        return polynom.begin();
    }

    auto end() const {
        return polynom.end();
    }

};

class int2 {
private:
    int int1;
public:
    int2(int i) {
        this->int1 = i;
    }

    int2() {
        this->int1 = 0;
    }

    bool operator == (const int2& i) const {
        return int1 == i.get();
    }

    bool operator != (const int2& i) const {
        return int1 != i.get();
    }

    int get() const {
        return this->int1;
    }

    int2 operator + (int2 i1) const {
        int res = this->int1 + i1.get();
        return int2(res);
    }

    void operator += (int2 i1) {
        int1 += i1.get();
    }

    int2 operator - (int2 i1) const {
        int res = this->int1 - i1.get();
        return int2(res);
    }

    void operator -= (int2 i1) {
        int1 -= i1.get();
    }

    int2 operator * (int2 i1) const {
        int res = this->int1 * i1.get();
        return int2(res);
    }

    void operator *= (int2 i1) {
        int1 *= i1.get();
    }

    operator int() {
        return this->int1;
    }


};

void coutVector(vector<int2> re) {
    for (int2 i : re) {
        cout << i.get() << " ";
    }
    cout << endl;
}

void coutVector2(vector<int> re) {
    for (int i : re) {
        cout << i << " ";
    }
    cout << endl;
}

int main() {
    vector<int2> res = { int2(1), int2(1), int2(1), int2(1) };
    vector<int2> res2 = { int2(2), int2(3), int2(4), int2(5) };
    Polynomial<int2> p(res);
    coutVector(p.get_polynom());
    Polynomial<int2> p1(res2);
    coutVector((p -= p1).get_polynom());
    cout << p[1] << endl;
    coutVector((p + p1).get_polynom());
    coutVector((p += p1).get_polynom());
    cout << (p == p1);
    cout << (p != p1);
    /*vector<int2> res = { int2(1), int2(1), int2(1), int2(1) };
    vector<int2> res2 = { int2(2), int2(3), int2(4), int2(5) };
    vector<int2> res3 = { int2(1), int2(1), int2(1), int2(1) };
    Polynomial<int2> p(res);
    Polynomial<int2> p1(res2);
    Polynomial<int2> p3(res);
    coutVector((p - p3).get_polynom());
    coutVector((p - p1).get_polynom());
    coutVector(p3.get_polynom());*/
    /*coutVector((p * p1).get_polynom());
    coutVector((p * int2()).get_polynom());
    cout << p1(int2(0));*/
    /*vector<int> res = { 1, 2, 3, 4 };
    Polynomial<int> hh(res);
    coutVector2((hh * 3).get_polynom());
    vector<int2> result = { int2(1), int2(2), int2(3), int2(4) };
    Polynomial<int2> polynom(result);
    vector<int2> result2 = { int2(3), int2(4), int2(5), int2(6) };
    Polynomial<int2> polynom2(result2);
    vector<int2> r = (polynom * polynom2).get_polynom();
    coutVector(r);
    vector<int2> r1 = (polynom + polynom2).get_polynom();
    coutVector(r1);
    vector<int2> r2 = (polynom - polynom2).get_polynom();
    coutVector(r2);
    polynom += polynom2;
    coutVector(polynom.get_polynom());
    polynom -= polynom2;
    coutVector(polynom.get_polynom());
    polynom *= polynom2;
    coutVector(polynom.get_polynom());
    polynom += int2(1);
    coutVector(polynom.get_polynom());
    polynom -= int2(1);
    coutVector(polynom.get_polynom());
    polynom *= int2(2);
    coutVector(polynom.get_polynom());
    coutVector((polynom + int2(2)).get_polynom());
    coutVector((polynom - int2(2)).get_polynom());
    coutVector((polynom * int2(2)).get_polynom());
    coutVector((int2(2) + polynom).get_polynom());
    coutVector((int2(2) - polynom).get_polynom());
    coutVector((int2(2) * polynom).get_polynom());
    cout << (polynom != polynom2);*/
}