Вывести все возможные варианты результата и их вероятности

word = input()
list_var = list(re.findall(r'd\d+', word))
pools = [range(1, int(n[1:])+1) for n in list_var]
result_tmp =  [[]]
result = {}
for pool in pools:
    result_tmp = [x+[y] for x in result_tmp for y in pool]
for i in result_tmp:
 
    tmp = list(zip(list_var, i))
 
    word_tmp = word
    for k,v in tmp:
        word_tmp = word_tmp.replace(str(k), str(v), 1)
 
    res_tmp = eval_(word_tmp)
    result[res_tmp] = result.get(res_tmp, 0)+1
summa = sum(result.values())
for k,v in sorted(result.items(), key=lambda x: x[0]):
    print('{0} {1:.2f}'.format(int(k), v*100/summa))

import re
 
 
class D:
    def __init__(self, tup, f=0):
        if f:
            self.d = {tup[0]: tup[1]}
        else:
            self.d = dict(tup)
 
    def __add__(self, other):
        t = {}
        for k1, v1 in self.d.items():
            for k2, v2 in other.d.items():
                if k1 + k2 in t.keys():
                    t[k1 + k2] += v1 * v2
                else:
                    t[k1 + k2] = v1 * v2
        return D(t.items())
 
    def __sub__(self, other):
        t = {}
        for k1, v1 in self.d.items():
            for k2, v2 in other.d.items():
                if k1 - k2 in t.keys():
                    t[k1 - k2] += v1 * v2
                else:
                    t[k1 - k2] = v1 * v2
        return D(t.items())
 
    def __mul__(self, other):
        t = {}
        for k1, v1 in self.d.items():
            for k2, v2 in other.d.items():
                if k1 * k2 in t.keys():
                    t[k1 * k2] += v1 * v2
                else:
                    t[k1 * k2] = v1 * v2
        return D(t.items())
 
    def __gt__(self, other):
        t = {}
        for k1, v1 in self.d.items():
            for k2, v2 in other.d.items():
                if int(k1 > k2) in t.keys():
                    t[int(k1 > k2)] += v1 * v2
                else:
                    t[int(k1 > k2)] = v1 * v2
        return D(t.items())
 
 
inf, pattern = "999*2*(d5-d7)>3+d9>3*(4>d4)", re.compile(r"(?:d\d+)|\d+")
list_to_join = re.findall(r"(?:d\d+)|\d+|[-+*>()]", inf)
lenght = len(list_to_join)
 
for i in range(lenght):
    if list_to_join[i].isdigit():
        list_to_join[i] = f"D({(int(list_to_join[i]), 1)}, 1)"
    elif list_to_join[i] in ("*", ">", "+", "-", ")", "("):
        continue
    else:
        list_to_join[
            i] = f"D({tuple((x, 1/int(list_to_join[i].lstrip('d'))) for x in range(1, int(list_to_join[i].lstrip('d')) + 1))})"
 
inf = "".join(list_to_join)
 
result = eval(inf)
for k, v in sorted(result.d.items()):
    print(f"{k} {v:.2f}")

import re
import string
from itertools import product
 
new_var_bank = []
for i in string.ascii_lowercase[:10]:
    for j in string.ascii_lowercase[:10]:
        new_var_bank.append(i + j)
        if len(new_var_bank) == 100:
            break
 
expression = 'd100+d100+d100+d100'
 
variables = sorted(re.findall(r'd\d+', expression), key=lambda x: int(x[1:]))
combinations = list(product(*[range(1, int(v[1:]) + 1) for v in variables]))
while len(set(variables)) != len(variables):
    for i in range(len(variables) - 1):
        if variables[i] == variables[i + 1]:
            new_var_name = new_var_bank.pop()
            expression = expression.replace(variables[i], new_var_name, 1)
            variables[i] = new_var_name
res = {}
for interval in combinations:
    for x, y in zip(interval, variables):
        vars()[y] = x
    key = eval(expression)
    res[key] = res.get(key, 0) + 1
s = sum(res.values())
answer = sorted(res.items(), key=lambda f: f[0])
for k, v in answer:
    print(f'{k} {v / s * 100:.2f}')