__author__ = 'minidonut'

ops = ["+", "-", "*", "/"]
counts = 0


def generate_list_digits(count):

if count >= 10:
print("count must be <= 10")
return
    else:
        params = 'abcdefghijk'
        exp = '['
        for i in range(count):
            exp += 'str(' + params[i] + ')'
            if i != count-1:
                exp += '+ '
        exp += ' '
        for i in range(count):
            exp += 'for ' + params[i] + ' in range('
            if i != 0:
                exp += params[i-1] + '+1, '
            else:
                exp += '1, '
            exp += '10) '
        exp += ']'

    return eval(exp)


def make_to_ten(lst):
    to_ten_exps = []

def generate(numbers, expression, result):
global counts
        counts += 1
        if numbers:
            operand = numbers[:].pop(0)
            poped_list = [x for x in numbers if x != numbers[0]]
if expression == "":
                generate(poped_list, operand, eval(operand))
else:
for i in ops:
                    new_expression = make_expression(expression, i, operand)
if new_expression[0] == 1:
                        generate(poped_list, new_expression[1], eval(new_expression[1]))
else:
                        generate(poped_list, new_expression[1], eval(new_expression[1]))
                        generate(poped_list, new_expression[2], eval(new_expression[2]))
else:
# print(expression)
            if result == 10:
return to_ten_exps.append(expression)
else:
return

    for i in lst:
        generate(i, "", 0)
return to_ten_exps


def make_expression(op1, operator, op2):
if operator == '+' or operator == '-':
if len(op1) >= 3:
if op1[len(op1)-3] == '+' or op1[len(op1)-3] == '-':
if not len(op1) >= 7:
                    op1 = op1[1: len(op1)-1]
else:
if not op1[len(op1)-1] == ')':
                    op3 = op1[: len(op1)-1] + '(' + op1[len(op1)-1]
return 2, '(' + op1 + operator + op2 + ')',  op3 + operator + op2 + ')'
        return 1, '(' + op1 + operator + op2 + ')', None
    else:
if len(op1) == 5 and op1[0] == '(':
return 2, op1 + operator + op2, op1[:3] + '(' + op1[3] + operator + op2 + '))'
        else:
return 1, op1 + operator + op2, None


def list_of_orders(numbers):
    ret = []

def generate(input_list, output_list):
if input_list:
for i in input_list:
                generate([x for x in input_list if x != i], output_list[:]+[i])
else:
return ret.append(output_list)

    generate(numbers, [])
return ret


def remove_duplicate_exp(exp_list):
    tmp_dic = {}
for i in exp_list:
        i = remove_brackets(i)
        lst = [x for x in i]
        lst.sort()
        str1 = ''.join(lst)
if not str1 in tmp_dic:
            tmp_dic[str1] = i

return list(tmp_dic.values())


def remove_brackets(exp):
    lst = [x for x in exp]
if lst.__contains__('*') or lst.__contains__('/'):
return exp
else:
while lst.__contains__('('):
            lst.remove('(')
while lst.__contains__(')'):
            lst.remove(')')
return ''.join(lst)


def generate_exps(numbers):
    lst = [x for x in numbers]
return remove_duplicate_exp(make_to_ten(list_of_orders(lst)))


def exp_to_tens(digits):
    ret = {}
    argument = generate_list_digits(digits)
for i in argument:
        ret[i] = generate_exps(i)

return ret


if __name__ == "__main__":

# args_4 = generate_list_digits(4)

    exps_for_4 = exp_to_tens(4)
    key_list = list(exps_for_4.keys())
    key_list.sort()
for i in key_list:
print (i, ":", exps_for_4[i])

print (counts)