Writing in Ruby, testing for matching parentheses, brackets and curly braces - ruby

Question

The question says to write a function that takes a string of braces, and determines if the order of the braces is valid. It should return true if the string is valid, and false if it's invalid.
All input strings will be nonempty, and will only consist of parentheses, brackets and curly braces: ()[]{}.
The tests should give these:
"(){}[]" => True
"([{}])" => True
"(}" => False
"[(])" => False
"[({})](]" => False
The code I've written is:
def validBraces(braces)
revBraces = braces.reverse
arr = []
i = -1
loop do
i += 1
if braces[i] == "(" && revBraces[i] == ")"
arr << 1
else
arr << 0
end
if braces[i] == ")" && revBraces[i] == "("
arr << 1
else
arr << 0
end
if braces[i] == "{" && revBraces[i] == "}"
arr << 1
else
arr << 0
end
if braces[i] == "}" && revBraces[i] == "{"
arr << 1
else
arr << 0
end
if braces[i] == "[" && revBraces[i] == "]"
arr << 1
else
arr << 0
end
if braces[i] == "]" && revBraces[i] == "["
arr << 1
else
arr << 0
end
break if i <= braces.length
end
if arr.include? 0
puts false
else
puts true
end
end
I cant tell where I've gone wrong and why it doesn't work.

Answer 1

I would use a stack to solve this problem. Add found opening braces to the stack and for closing braces compare them with the brace from the top of the stack.
def validBraces(braces)
matches = { '(' => ')', '{' => '}', '[' => ']' }
stack = []
braces.chars.each do |char|
case char
when *matches.keys
stack.push(char)
when *matches.values
return false if matches[stack.pop] != char
else
raise ArgumentError, "Unexpected char `#{char}`"
end
end
stack.empty?
end
validBraces("(){}[]") #=> true
validBraces("([{}])") #=> true
validBraces("(}") #=> false
validBraces("[(])") #=> false
validBraces("[({})](]") #=> false
validBraces("[A]") #=> Unexpected char `A` (ArgumentError)
Or following OOP:
class Balancer
MATCHES = { '(' => ')', '{' => '}', '[' => ']' }
OPENING = MATCHES.keys
CLOSING = MATCHES.values
def initialize(string)
#chars = string.chars
end
def valid?
stack = []
chars.each do |char|
case char
when *OPENING
stack.push(char)
when *CLOSING
return false if MATCHES[stack.pop] != char
else
raise ArgumentError, "Unexpected char `#{char}`"
end
end
stack.empty?
end
private
attr_reader :chars
end
Balancer.new("(){}[]").valid? #=> true
Balancer.new("([{}])").valid? #=> true
Balancer.new("(}").valid? #=> false
Balancer.new("[(])").valid? #=> false
Balancer.new("[({})](]").valid? #=> false
Balancer.new("[A]").valid? #=> Unexpected char `A` (ArgumentError)

Answer 2

The logics is wrong.
You take braces and reverseBraces. And you don't think of cases where the braces are nested. But even when not nested the way you go through the string is not right. Better have a dictionary of "(", "{", "[", ")", "}", "]" and count their frequency (make the closing brackets' counts negative) and see whether they cancel themselves out by building a sum - it should be 0.
def freqs(l)
h = Hash.new(0)
l.each do |e|
h[e] += 1
end
return h
end
def balanced(braces)
fr = freqs(braces.split(""))
return fr["("] - fr[")"] == 0 && fr["{"] - fr["}"] == 0 && fr["["] - fr["]"] == 0
end

Answer 3

One way to do that is to successively remove strings '()', '[]' and '{}' until either the string is empty, in which case the string is found to be balanced, or at some iteration no string '()', '[]' or '{}' is found, in which case the string is found to be unbalanced.
RGX = /\(\)|\[\]|{}/
def valid_braces(str)
s = str.dup
until s.empty?
return false if s.gsub!(RGX, '').nil?
end
true
end
valid_braces '(){}[]' #=> true
valid_braces '([{}])' #=> true
valid_braces '([[{[]}]{}]())' #=> true
valid_braces '(}' #=> false
valid_braces '[(])' #=> false
valid_braces '[({})](]' #=> false
valid_braces('[A]') #=> false
The regular expression reads, "match '()' or '[]' or '{}'". Note that String#gsub! returns nil if no substitutions are performed.
I can insert a puts statement to illustrate what is happening at each iteration.
def valid_braces(str)
s = str.dup
until s.empty?
puts s
return false if s.gsub!(RGX, '').nil?
end
true
end
valid_braces '([[{[]}]{}]())'
([[{[]}]{}]()) full string
([[{}]]) '[]', '{}' and '()' removed
([[]]) '{}' removed
([]) '[]' removed
() '[]' removed
'()' removed
#=> true as `str` is empty
This is probably not as efficient as using a stack, as #spickermann has done. I would implement that a little differently.
CLOSE_TO_OPEN = { ')'=>'(', ']'=>'[', '}'=>'{' }
OPENS = CLOSE_TO_OPEN.values
#=> ["(", "[", "{"]
def valid_braces(str)
stack = []
str.each_char do |c|
if OPENS.include?(c)
stack << c
else
return false unless CLOSE_TO_OPEN[c] == stack.pop
end
end
return stack.empty?
end
valid_braces '(){}[]' #=> true
valid_braces '([{}])' #=> true
valid_braces '([[{[]}]{}]())' #=> true
valid_braces '(}' #=> false
valid_braces '[(])' #=> false
valid_braces '[({})](]' #=> false
valid_braces('[A]') #=> false
We can add puts statements to see what is happening.
def valid_braces(str)
stack = []
str.each_char do |c|
print "stack = #{stack}, c = '#{c}', "
if OPENS.include?(c)
stack << c
puts "pushed '#{c}'"
else
return false unless CLOSE_TO_OPEN[c] == stack.pop
puts "popped '#{CLOSE_TO_OPEN[c]}'"
end
end
puts "stack at end = #{stack}"
return stack.empty?
end
valid_braces '([[{[]}]{}]())'
stack = [], c = '(', pushed '('
stack = ["("], c = '[', pushed '['
stack = ["(", "["], c = '[', pushed '['
stack = ["(", "[", "["], c = '{', pushed '{'
stack = ["(", "[", "[", "{"], c = '[', pushed '['
stack = ["(", "[", "[", "{", "["], c = ']', popped '['
stack = ["(", "[", "[", "{"], c = '}', popped '{'
stack = ["(", "[", "["], c = ']', popped '['
stack = ["(", "["], c = '{', pushed '{'
stack = ["(", "[", "{"], c = '}', popped '{'
stack = ["(", "["], c = ']', popped '['
stack = ["("], c = '(', pushed '('
stack = ["(", "("], c = ')', popped '('
stack = ["("], c = ')', popped '('
stack at end = []
#=> true