Pas de force brute, mais soyons bourrins, oh oui, bourrins !

Pour l'exo 1 je fais du re.findall, str.replace, re.sub, et un gros eval dès que j'ai root.
Youpi, bourrin :)

Pour le 2, bah non.
On remplace root: truc * much par root: truc - much, et humn: ???? par humn: X
À la fin on a une grosse opération bourrée de parenthèses, avec au fond du fond (X), il faut résoudre ce truc = 0.
Donc on remonte en inversant les opérations, chaque parenthèse est (nombre opération (trucs...)) ou ((trucs...) opération nombre), des gros if tout moches, et à la fin le résultat.

Sans finesse ça va assez vite : une demi seconde.

import re
def iteration1(data):
 reg=re.compile(r"^([a-z]{4}): ([^a-z]+?)$",re.MULTILINE)
 while True:
 numbers = {
 a: f"({b})" if 'X' in b else str(eval(b))
 for a, b in reg.findall(data)
 }
 if "root" in numbers:
 yield numbers['root']
 return
 data = reg.sub("", data)
 for name, value in numbers.items():
 data = data.replace(name, value)
 yield data
def iteration2(data, r=0):
 reg1 = re.compile(r"^\((.*) (.) ([\d.]+)\)$")
 reg2 = re.compile(r"^\(([\d.]+) (.) (.*)\)$")
 while True:
 # r = a o b
 a, o, b = (reg1.findall(data) + reg2.findall(data))[0]
 if 'X' in a:
 data = a
 if o == '+':
 r = r - float(b)
 if o == '-':
 r = r + float(b)
 if o == '*':
 r = r / float(b)
 if o == '/':
 r = r * float(b)
 else:
 data = b
 if o == '+':
 r = r - float(a)
 if o == '-':
 r = float(a) - r
 if o == '*':
 r = r / float(a)
 if o == '/':
 r = float(a) / r
 yield data, r
 if data == "(X)":
 return
data = sys.stdin.read().strip()
# Exercice 1
r = 0
for d in iteration1(data):
 r = d
print(eval(d))
# Exercice 2
data2 = re.sub(r"root: ([a-z]{4}) . ([a-z]{4})", r"root: 1円 - 2円", re.sub(r"humn: \d+", "humn: X", data))
for d in iteration1(data2):
 r = d
for d in iteration2(r, 0):
 r = d
print(r[1])

Zéro modélisation, à peine de la réflexion, zéro optimisations sauf l'eval ajouté dans l'iteration1 quand on peut réduire à un nombre, basta.

• Yth.