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绝对更好！虽然我的最后一行测试代码正在评估为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

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

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 3

仅仅因为它是有趣，我继续解决了这个 The 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 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

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

5 个答案: