blocks|key|3650290|text|您可以使用此命令(see+on+rubular.com)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3650291|%5E(?=[1-4]{4}$)(?!.*(.).*\1).*$|code-block|syntax|javascript|3650292|第一个断言确保它是%5E[1-4]{4}$，第二个断言是否定的先行检查，它确保您不能匹配.*(.).*\1，即重复字符。第一个断言是“更便宜的”，所以你想先做这件事。|style|CODE|3650293|参考文献|3650294|3650295|regular-expressions.info/Lookarounds和Backreferences|unordered-list-item|3650296|3650297|相关问题|3650298|3650299|How+does+the+regular+expression+(?<=#)[%5E#]%2B(?=#)+work?|3650300|3650301|entityMap|0|LINK|mutability|MUTABLE|url|http://www.rubular.com/r/POEc80vjWS|1|http://www.regular-expressions.info/lookaround.html|2|http://www.regular-expressions.info/brackets.html|3|https://stackoverflow.com/questions/3092797/how-does-the-regular-expression-work/^0|9|I|0|0|0|9|A|16|9|0|0|0|0|10|1|11|E|2|0|0|0|0|W|G|0|1I|3|0|0^^$0|@$1|2|3|4|5|6|7|1D|8|@]|9|@$A|1E|B|1F|1|1G]]|C|$]]|$1|D|3|E|5|F|7|1H|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1I|8|@$A|1J|B|1K|K|L]|$A|1L|B|1M|K|L]]|9|@]|C|$]]|$1|M|3|N|5|6|7|1N|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]|$1|P|3|Q|5|R|7|1P|8|@]|9|@$A|1Q|B|1R|1|1S]|$A|1T|B|1U|1|1V]]|C|$]]|$1|S|3|-4|5|6|7|1W|8|@]|9|@]|C|$]]|$1|T|3|U|5|6|7|1X|8|@]|9|@]|C|$]]|$1|V|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|W|3|X|5|R|7|1Z|8|@$A|20|B|21|K|L]]|9|@$A|22|B|23|1|24]]|C|$]]|$1|Y|3|-4|5|6|7|25|8|@]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|26|8|@]|9|@]|C|$]]]|10|$11|$5|12|13|14|C|$15|16]]|17|$5|12|13|14|C|$15|18]]|19|$5|12|13|14|C|$15|1A]]|1B|$5|12|13|14|C|$15|1C]]]]

You can use this (<a href="http://www.rubular.com/r/POEc80vjWS" rel="noreferrer">see on rubular.com</a>):

<pre><code>^(?=[1-4]{4}$)(?!.*(.).*\1).*$
</code></pre>

The first assertion ensures that it's <code>^[1-4]{4}$</code>, the second assertion is a negative lookahead that ensures that you can't match <code>.*(.).*\1</code>, i.e. a repeated character. The first assertion is "cheaper", so you want to do that first.

<h3>References</h3>

<ul>
<li><a href="http://www.regular-expressions.info/lookaround.html" rel="noreferrer">regular-expressions.info/Lookarounds</a> and <a href="http://www.regular-expressions.info/brackets.html" rel="noreferrer">Backreferences</a></li>
</ul>

<h3>Related questions</h3>

<ul>
<li><a href="https://stackoverflow.com/questions/3092797/how-does-the-regular-expression-work/">How does the regular expression <code>(?&lt;=#)[^#]+(?=#)</code> work?</a></li>
</ul>

blocks|key|2242612|text|只是为了开怀大笑，这里有另一个选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2242613|%5E(?:1()%7C2()%7C3()%7C4()){4}\1\2\3\4$|code-block|syntax|javascript|2242614|当每个唯一的字符被使用时，它后面的捕获组捕获一个空字符串。反向引用还尝试匹配空字符串，因此如果其中一个不成功，只能意味着关联的组没有参与匹配。只有当字符串包含至少一个重复项时，才会发生这种情况。|2242615|这种空捕获组和反向引用的行为在任何regex版本中都不受官方支持，因此请注意抢购者。但它在大多数情况下都能正常工作，包括Ruby。|2242616|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Just for a giggle, here's another option:

<pre><code>^(?:1()|2()|3()|4()){4}\1\2\3\4$
</code></pre>

As each unique character is consumed, the capturing group following it captures an empty string. The backreferences also try to match empty strings, so if one of them doesn't succeed, it can only mean the associated group didn't participate in the match. And that will only happen if string contains at least one duplicate.

This behavior of empty capturing groups and backreferences is not officially supported in any regex flavor, so caveat emptor. But it works in most of them, including Ruby.

blocks|key|1382869|text|我认为这个解决方案要简单一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1382870|%5E(?:([1-4])(?!.*\1)){4}$|code-block|syntax|javascript|1382871|查看here+on+Rubular|offset|length|1382872|%5E++++++++++++++++++#+matches+the+start+of+the+string
++++(?:++++++++++++#+open+a+non+capturing+group+
++++++++([1-4])++++#+The+characters+that+are+allowed+the+found+char+is+captured+in+group+1
++++++++(?!.*\1)+++#+That+character+is+matched+only+if+it+does+not+occur+once+more
++++){4}+++++++++++#+Defines+the+amount+of+characters
$|1382873|(?!.*\1)是一个lookahead+assertion，以确保字符不会重复。|style|CODE|1382874|%5E和$是匹配字符串开头和结尾的锚点。|1382875|entityMap|0|LINK|mutability|MUTABLE|url|http://www.rubular.com/r/0Tqwh474Cd|1|http://www.regular-expressions.info/lookaround.html^0|0|0|2|F|0|0|0|0|8|B|J|1|0|0|1|2|1|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@$I|15|J|16|1|17]]|A|$]]|$1|K|3|L|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|19|8|@$I|1A|J|1B|O|P]]|9|@$I|1C|J|1D|1|1E]]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@$I|1G|J|1H|O|P]|$I|1I|J|1J|O|P]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]]]

I think this solution is a bit simpler

<pre><code>^(?:([1-4])(?!.*\1)){4}$
</code></pre>

See it <a href="http://www.rubular.com/r/0Tqwh474Cd" rel="noreferrer">here on Rubular</a>

<pre><code>^ # matches the start of the string
 (?: # open a non capturing group 
 ([1-4]) # The characters that are allowed the found char is captured in group 1
 (?!.*\1) # That character is matched only if it does not occur once more
 ){4} # Defines the amount of characters
$
</code></pre>

<code>(?!.*\1)</code> is a <a href="http://www.regular-expressions.info/lookaround.html" rel="noreferrer">lookahead assertion</a>, to ensure the character is not repeated.

<code>^</code> and <code>$</code> are anchors to match the start and the end of the string.

blocks|key|1386877|text|虽然前面的答案解决了问题，但它们并不像它们可能的那样通用，并且不允许在初始字符串中出现重复。例如，{a,a,b,b,c,c}。在Perl+Monks上询问similar+question之后，Eily提供了the+following+solution|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1386878|%5E(?:(?!\1)a()%7C(?!\2)a()%7C(?!\3)b()%7C(?!\4)b()%7C(?!\5)c()%7C(?!\6)c()){6}$|code-block|syntax|javascript|1386879|同样，这也适用于字符串中较长的“符号”，也适用于可变长度的符号。|1386880|entityMap|0|LINK|mutability|MUTABLE|url|https://www.perlmonks.org/|1|https://www.perlmonks.org/?node_id=1226058|2|https://www.perlmonks.org/?node_id=1039428|3|https://www.perlmonks.org/?node_id=1226072^0|1D|D|1S|A|0|25|G|1|2O|4|2|2V|M|3|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]|$9|19|A|1A|1|1B]|$9|1C|A|1D|1|1E]]|E|$]]|$1|F|3|G|5|H|7|1F|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1G|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]|W|$5|P|Q|R|E|$S|X]]|Y|$5|P|Q|R|E|$S|Z]]]]

While the previous answers solve the problem, they aren't as generic as they could be, and don't allow for repetitions in the initial string. For example, <code>{a,a,b,b,c,c}</code>. After asking a <a href="https://www.perlmonks.org/?node_id=1226058" rel="nofollow noreferrer">similar question</a> on <a href="https://www.perlmonks.org/" rel="nofollow noreferrer">Perl Monks</a>, <a href="https://www.perlmonks.org/?node_id=1226072" rel="nofollow noreferrer">the following solution</a> was given by <a href="https://www.perlmonks.org/?node_id=1039428" rel="nofollow noreferrer">Eily</a>:

<pre><code>^(?:(?!\1)a()|(?!\2)a()|(?!\3)b()|(?!\4)b()|(?!\5)c()|(?!\6)c()){6}$
</code></pre>

Similarly, this works for longer "symbols" in a string, and for variable length symbols too.

I am implementing the following problem in ruby.

Here's the pattern that I want :

1234, 1324, 1432, 1423, 2341 and so on

i.e. the digits in the four digit number should be between [1-4] and should also be non-repetitive.

to make you understand in a simple manner I take a two digit pattern
and the solution should be :
12, 21

i.e. the digits should be either 1 or 2 and should be non-repetitive.

To make sure that they are non-repetitive I want to use $1 for the condition for my second digit but its not working. 

Please help me out and thanks in advance.

Regex to match all permutations of {1,2,3,4} without repetition

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在用ruby实现以下问题。下面是我想要的模式：1234、1324、1432、1423、2341等等也就是说，四位数中的数字应该在1-4之间，并且也应该是非重复的。为了让你以一种简单的方式理解，我采用了一个两位数的模式，解决方案应该是: 12，21即，数字应该是1或2，并且应该是非重复的。为了确保它们是非重复的，我想...

问匹配{1,2,3,4}的所有排列而不重复的正则表达式
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问匹配{1,2,3,4}的所有排列而不重复的正则表达式EN