blocks|key|3670860|text|您可以将此正则表达式用于此操作，并使用负先行：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3670861|%5E(?!(?:[01]*0)?(?:1{2})%2B(?:0%7C$))[01]%2B$|code-block|syntax|javascript|3670862|RegEx+Demo|offset|length|3670863|RegEx详细信息：|style|BOLD|3670864|当表达式中任意位置的1数为偶数时，|CODE|3670865|(?!(?:[01]*0)?(?:1{2})%2B(?:0%7C$))：表达式将导致匹配失败。|unordered-list-item|3670866|(?:0%7C$)确保一对开头后面不跟1|3670867|(?:[01]*0)?：仅允许在1s|3670868|[01]%2B：之前出现0或1匹配长度为0或1的字符串和一个或多个长度的1|3670869|3670870|entityMap|0|LINK|mutability|MUTABLE|url|https://regex101.com/r/c8GCfj/2^0|0|0|0|A|0|0|0|A|0|A|1|0|0|V|0|0|7|H|1|0|0|B|G|1|0|0|5|A|1|C|1|Y|1|0|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1B|8|@]|9|@$I|1C|J|1D|1|1E]]|A|$]]|$1|K|3|L|5|6|7|1F|8|@$I|1G|J|1H|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1I|8|@$I|1J|J|1K|M|Q]]|9|@]|A|$]]|$1|R|3|S|5|T|7|1L|8|@$I|1M|J|1N|M|Q]]|9|@]|A|$]]|$1|U|3|V|5|T|7|1O|8|@$I|1P|J|1Q|M|Q]|$I|1R|J|1S|M|Q]]|9|@]|A|$]]|$1|W|3|X|5|T|7|1T|8|@$I|1U|J|1V|M|Q]|$I|1W|J|1X|M|Q]]|9|@]|A|$]]|$1|Y|3|Z|5|T|7|1Y|8|@$I|1Z|J|20|M|Q]|$I|21|J|22|M|Q]|$I|23|J|24|M|Q]|$I|25|J|26|M|Q]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|27|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|28|8|@]|9|@]|A|$]]]|12|$13|$5|14|15|16|A|$17|18]]]]

You may use this regex for this with a negative lookahead:

<pre><code>^(?!(?:[01]*0)?(?:1{2})+(?:0|$))[01]+$
</code></pre>

<a href="https://regex101.com/r/c8GCfj/2" rel="nofollow noreferrer">RegEx Demo</a>

RegEx Details:

<ul>
<li><code>(?!(?:[01]*0)?(?:1{2})+(?:0|$))</code>: Expression to fail the match when you have even number of <code>1</code>s in the expression anywhere. <code>(?:1{2})+</code> matches a pair of <code>1</code>s </li>
<li><code>(?:0|$)</code> ensures pair of <code>1</code>s is not followed by <code>1</code></li>
<li><code>(?:[01]*0)?</code>: only allows presence of <code>0</code> or start just before <code>1</code>s</li>
<li><code>[01]+</code>: Match a string with 0 or 1 with one or more length</li>
</ul>

blocks|key|3670887|text|我认为另一种选择是只匹配0或匹配可选的前导零，然后重复匹配奇数1，后跟1%2B+0或字符串末尾。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3670888|%5E(?:(?:0*1(?:11)*(?:0%2B%7C$))%2B%7C0%2B)$|code-block|syntax|javascript|3670889|3670890|%5E开始string|unordered-list-item|offset|length|style|CODE|3670891|(?:非捕获组|3670892|3670893|0*1(?:11)*+11|3670894|(?:0%2B%7C$)匹配0%2B零，1并重复0%2B次数string|3670895|3670896|3670897|匹配0%2B零或断言end+of+1|3670898|​|3670899|-+`)%2B`+Close+non+capturing+group+and+repeat+1%2B+times+to+not+match+empty+strings
-+`%7C`+Or
-+`0%2B`+Match+only+zeroes|3670900|3670901|3670902|)+Close+non+capturing+group|3670903|$+End+of+string|3670904|+(字符串关闭时不捕获字符串末尾)|3670905|Regex+demo|3670906|entityMap|0|LINK|mutability|MUTABLE|url|https://regex101.com/r/aPdGHS/1^0|0|0|0|0|1|0|0|3|1|0|3|2|0|A|B|2|2|0|8|E|1|2|1|0|F|1|0|0|0|0|0|0|1|0|0|1|0|0|0|A|0|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1O|8|@$K|1P|L|1Q|M|N]]|9|@]|A|$]]|$1|O|3|P|5|J|7|1R|8|@$K|1S|L|1T|M|N]]|9|@]|A|$]]|$1|Q|3|P|5|J|7|1U|8|@$K|1V|L|1W|M|N]]|9|@]|A|$]]|$1|R|3|S|5|J|7|1X|8|@$K|1Y|L|1Z|M|N]|$K|20|L|21|M|N]]|9|@]|A|$]]|$1|T|3|U|5|J|7|22|8|@$K|23|L|24|M|N]|$K|25|L|26|M|N]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|27|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|28|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|29|8|@$K|2A|L|2B|M|N]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2C|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|2D|8|@]|9|@]|A|$E|F]]|$1|13|3|10|5|6|7|2E|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|15|3|16|5|J|7|2G|8|@$K|2H|L|2I|M|N]]|9|@]|A|$]]|$1|17|3|18|5|J|7|2J|8|@$K|2K|L|2L|M|N]]|9|@]|A|$]]|$1|19|3|1A|5|6|7|2M|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|2N|8|@]|9|@$K|2O|L|2P|1|2Q]]|A|$]]|$1|1D|3|-4|5|6|7|2R|8|@]|9|@]|A|$]]]|1E|$1F|$5|1G|1H|1I|A|$1J|1K]]]]

