如何检查Ruby中的闭括号,括号或括号的有效性

Question

写一个方法'valid_string？' 接受一个字符串.如果括号,括号和花括号正确关闭,则返回true.否则返回false.

valid_string?("[ ]")                  # returns true
valid_string?("[  ")                  # returns false
valid_string?("[ ( text ) {} ]")      # returns true
valid_string?("[ ( text { ) } ]")     # returns false

---

我的代码:对所有事情都是假的.甚至尝试对个别情况{} ||使用显式布尔值 ()||等没有用.对于一切都返回true或false.这是我的驱动程序代码吗？

def valid_string?(str) 

    if str == ("\[\s+]")
        true
    else
        false
    end
end

更新的解决方案:----------------------------------------------- - 是的!#match绝对更好!虽然我的最后一行测试代码正在评估为true.什么时候应该是假的...

def valid_string?(str) 
if str.match "(\\[.+\\])" || "|(\\(\\))" || "|({})"
    return true
else
    return false
    end
end

puts valid_string?("[ ]")                  # returns true
puts valid_string?("[  ")                  # returns false
puts valid_string?("[ ( text ) {} ]")      # returns true
puts valid_string?("[ ( text { ) } ]")     # returns false

Answer 1

我认为用它regex来解决这个问题可能很复杂.这是一个潜在的解决方案:你可以使用一个栈来记录左侧符号一样{,[,(在遍历.每次遇到正确的符号时,只需检查堆栈顶部的符号是否与此右符号匹配.false如果不匹配,只需返回.

以下是我的代码:

def valid_string?(str)
  stack = []
  symbols = { '{' => '}', '[' => ']', '(' => ')' }
  str.each_char do |c|
    stack << c if symbols.key?(c)
    return false if symbols.key(c) && symbols.key(c) != stack.pop
  end
  stack.empty?
end

puts valid_string?('[ ]')                  # returns true
puts valid_string?('[  ')                  # returns false
puts valid_string?('[ ( text ) {} ]')      # returns true
puts valid_string?('[ ( text { ) } ]')     # returns false

Answer 2

只因为它很有趣,我继续解决了这个Ruby Way :)

class Brackets
  class Bracket
    def initialize(open, close)
      @open = open
      @close = close
      @match_count = 0
    end
    attr_reader :match_count, :open, :close

    def check(c)
      @match_count += 1 if c == @open
      @match_count -= 1 if c == @close
    end
  end

  def initialize
    @brackets = []
    @stack = []
    @valid = true
  end

  def add(open, close)
    @brackets << Bracket.new(open,close)
  end

  def check(c)
    @brackets.each do |b|
      b.check(c)
      @stack.push(c) if c == b.open
      @valid = false if c == b.close and @stack.pop != b.open
    end
  end

  def valid?
    total = 0
    @brackets.each { |b| total += b.match_count }
    total == 0 && @valid == true
  end
end

def valid_string?(str)
  brackets = Brackets.new
  brackets.add('[', ']')
  brackets.add('{', '}')
  brackets.add('(', ')')

  str.each_char { |c| brackets.check(c) }
  brackets.valid?
end

# Our tests
puts valid_string?("[ ]") ? 'true' : 'false'                 # returns true
puts valid_string?("[  ") ? 'true' : 'false'                 # returns false
puts valid_string?("[ ( text ) {} ]") ? 'true' : 'false'     # returns true
puts valid_string?("[ ( text { ) } ]") ? 'true' : 'false'    # returns false
puts valid_string?("[ ( text { } ) ]") ? 'true' : 'false'    # returns true

Answer 3

这是一种不使用正则表达式的方法:

def valid_string?(str)
  strim = str.gsub(/[^\[\]\(\)\{\}]/,'')
  return true if strim.empty?
  return false if strim.size.odd?
  loop do  
    s = strim.gsub('()','').gsub('[]','').gsub('{}','')
    return true if s.empty?
    return false if s == strim
    strim = s
  end   
end

p valid_string?("[ ]")               # => true
p valid_string?("[  ")               # => false
p valid_string?("[ ( text ) {} ]")   # => true
p valid_string?("[ ( text { ) } ]")  # => false
p valid_string?("[ ( text { more text { (more text) }} )]")  # => true

• 首先删除除"()[] {}"之外的所有字符.
• 如果剩余的字符串为空,则返回true
• 如果剩余的字符串包含奇数个字符,则返回false.
• 继续删除相邻的对'()','[]'和'[]',直到字符串为空,在这种情况下返回true,或者不能删除更多的相邻对,并且字符串是非空的,在这种情况下返回false.