5.1

from math import gcd


class R:

    def __init__(self, m, n):
        self._num = m
        self._den = n

    def __add__(self, other):
        nok = (self._den * other._den) // gcd(self._den, other._den)
        tmp = self._num * (nok // self._den) + other._num * (nok // other._den)
        return f'{tmp}/{nok}'

    def __sub__(self, other):
        nok = (self._den * other._den) // gcd(self._den, other._den)
        tmp = self._num * (nok // self._den) - other._num * (nok // other._den)
        return f'{tmp}/{nok}'

    def get_ten(self):
        return f'{self._num / self._den}'

    def __lt__(self, other):
        nok = (self._den * other._den) // gcd(self._den, other._den)
        if self._num * (nok // self._den) < other._num * (nok // other._den):
            return f'{self._num}/{self._den}'

    def __gt__(self, other):
        nok = (self._den * other._den) // gcd(self._den, other._den)
        if self._num * (nok // self._den) > other._num * (nok // other._den):
            return f'{self._num}/{self._den}'

    def __str__(self):
        return f'{self._num}/{self._den}'


f, f1, f2, f3, f4, f5 = R(9, 11), R(3, 4), R(5, 6), R(6, 7), R(7, 8), R(4, 5)


class SetR:

    def __init__(self, *args):
        self.list = list(args)

    def get_max(self):
        return max(self.list)

    def get_min(self):
        return min(self.list)

    def get_count_max(self, item):
        p = self.list[self.list.index(item) + 1:]
        return len(p)

    def get_count_min(self, item):
        g = self.list[:self.list.index(item)]
        return len(g)

    def __getitem__(self, item):
        return self.list[item]

    def __setitem__(self, key, value):
        self.list[key] = value
        return self.list

    def __len__(self):
        return len(self.list)

    def __str__(self):
        l = [f'{self.list[i]}' for i in range(len(self.list))]
        return '[' + ', '.join(l) + ']'


s = SetR(f, f1, f3, f2, f5, f4)
d = SetR(f1, f2, f3)


class Polynom:

    def __init__(self, x):
        self.x = x

    def __add__(self, other):
        storage = []
        if len(self.x) > len(other.x):
            copy = self.x
        else:
            copy = other.x
        for i in range(-min(len(self.x), len(other.x)), 0):
            storage.append(self.x[i] + other.x[i])
        for i in range(-len(storage), 0):
            copy.__setitem__(i, storage[i])
        l = [f'({copy[i]} * x**{len(copy) - i})' for i in range(len(copy))]
        return ' + '.join(l)

    def __str__(self):
        l = [f'({self.x[i]} * x**{len(self.x) - i})' for i in range(len(self.x))]
        return ' + '.join(l)
        # return f'{self.f}'


x = Polynom(s)
y = Polynom(d)
print(x + y)