blocks|key|1350705|text|我认为使用regex解决这个问题可能比较复杂。这里有一个潜在的解决方案:您可以使用堆栈在遍历中记录左边的符号，如{、[、(。每次遇到正确的符号时，只需检查堆栈顶部的符号是否与此正确的符号匹配。如果不匹配，只需返回false。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1350706|下面是我的代码：|1350707|def+valid_string?(str)
++stack+=+[]
++symbols+=+{+'{'+=>+'}',+'['+=>+']',+'('+=>+')'+}
++str.each_char+do+%7Cc%7C
++++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|code-block|syntax|javascript|1350708|entityMap^0|5|5|1K|1|1M|1|1O|1|2Y|5|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

I think it might be complicated to use <code>regex</code> to solve this problem. Here is a potential solution: You may use a stack to record the left symbol like <code>{</code>, <code>[</code>, <code>(</code> in the traverse. Each time you met the right symbol, just check whether the symbol on the stack top matches this right symbol. Simply return <code>false</code> if not match.

Below is my code:

<pre><code>def valid_string?(str)
 stack = []
 symbols = { '{' =&gt; '}', '[' =&gt; ']', '(' =&gt; ')' }
 str.each_char do |c|
 stack &lt;&lt; c if symbols.key?(c)
 return false if symbols.key(c) &amp;&amp; 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
</code></pre>

blocks|key|2692703|text|这里有一种不使用regex的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2692704|def+valid_string?(str)
++strim+=+str.gsub(/[%5E\[\]\{\}]/,'')
++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|code-block|syntax|javascript|2692705|首先移除"()[]{}“中的所有字符。|unordered-list-item|2692706|如果其余字符串为空，则返回true。|2692707|如果其余字符串包含奇数字符，则返回false。|2692708|继续删除相邻的对“()”、“[]”和“[]”，直到字符串为空为止，在这种情况下返回true，或者不再删除相邻的对，字符串是非空的，在这种情况下返回false。|2692709|2692710|2692711|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|I|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|I|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|I|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|I|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|S|$]]

Here's a way that doesn't use regex:

<pre><code>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?("[ ]") # =&gt; true
p valid_string?("[ ") # =&gt; false
p valid_string?("[ ( text ) {} ]") # =&gt; true
p valid_string?("[ ( text { ) } ]") # =&gt; false
p valid_string?("[ ( text { more text { (more text) }} )]") # =&gt; true
</code></pre>

<ul>
<li>First remove all characters other than those in "()[]{}".</li>
<li>If the remaining string is empty, return true</li>
<li>If the remaining string contains an odd number of characters, return false.</li>
<li>Continue removing adjacent pairs '()', '[]' and '[]' until either the string is empty, in which case return true, or no more adjacent pairs can be removed and the string is non-empty, in which case return false.</li>
</ul>

blocks|key|2692713|text|一个简单的计数程序怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2692714|def+valid_string?(str)
++match_count+=+0

++str.each_char+do+%7Cc%7C
++++match_count+%2B=+1+if+[+'[',+'{',+'('+].include?(c)
++++match_count+-=+1+if+[+']',+'}',+')'+].include?(c)
++end

++return+match_count+==+0
end|code-block|syntax|javascript|2692715|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

How about a simple counting routine?

<pre><code>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
</code></pre>

blocks|key|2692743|text|仅仅因为它很有趣，我就着手解决了这个--+Ruby++:)|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2692744|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+%2B=+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+%7Cb%7C
++++++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+{+%7Cb%7C+total+%2B=+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+{+%7Cc%7C+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|code-block|syntax|javascript|2692745|entityMap^0|I|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Just because it was fun, I went ahead and solved this The Ruby Way :)

<pre><code>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 &lt;&lt; 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 &amp;&amp; @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
</code></pre>

blocks|key|2692758|text|在这种情况下，我发现递归很好地工作。希望这能有所帮助！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2692759|def+valid_string?(string)
++bracket_string+=+string.gsub(/[%5E\[\]\{\}]/,'').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|code-block|syntax|javascript|2692760|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I found recursion to work really well in this situation. Hope this helps!

<pre><code>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
</code></pre>

Write a method 'valid_string?' that accepts a string. It returns true if the brackets, parentheses, and curly braces close correctly. It returns false otherwise.

<pre><code>valid_string?("[ ]") # returns true
valid_string?("[ ") # returns false
valid_string?("[ ( text ) {} ]") # returns true
valid_string?("[ ( text { ) } ]") # returns false
</code></pre>

<hr>

My code: Is returning false for everything. Even tried using explicit booleans for individual cases {} || () ||, etc. Did not work. Either returns true or false for everything. Is it my driver code?

<pre><code>def valid_string?(str) 

 if str == ("\[\s+]")
 true
 else
 false
 end
end
</code></pre>

UPDATED SOLUTION:------------------------------------------------
Yes! #match definitely worked out better! Although my last line of test code is evaluating to true. When it should be false. . .

<pre><code>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
</code></pre>

How to check validity of closed brackets, parentheses or brackets in Ruby

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

编写一个方法'valid_string?‘接受一个字符串。如果括号、括号和大括号正确关闭，则返回true。否则它会返回false。valid_string?("[ ]")                  # returns truevalid_string?("[  ")                  # ret...

问如何检查Ruby中闭括号、括号或括号的有效性
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何检查Ruby中闭括号、括号或括号的有效性EN