#include <iostream>

using namespace std;

class rational {

public:

    rational(int numerator, int denominator) {
        numerator_ = numerator;
        denominator_ = denominator;
        reduction();
    }

    int numerator() const {
        return numerator_;
    }

    int denominator() const {
        return denominator_;
    }

    rational& operator+=(const rational& other) {
        numerator_ = numerator_ * other.denominator_ + other.numerator_ * denominator_;
        denominator_ = denominator_ * other.denominator_;
        reduction();
        return *this;
    } // переопределение оператора +=

    rational& operator-=(const rational& other) {
        numerator_ = numerator_ * other.denominator_ - other.numerator_ * denominator_;
        denominator_ = denominator_ * other.denominator_;
        reduction();
        return *this;
    } // переопределение оператора -=

    rational& operator*=(const rational& other) {
        numerator_ *= other.numerator_;
        denominator_ *= other.denominator_;
        reduction();
        return *this;
    } // переопределение оператора *=

    rational& operator/=(const rational& other) {
        numerator_ *= other.denominator_;
        denominator_ *= other.numerator_;
        reduction();
        return *this;
    } // переопределение оператора /=

private:
    int numerator_;
    int denominator_;

    void reduction() { // сокращение дроби

        if (denominator_ < 0) {
            numerator_ *= -1;
            denominator_ *= -1;
        }

        int x = numerator_ < 0 ? -numerator_ : numerator_;
        int y = denominator_;

        while (x != y) {
            if (x > y) {
                x -= y;
            }
            else {
                y -= x;
            }
        }
        numerator_ /= x;
        denominator_ /= x;
    }
};

rational& operator+(const rational& left, const rational& right) {
    rational temp = left;
    return temp += right;
} // переопределение оператора + с помощью ранее переопределенного оператора +=

rational& operator-(const rational& left, const rational& right) {
    rational temp = left;
    return temp -= right;
} // переопределение оператора - с помощью ранее переопределенного оператора -=

rational& operator*(const rational& left, const rational& right) {
    rational temp = left;
    return temp *= right;
} // переопределение оператора * с помощью ранее переопределенного оператора *=

rational& operator/(const rational& left, const rational& right) {
    rational temp = left;
    return temp /= right;
} // переопределение оператора / с помощью ранее переопределенного оператора /=

bool operator==(const rational& left, const rational& right) {
    return left.numerator() == right.numerator() && left.denominator() == right.denominator();
} // перегрузка оператора ==

bool operator!=(const rational& left, const rational& right) {
    return !(left == right);
} // перегрузка оператора != с помощью ранее переопределенного ==

bool operator>(const rational& left, const rational& right) {
    return left.numerator() * right.denominator() > right.numerator() * left.denominator();
}

bool operator<(const rational& left, const rational& right) {
    return left.numerator() * right.denominator() < right.numerator() * left.denominator();
}

bool operator>=(const rational& left, const rational& right) {
    return left.numerator() * right.denominator() >= right.numerator() * left.denominator();
}

bool operator<=(const rational& left, const rational& right) {
    return left.numerator() * right.denominator() <= right.numerator() * left.denominator();
}

ostream& operator<<(ostream& output, const rational& right) {
     return output << right.numerator() << '/' << right.denominator();
}

istream& operator>>(istream& input, rational& right) {
    int numerator;
    int denominator;
    char slash;
    if ((input >> numerator) && (input >> slash) && (slash == '/') && (input >> denominator)) {
        right = rational{ numerator, denominator };
    }
    return input;
}


int main() {

    setlocale(LC_ALL, "ru");

    rational r1(1, 2);
    rational r2(3, 4);
    cout << r1 << endl;
    cout << r2 << endl;

    cout << (r1 == r2) << endl;
    cout << (r1 != r2) << endl;
    cout << (r1 > r2) << endl;
    cout << (r1 < r2) << endl;
    cout << (r1 >= r2) << endl;
    cout << (r1 <= r2) << endl;

    r1 += r2;
    cout << r1 << endl;

    r1 -= r2;
    cout << r1 << endl;

    r1 *= r2;
    cout << r1 << endl;

    r1 /= r2;
    cout << r1 << endl;

    int a = 3;
    int b = 2;

    rational r3(1, 1);
    r3 = r1 + r2;
    cout << r3 << endl;

    r3 = r1 - r2;
    cout << r3 << endl;

    r3 = r1 * r2;
    cout << r3 << endl;

    r3 = r1 / r2;
    cout << r3 << endl;

    cin >> r3;
    cout << r3 << endl;
}