0

我们寻找偶数个匹配的大括号，但没有考虑数组中的位置。像这样：

def brace_count(brace_array)
    # ["{}[]()", "{}[]()"]

    brace_array.each do |braces|
        brace_chars_array = braces.split('')
        # ["{", "}", "[", "]", "(", ")"]
        paren_count = 0
        brace_count = 0
        bracket_count = 0
        brace_chars_array.each do |char|
            if char == "[" || char == "]"
                bracket_count += 1
            elsif char == "{" || char == "}"
                brace_count += 1
            elsif char == "(" || char == ")"
                paren_count += 1
            end
        # brace_count = 2, paren_count = 2, bracket_count = 2
        if brace_count % 2 == 0 && paren_count  % 2 == 0 && bracket_count % 2 == 0
            puts 1
        else 
            puts 0
        end
    end
end

有谁知道如何解决这个问题？我们无法弄清楚如何递归调用它。我认为正则表达式不是正确的方法。1如果大括号匹配，它应该返回，但0如果它们不匹配，并且如果在两个匹配的大括号之间有不同类型的大括号，则测试应该大量输出0。

例子：

{{[]}} = 1 
{([[)]]} = 0 (Even though the brackets are all even numbers [1 open 1 close, just not ordered properly])
4

4 回答 4

1

我认为您正在寻找的是一个 LIFO 堆栈，以在您遇到牙套时跟踪它们。您可以通过推送和弹出数组来获得它。

如果您只是想验证大括号是否平衡，最简单的方法是遍历字符串，将左大括号粘在堆栈上，当您到达右大括号时弹出堆栈并验证右大括号与开头匹配支撑你刚刚弹出。当它们不匹配时返回 0，如果到达字符串的末尾，如果堆栈为空则返回 1，否则返回 0。

于 2013-11-13T02:44:00.320 回答
0

我猜你的老师期待这样的事情：

def brace_match?(chars_array)
  while ['{', '[', '('].include?(chars_array.first)
    opener = chars_array.shift
    return false unless brace_match?(chars_array)  # This is the recursive call (s)he mentioned.
    closer = chars_array.shift
    case opener
    when '['
      return false if closer != ']'
    when '{'
      return false if closer != '}'
    when '('
      return false if closer != ')'
    end
  end
  return chars_array.empty? || ['}', ']', ')'].include?(chars_array.first)
end

def brace_count(brace_array)
    # ["{}[]()", "{}[]()"]

    brace_array.each do |braces|
        brace_chars_array = braces.split('')
        # ["{", "}", "[", "]", "(", ")"]
        if brace_match?(brace_chars_array)
            puts 1
        else
            puts 0
        end
    end
end

这做同样的事情，但有一些压缩的代码：

Braces = { '{' => '}', '[' => ']', '(' => ')' }

def brace_match?(chars_array)
  while Braces.keys.include?(chars_array.first)
    opener = chars_array.shift
    return false unless brace_match?(chars_array)  # This is the recursive call (s)he mentioned.
    return false unless chars_array.shift == Braces[opener]
  end
  return chars_array.empty? || Braces.values.include?(chars_array.first)
end
于 2013-11-13T05:22:04.997 回答
0

在您的示例中，您的字符串具有匹配的大括号、方括号和括号对。如果它们在您的字符串中总是成对出现（"[{}]"例如，不是），那么问题就会大大简化。

假设您正在处理字符串：

str = "{}[]()"

请注意

str.scan(/../) # => ["{}", "[]", "()"]

所以你可以做这样的事情：

str.strip.scan(/../).each do |s|
  case s
  when "{}"
    ..do something..
  when "[]"
    ..do something..
  when "()"
    ..do something..
  else
    .. raise an error..
  end
end

（在拆分对之前，我在和strip之间插入了可能位于字符串开头或结尾的任何空格。）strscanscan

使用对的优点是，如果您有一个不匹配的对，则会标记错误：

str = "{}[[()"

您不必检查确定数量是否与数量[相同]。

于 2013-11-13T03:20:27.143 回答
0

为此使用 String#count。

input_string.count(string_containing_chars_to_count)

它将大大缩短您的代码：

input = "{}[]()"
brackets, braces, parens = ['[]', '{}', '()'].map { |t| input.count t }     
#=> [2, 2, 2]

但是，作为提示：您希望在每次遇到“{”时增加一个计数器，并在每次遇到“}”时减少它，然后在字符串结束时检查计数器是否为 0。我相信你可以从那里弄清楚！

于 2013-11-13T02:23:51.917 回答