#include <cassert>
#include <iostream>
#include <numeric>

// VERSÃO 1!
class Rational {
  int _numerator;
  int _denominator;
  void _normalize();

public:
  // Multiplica por other.
  Rational multiply(Rational other) const;
  // Divide por other.
  Rational divide(Rational other) const;
  // Soma other.
  Rational add(Rational other) const;
  // Subtrai other.
  Rational subtract(Rational other) const;
  // Inverte sinal.
  Rational negative() const;
  // Verifica se igual a other.
  bool is_equal(Rational b) const;
  // Acesso (apenas leitura) a numerador e denominador.
  int numerator() const;
  int denominator() const;

  // Ajusta fração.
  void set(int numerator, int denominator);
};

// Garante que:
// - r.denominator > 0
// - std::gcd(r.numerator, r.denominator) == 1
void Rational::_normalize() {
  // Se denominador fornecido e zero, nao ha o que fazer.
  assert(_denominator != 0);

  // Garante que o denominador e positivo.
  if (_denominator < 0) {
    _numerator = -_numerator;
    _denominator = -_denominator;
  }

  // Elimina fatores comuns no numerador e denominador.
  auto common = std::gcd(_numerator, _denominator);
  _numerator /= common;
  _denominator /= common;
}

// Multiplica por other.
Rational Rational::multiply(Rational other) const {
  Rational result;
  result._numerator = _numerator * other._numerator;
  result._denominator = _denominator * other._denominator;
  result._normalize();
  return result;
}

// Divide por other.
Rational Rational::divide(Rational other) const {
  Rational result;
  result._numerator = _numerator * other._denominator;
  result._denominator = _denominator * other._numerator;
  result._normalize();
  return result;
}

// Soma other.
Rational Rational::add(Rational other) const {
  Rational result;
  result._numerator =
      _numerator * other._denominator + _denominator * other._numerator;
  result._denominator = _denominator * other._denominator;
  result._normalize();
  return result;
}

// Subtrai other.
Rational Rational::subtract(Rational other) const {
  Rational result;
  result._numerator =
      _numerator * other._denominator - _denominator * other._numerator;
  result._denominator = _denominator * other._denominator;
  result._normalize();
  return result;
}

// Inverte sinal.
Rational Rational::negative() const {
  Rational result;
  result._numerator = -_numerator;
  result._denominator = _denominator;
  return result;
}

// Verifica se igual a other.
bool Rational::is_equal(Rational other) const {
  return _numerator == other._numerator && _denominator == other._denominator;
}

// Ajusta valor da fração.
void Rational::set(int numerator, int denominator) {
  _numerator = numerator;
  _denominator = denominator;
  _normalize();
}

int Rational::numerator() const { return _numerator; }

int Rational::denominator() const { return _denominator; }

void show(std::ostream &os, Rational r, std::string sep = "\n") {
  os << r.numerator() << "/" << r.denominator() << sep;
}

int main(int, char *[]) {
  Rational a, b, c;
  a.set(1, 4);
  b.set(3, 7);

  c = a.multiply(b);
  show(std::cout, c);

  c = a.divide(b);
  show(std::cout, c);

  c = a.add(b);
  show(std::cout, c);

  c = a.subtract(b);
  show(std::cout, c);

  c.set(0, 1);
  for (int i = 0; i < 10; ++i) {
    c = c.add(a.multiply(b));
    show(std::cout, c, ", ");
  }
  std::cout << std::endl;
}