I think another option could be to match either only zeroes or match optional leading zeroes and repeat matching odd 1's followed by either 1+ zeroes or the end of the string.

<pre><code>^(?:(?:0*1(?:11)*(?:0+|$))+|0+)$
</code></pre>

<ul>
<li><code>^</code> Start of string</li>
<li><code>(?:</code> Non capturing group

<ul>
<li><code>(?:</code> Non capturing group

<ul>
<li><code>0*1(?:11)*</code> Match 0+ zeroes, <code>1</code> and repeat 0+ times <code>11</code></li>
<li><code>(?:0+|$)</code> Match 1+ zeroes or assert end of string</li>
</ul></li>
<li><code>)+</code> Close non capturing group and repeat 1+ times to not match empty strings</li>
<li><code>|</code> Or</li>
<li><code>0+</code> Match only zeroes</li>
</ul></li>
<li><code>)</code> Close non capturing group</li>
<li><code>$</code> End of string</li>
</ul>

<a href="https://regex101.com/r/aPdGHS/1" rel="nofollow noreferrer">Regex demo</a>

blocks|key|1273013|text|这应该不需要lookaround解决方案的复杂性。您尝试的解决方案的基本问题是0*可以在下一组0之前匹配零个1。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1273014|0*(1(11)*0%2B)*(1(11)*)?|code-block|syntax|javascript|1273015|这将处理前导0。如果您不关心这一点，可以删除0*。|1273016|“肉”是0%2B的内在表达。由一个或多个1分隔的奇数组0。|1273017|因为这些组以0结尾，所以我们需要在末尾有一个可选的奇数组1，以防字符串以1结尾。|1273018|请注意，由于以上所有数量都是可选的，因此上面的解决方案也将匹配空字符串。如果您至少需要一个1，则会稍微复杂一些：|1273019|0*1(11)*(0%2B1(11)*)*0*|1273020|entityMap^0|13|2|1B|1|1I|1|0|0|6|1|M|2|0|4|2|I|1|P|1|0|6|1|S|1|10|1|0|19|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|1Q|8|@]|D|@]|E|$I|J]]|$1|U|3|-4|5|6|7|1R|8|@]|D|@]|E|$]]]|V|$]]

This should not need the complications of the lookaround solutions. The basic problem with your attempted solution is the <code>0*</code> which can match zero <code>0</code>s before the next group of <code>1</code>s.

<pre><code>0*(1(11)*0+)*(1(11)*)?
</code></pre>

This handles leading <code>0</code>s. If you're not concerned about that you can remove the <code>0*</code>.

The "meat" is the inner expression with the <code>0+</code>. Odd groups of <code>1</code>s delimited by one or more <code>0</code>s.

Since those groups end with <code>0</code>, we need an optional odd group of <code>1</code>s at the end in case the string ends in <code>1</code>.

Note that as all quantities above are optional, the above solution will also match an empty string. If you require at least one <code>1</code>, it's a little more complicated:

<pre><code>0*1(11)*(0+1(11)*)*0*
</code></pre>

blocks|key|3671016|text|如果您的正则表达式支持possessive+quantifiers来防止回溯。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3671017|%5E0*(?:(?:11)*%2B10*)*$|code-block|syntax|javascript|3671018|See+this+demo+at+regex101|3671019|请注意，这也将匹配一个空字符串。如果字符串应始终以1开头并包含一个或多个字符，请尝试使用%5E(?:(?:11)*%2B10*)%2B$|style|CODE|3671020|entityMap|0|LINK|mutability|MUTABLE|url|https://www.regular-expressions.info/possessive.html|1|https://regex101.com/r/amyAjG/1|2|https://regex101.com/r/amyAjG/2^0|B|M|0|0|0|0|P|1|0|P|1|18|I|18|I|2|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@$A|16|B|17|1|18]]|C|$]]|$1|K|3|L|5|6|7|19|8|@$A|1A|B|1B|M|N]|$A|1C|B|1D|M|N]]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|O|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]|Y|$5|R|S|T|C|$U|Z]]]]

If your regex flavor supports <a href="https://www.regular-expressions.info/possessive.html" rel="nofollow noreferrer">possessive quantifiers</a> for preventing backtracking.

<pre><code>^0*(?:(?:11)*+10*)*$
</code></pre>

<a href="https://regex101.com/r/amyAjG/1" rel="nofollow noreferrer">See this demo at regex101</a>

Be aware, that this one will also match an empty string. 
If the string should always start with <code>1</code> and contain one or more characters, try <a href="https://regex101.com/r/amyAjG/2" rel="nofollow noreferrer"><code>^(?:(?:11)*+10*)+$</code></a>

I would like to write a regex that can match binary string where consecutive 1s must have odd length.

Examples: 1001110111 is accepted, and 10110111 is not accepted.

<pre><code>(1(11)*|0*)*
</code></pre>

The best I came up with is the one above, which is not correct. This regex will match consecutive even 1s too. Any other ideas?

TIA

Regex for matches 0 and 1 where consecutive 1s must be odd?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我想写一个正则表达式，可以匹配二进制字符串，其中连续的1必须有奇数长度。例如: 1001110111被接受，10110111不被接受。(1(11)*|0*)*我想出的最好的是上面的那个，这是不正确的。这个正则表达式也将匹配连续的偶数1。还有其他想法吗？提亚

问匹配0和1的正则表达式，其中连续的1必须是奇数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问匹配0和1的正则表达式，其中连续的1必须是奇数？EN