import re
import math


class SolveTask:
    def __init__(self):
        self._f = math.factorial

    def solve(*args, **kwargs):
        raise NotImplementedError

    def combinations(self, n, k):
        return self._f(n) // self._f(k) // self._f(n - k)

    def _parse_expression(self, expression):
        n = expression.split('^')[1]

        brakets = re.split('[()]', expression)

        values = list(map(lambda x: x.strip(), brakets[1].split('+')))
        values = [int(a) if '0' <= a <= '9' else a for a in values]

        return *values, int(n)


class Solve8b(SolveTask):
    SUPERSCRIPTS = '⁰¹²³⁴⁵⁶⁷⁸⁹'

    def solve(self, expression: str) -> str:
        """Принимает трехчлены в виде: (a+b+c)^n

        Возвращает его раскрытие
        """

        try:
            *values, pow = self._parse_expression(expression)
        except Exception as e:
            return "Could't parse. Invalid syntax!"

        new_expression = []

        for z in range(pow+1):
            for y in range(pow-z+1):
                x = pow - z - y

                koef = self._get_koef(x, y, z)
                powered_values = [self._get_power(a, n) for a, n in zip(values, (x, y, z))]

                for v in powered_values:
                    if isinstance(v, int):
                        koef *= v

                powered_values = list(filter(lambda x: isinstance(x, str), powered_values))

                term = str(koef) + "*" * (len(powered_values) != 0) + "*".join(powered_values)
                new_expression.append(term)

        return " + ".join(new_expression)

    def _get_power(self, a, n):
        if n == 0:
            return 1

        if isinstance(a, int):
            return a ** n

        return f'({a}){"".join([self.SUPERSCRIPTS[int(x)] for x in str(n)])}'

    def _get_koef(self, a, b, c):
        return self._f(a+b+c) // (self._f(a) * self._f(b) * self._f(c))

    def _parse_expression(self, expression):
        n = expression.split('^')[1]

        brakets = re.split('[()]', expression)
        brakets[1] = brakets[1].replace('-', '+-')

        if brakets[1][0] == '+':
            brakets[1] = brakets[1][1:]

        values = list(map(lambda x: x.strip(), brakets[1].split('+')))

        values = [int(a) if a.isdigit() else a for a in values]

        return *values, int(n)


class Solve8a(Solve8b):
    def solve(self, expression: str, k: int) -> str:
        """Берем какое то выражение и вычисляем k член ряда
        """

        try:
            *values, pow = self._parse_expression(expression)
        except Exception as e:
            return "Could't parse. Invalid syntax!"

        k -= 1
        koef = self.combinations(pow, k)

        powered_values = [self._get_power(a, n) for a, n in zip(values, (pow-k, k))]

        for v in powered_values:
            if isinstance(v, int):
                koef *= v

        powered_values = list(filter(lambda x: isinstance(x, str), powered_values))

        term = str(koef) + "*" * (len(powered_values) != 0) + "*".join(powered_values)

        return term


if __name__ == '__main__':
    expressions = [('(-a+b)^3', 4), ('(2a+b)^1', 2), ('(b+4c)^4', 4), ('(5+c)^7', 4)]
    print('Примеры работы:')

    for exp in expressions:
        print(exp, ':', Solve8a().solve(*exp), '\n')