Question

我目前正在进行Ruby问题测验，但我不确定我的解决方案是否正确。运行检查后，它显示编译成功，但我只是担心这不是正确的答案。

问题：

在以下情况下，正确嵌套了一个仅包含字符'（'和'）'的字符串S.


S为空，

S的形式为“（U）”   U是一个正确嵌套的字符串，

S有   形式为“VW”，其中V和W为   正确嵌套的字符串。


例如，“（（）（（））（））”被正确嵌套而“（）”“不是。

写一个函数
def nesting(s)
给定字符串S如果S则返回1   是否正确嵌套，否则为0。   假设S的长度没有   超过1,000,000。假设S   只包含字符'（'和'   '）'

例如，给定S =“（（）（（））（））”   该函数应返回1并给出   S =“（））”函数应该返回   0，如上所述。

解决方案：

def nesting ( s )
    # write your code here

    if s == '(()(())())' && s.length <= 1000000
        return 1
    elsif s == ' ' && s.length <= 1000000
        return 1
    elsif 
        s == '())'
        return 0
    end
end

Answer 1

以下是应该实现目标的两种算法的描述。我将把它作为练习留给读者将它们变成代码（除非你明确要求代码解决方案）：

从设置为0的变量开始并遍历字符串中的每个字符：当您看到'（'，向变量添加一个;当您看到'）'时，减去一个来自变量。如果变量变为负数，则您看到太多'）'并且可以立即返回0。如果你完成了字符循环并且变量不完全是0，那么你有太多'（'并且应该返回0。
删除字符串中每次出现的'（）'（替换为''）。继续这样做，直到你发现没有任何东西被替换（检查gsub!的返回值）。如果字符串为空，则括号匹配。如果字符串不为空，则表示不匹配。

Answer 2

你不应该只列举给定的例子。你应该通常解决这个问题。你也不应该检查长度是否低于1000000，你可以假设它。

这个问题最直接的解决方案是遍历字符串并跟踪现在打开多少个括号。如果在当前没有括号的情况下看到右括号，则字符串不均衡。如果到达结尾时任何括号仍然打开，则字符串不均衡。否则就是。

或者你也可以使用ruby 1.9的递归正则表达式功能将规范直接转换为正则表达式模式。

Answer 3

理论上你可以解决这个问题。通过使用这样的语法：

S ← LSR | LR
L ← (
R ← )

语法应该可以通过递归算法轻松解决。那将是最优雅的解决方案。否则，如此处已经提到的那样计算开括号。

Answer 4

我的算法会使用堆栈来实现此目的。堆栈旨在解决此类问题

算法

定义一个包含平衡括号列表的哈希 instance {“（”=“＆gt;”）“，”{“=＆gt; “}”等等......}
声明一个堆栈（在我们的例子中是数组），即括号= []
使用each_char循环遍历字符串，并将每个字符与哈希的键进行比较，并将其推送到括号中
在同一循环中将其与散列值进行比较，并从括号
最后，如果括号堆栈为空，则括号是平衡的。

def brackets_balanced?(string) return false if string.length < 2 brackets_hash = {"(" => ")", "{" => "}", "[" => "]"} brackets = [] string.each_char do |x| brackets.push(x) if brackets_hash.keys.include?(x) brackets.pop if brackets_hash.values.include?(x) end return brackets.empty? end

Answer 5

你担心是对的;我认为你已经得到了非常错误的结局，并且你在字面上解决了这个问题（字符串不超过1,000,000个字符的信息只是为了阻止人们担心他们的代码运行速度有多慢长度是100倍，并且示例只是 - 示例 - 而不是您可以预期接收的最终字符串列表）

我不打算为你做功课（通过编写代码），但是会给你一个指向我的解决方案的指针：

如果每个左括号在其右侧有一个右括号，或者它们之间有正确嵌套的括号组，则该字符串是正确嵌套的。那么删除字符串的递归函数或循环如何匹配“（）”。当你用完比赛时，你剩下什么？没有？那是一个正确嵌套的字符串。其他东西（如'）'或'）（'等）意味着它首先没有正确嵌套。

Answer 6

这是使用inject执行此操作的一种巧妙方法：

class String
  def valid_parentheses?
    valid = true
    self.gsub(/[^\(\)]/, '').split('').inject(0) do |counter, parenthesis|
      counter += (parenthesis == '(' ? 1 : -1)
      valid = false if counter < 0
      counter
    end.zero? && valid
  end
end

> "(a+b)".valid_parentheses?    # => true
> "(a+b)(".valid_parentheses?   # => false
> "(a+b))".valid_parentheses?   # => false
> "(a+b))(".valid_parentheses?  # => false

Answer 7

定义方法：

def check_nesting str
  pattern = /\(\)/
  while str =~ pattern do
    str = str.gsub pattern, ''
  end

  str.length == 0
end

测试一下：

>ruby nest.rb (()(())())
true

>ruby nest.rb (()
false

>ruby nest.rb ((((()))))
true

>ruby nest.rb (()
false

>ruby nest.rb (()(((())))())
true

>ruby nest.rb (()(((())))()
false

Answer 8

您的解决方案只返回字符串“（（）（（））（））”和“（））”的正确答案。你肯定需要一个适用于任何字符串的解决方案！

首先，如何计算(和)的出现次数，看看它们是否相等？

检查字符串是否具有平衡括号

8 个答案:

算法