如何在 Ruby 中检查右括号、圆括号或方括号的有效性

Question

写一个方法'valid_string?'接受一个字符串。如果括号、圆括号和花括号正确闭合，则返回 true。否则返回 false。

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

---

我的代码：对所有内容都返回 false。甚至尝试对个别情况使用显式布尔值 {} || () || 等都没有用。对所有内容都返回 true 或 false。是我的驱动代码吗？

def valid_string?(str) 

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

更新的解决方案：-------------------------------------------------------- ---- 是的！ #match 肯定效果更好！尽管我的最后一行测试代码评估为真。什么时候应该是假的。 . .

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方式 :)

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。

Answer 4

简单的计数程序怎么样？

def valid_string?(str)
  match_count = 0

  str.each_char do |c|
    match_count += 1 if [ '[', '{', '(' ].include?(c)
    match_count -= 1 if [ ']', '}', ')' ].include?(c)
  end

  return match_count == 0
end

Answer 5

我发现递归在这种情况下工作得非常好。希望这会有所帮助！

def valid_string?(string)
  bracket_string = string.gsub(/[^\[\]\(\)\{\}]/,'').gsub('()','').gsub('[]','').gsub('{}','')
  return true if bracket_string.empty?
  return false if bracket_string.length.odd?
  return false if bracket_string.include?(string)
  valid_string?(bracket_string)
end