7.2

from math import gcd


class R:

    def __init__(self, m: int, n: int) -> None:
        if n == 0:
            raise ZeroDivisionError('Division by zero')
        else:
            self._num = m
            self._den = n

    def __add__(self, other: 'R') -> 'R':
        if not isinstance(other, R):
            raise TypeError
        else:
            nok = (self._den * other._den) // gcd(self._den, other._den)
            tmp = self._num * (nok // self._den) + other._num * (nok // other._den)
            return R(tmp, nok)

    def __sub__(self, other: 'R') -> 'R':
        if not isinstance(other, R):
            raise TypeError
        else:
            nok = (self._den * other._den) // gcd(self._den, other._den)
            tmp = self._num * (nok // self._den) - other._num * (nok // other._den)
            return R(tmp, nok)

    def get_ten(self) -> str:
        if self._den == 0:
            raise ZeroDivisionError('Impossible')
        else:
            return f'{self._num / self._den}'

    def __lt__(self, other: 'R') -> 'R':
        if not isinstance(other, R):
            raise TypeError
        else:
            nok = (self._den * other._den) // gcd(self._den, other._den)
            if self._num * (nok // self._den) < other._num * (nok // other._den):
                return R(self._num, self._den)

    def __gt__(self, other: 'R') -> 'R':
        if not isinstance(other, R):
            raise TypeError
        else:
            nok = (self._den * other._den) // gcd(self._den, other._den)
            if self._num * (nok // self._den) > other._num * (nok // other._den):
                return R(self._num, self._den)

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


f, f1, f2, f3, f4, f5 = R(9, 2), R(3, 4), R(5, 6), R(6, 7), R(7, 1), R(4, 5)
b = f + f1
print(b)


class SetR:

    def __init__(self, *args: R) -> None:
        for i in range(len(args)):
            if isinstance(args[i], R):
                self.list = list(args)
            else:
                raise TypeError("Type isn't R")

    def get_max(self) -> R:
        return max(self.list)

    def get_min(self) -> R:
        return min(self.list)

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

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

    def __getitem__(self, item: int) -> R:
        return self.list[item]

    def __setitem__(self, key: int, value: R) -> list:
        self.list[key] = value
        return self.list

    def __len__(self) -> int:
        return len(self.list)

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


s = SetR(f, f1, f3, f2, f5, f4)
n = SetR(f1, f2, f3)
print(max(s))


class Polynomial:

    def __init__(self, x: SetR) -> None:
        if isinstance(x, SetR):
            self.x = x
        else:
            raise TypeError("Type isn't SetR")

    def __add__(self, other: 'Polynomial') -> 'Polynomial':
        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[i] = storage[i]
        return Polynomial(copy)

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


x = Polynomial(s)
y = Polynomial(n)
print(x + y)