Robert Dober
12/2/2007 1:53:00 PM
Here goes my solution for this Quiz, I am confident that solutions 1
and 2 are correct, well 3 too, for 4 that is less sure ;).
Nice to have a quiz which can be solved in less time again.
Robert
###############################
# Read postfix from args or stdin
# Print an infix solution *without* paranthesis
postfix = ARGV.empty? ? $stdin.read.split : ARGV
postfix = postfix.map{ | ele | Integer( ele ) rescue ele }
stack = []
postfix.each do | ele |
case ele
when Integer
stack << ele
else
rhs = stack.pop
stack[ -1 ] = stack[ -1 ].send( ele, rhs )
end
end
puts stack.first.to_s
#########################################################"
# Read postfix from args or stdin
# Print an infix solution with *many* paranthesis
postfix = ARGV.empty? ? $stdin.read.split : ARGV
postfix = postfix.map{ | ele | Integer( ele ) rescue ele }
stack = []
postfix.each do | ele |
case ele
when Integer
stack << ele
else
rhs = stack.pop
stack[ -1 ] = "( #{stack[ -1 ]} ) #{ele} ( #{rhs} )"
end
end
puts stack.first
##################################################
# Read postfix from args or stdin
# Print an infix solution with *some* paranthesis
# the stupid ( and expensive ) way.
class Expression
Combinations = [
["", "", "", ""],
["( ", " )", "", ""],
["", "", "( ", " )"],
["( ", " )", "( ", " )"]
]
attr_reader :text, :value
def initialize text
@value = Integer( text )
@text = text
end
def apply op, rhs
new_text = "#@text #{op} #{rhs.text}"
@value = @value.send( op, rhs.value )
Combinations.each do | parens |
txt = ["", @text, " #{op} ", rhs.text ].
zip( parens ).flatten.join
if eval( txt ) == @value then
return @text = txt
end
end
raise RuntimeError, "ooops"
end
end
postfix = ARGV.empty? ? $stdin.read.split : ARGV
postfix = postfix.map{ | ele | Expression.new( ele ) rescue ele }
stack = []
postfix.each do | ele |
case ele
when Expression
stack << ele
else
rhs = stack.pop
stack.last.apply ele, rhs
end
end
puts stack.first.text
#############################################
# Read postfix from args or stdin
# Print an infix solution with *some* paranthesis
# (the clever way?)
class Expression
Priorities = {
"**" => 2,
"*" => 1, "/" => 1, "%" => 1,
"+" => 0, "-" => 0,
nil => 3
}
Commutative = %w[ * + ]
attr_reader :text, :top_op
def initialize text
@top_op = nil
@text = text
end
def apply op, rhs
@text = parented_text( op ) +
" #{op} " << rhs.parented_text( op, false )
@top_op = op
end
def comm? op
Commutative.include? op
end
def parented_text op, is_lhs=true
my_prio = Priorities[ @top_op ]
op_prio = Priorities[ op ]
return @text if op_prio < my_prio
return "( #@text )" if op_prio > my_prio
return @text if comm?( op ) || is_lhs
"( #@text )"
end
end
postfix = ARGV.empty? ? $stdin.read.split : ARGV
postfix = postfix.map{ | ele |
Expression::Priorities[ ele ] ? ele : Expression.new( ele )
}
stack = []
postfix.each do | ele |
case ele
when Expression
stack << ele
else
rhs = stack.pop
stack[ -1 ].apply ele, rhs
end
end
puts stack.first.text