Programme « Évaluation des expressions Postfix » dans Ruby

Question

J'ai essayé de créer un petit script pour évaluer les expressions post-fixes dans Ruby.

def evaluate_post(expression)

    my_stack = Stack.new

    expression.each_char do |ch|        
    begin    
        # Get individual characters and try to convert it to integer
        y = Integer(ch)

        # If its an integer push it to the stack
        my_stack.push(ch)

    rescue    
        # If its not a number then it must be an operation
        # Pop the last two numbers
        num2 = my_stack.pop.to_i            
        num1 = my_stack.pop.to_i


        case ch
        when "+"   
            answer = num1 + num2        
        when "*"       
            answer = num1* num2    
        when "-"        
            answer = num1- num2     
        when "/"        
            answer = num1/ num2    
        end   

        # If the operation was other than + - * / then answer is nil
        if answer== nil
        my_stack.push(num2)
        my_stack.push(num1)
        else
        my_stack.push(answer)
        answer = nil
        end
    end
    end

    return my_stack.pop
end

1. Je ne connais pas de meilleure façon de vérifier si le caractère de l'expression est un entier sans utiliser cette méthode brute ou ces expressions régulières.Avez-vous des suggestions?
2. Existe-t-il un moyen de résumer les cas.Existe-t-il une fonction eval("num1 ch num2") dans Ruby ?

Answer 1

si vous voulez vérifier si une chaîne est un entier, entier () est une façon élégante de le faire, car il fait que votre définition d'un entier correspond à Ruby. si vous préférez ne pas l'utiliser parce qu'il renvoie une exception, les expressions régulières fonctionnent bien - pourquoi les éviter? Notez également que dans le cas entier, vous pouvez simplement pousser y sur votre pile, pas ch, et pas besoin des appels to_i quand popping. comme pour l'autre question, Ruby a effectivement un eval.

y = Integer(ch) rescue nil   
if y  
  stack.push(y)  
else  
  num2, num1 = stack.pop(2)  
  a = eval "#{num2} #{ch} #{num1}" # see mehrdad's comment for why not num1 ch num2  
  stack.push(a)  
end  

Answer 2

Je ne connais pas Ruby donc je ne réponds pas à vos questions.Il y a cependant là un problème algorithmique.Pour ajouter, multiplier l'ordre des opérandes n'a pas d'importance, mais pour la soustraction et la division, vous devez soustraire et diviser le premier opérande par le second.Le premier est celui qui est le plus profond dans la pile.Par conséquent, vous devez échanger ces deux lignes :

num1 = my_stack.pop.to_i
num2 = my_stack.pop.to_i