Checking Balanced Parentheses (an Application of Stacks)

In this lesson you will apply a stack to check that brackets match up, seeing a data structure put to practical use. This is for anyone searching for "Ruby balanced parentheses check".

With a stack (last in, first out) you can push opening brackets such as ( and [, then check each closing bracket against whatever is on top. That is how bracket matching works.

The sample code uses the array stack as a stack, walks the string one character at a time with str.each_char, pushes on an opening bracket, and on a closing one checks the popped value against the pairs hash.

A common stumbling block for beginners is the case where the closing bracket is the wrong kind. Matching counts alone is not enough - you have to confirm that each pair is of the right type, and that is the heart of this algorithm.

The same idea is used behind editor auto-completion and code syntax checking. Plenty of similar tools check that HTML opening and closing tags line up correctly.

📖 Reference code

def balanced?(str)
  stack = []
  pairs = { ")" => "(", "]" => "[", "}" => "{" }
  str.each_char do |ch|
    if "([{".include?(ch)
      stack.push(ch)
    elsif ")]}".include?(ch)
      return false if stack.pop != pairs[ch]
    end
  end
  stack.empty?
end

puts balanced?("(a[b]{c})")
puts balanced?("(a[b)]")

✍️ Your code

Type your code, then press "Run"

🧪 This site can't compile or run Ruby directly, so it checks on the spot whether what you typed matches the reference code (scoring happens entirely in your browser — nothing is sent anywhere).