Resolviendo expresiones completamente entre paréntesis con recursión.

Estoy teniendo problemas para encontrar un método recursivo que pueda resolver ecuaciones completamente entre paréntesis … como ((3+2)/(1+4)) . Pude encontrar una solución recursiva para resolver expresiones infijos como +*+3421 usando recursión, pero para algo como ((3+2)/(1+4)) estoy un poco atascado.

 def evalPrefix(exp): it = iter(exp) return evalPrefixInner(it) def evalPrefixInner(it): item = it.next() if isInt(item): return int(item) else: operand1 = evalPrefixInner(it) operand2 = evalPrefixInner(it) return execute(item, operand1, operand2) 

Tu gramática es:

 expr ::= int | ( expr op expr ) 

¿correcto?

Entonces, ignorando la comprobación de errores, algo como …

 def evalExpr(it): item = it.next() if isInt(item): return int(item) else: //item should = lparen operand1 = evalExpr(it) op = it.next() operand2 = evalExpr(it) rparen = it.next() return execute(op, operand1, operand2) 

Intente el shunting-yard algorithm la shunting-yard algorithm :

 dic={"+": lambda x, y:x+y, "-": lambda x, y:xy, "/": lambda x, y:x/y, "%": lambda x, y:x%y, "*": lambda x, y:x*y} def algo(x, op=None, nums=None): if x != "": op = op if op else [] nums = nums if nums else [] item = x[0] if item in ("+","-","%","/","*"): op.append(item) if item.isdigit(): nums.append(item) if item==")": operator = op.pop() opd1, opd2 = int(nums.pop()), int(nums.pop()) ans = dic[operator](opd1, opd2) nums.append(ans) return algo(x[1:], op, nums) else: if op and nums: operator = op.pop() opd1, opd2 = int(nums.pop()), int(nums.pop()) return dic[operator](opd1, opd2) else: return nums[-1] print algo("((3+2)/(1+4))") #output :1 print algo("((5+2)*3*(2+5))") #output :147 

Analice la entrada para datos válidos y luego use el módulo del compiler para analizar la expresión de la siguiente manera:

 import compiler expr = compiler.compile(r'((3+2)/(4+1))', 'err', 'eval') 

y luego puedes usar:

 eval(expr)