如何编写一个以任何顺序匹配字符的正则表达式？

Question

我正在尝试编写一个匹配一组字符而不考虑顺序的正则表达式。例如：

str = "act" 
str.scan(/Insert expression here/)

会匹配：

cat
act
tca
atc
tac
cta

但不匹配 ca、ac 或 cata。

我在 StackOverflow 上阅读了很多类似的问题和答案，但没有找到与我的目标完全匹配的问题和答案。

澄清一下，我使用的是 ruby​​，不想允许重复字符。

Answer 1

这是你的解决方案

^(?:([act])(?!.*\1)){3}$

看here on Regexr

^                  # matches the start of the string
    (?:            # open a non capturing group 
        ([act])    # The characters that are allowed and a capturing group
        (?!.*\1)   # That character is matched only if it does not occur once more, Lookahead assertion
    ){3}           # Defines the amount of characters
$

唯一特别想的是lookahead assertion，保证字符不重复。

^ 和 $ 是匹配字符串开头和结尾的锚点。

Answer 2

[act]{3} 或 ^[act]{3}$ 在大多数正则表达式方言中都会这样做。如果您可以缩小您正在使用的系统，这将有助于您获得更具体的答案。

编辑：正如@georgydyer 在下面的 cmets 中提到的，您的问题不清楚是否允许重复字符。如果没有，您可以调整this question 的答案并获得：

^(?=[act]{3}$)(?!.*(.).*\1).*$

也就是说，先用正向先行检查匹配，然后用反向引用进行否定先行以排除重复字符。

Answer 3

下面是我的做法：

regex = /\b(?:#{ Regexp.union(str.split('').permutation.map{ |a| a.join }).source })\b/
# => /(?:act|atc|cat|cta|tac|tca)/

%w[
  cat act tca atc tac cta
  ca ac cata
].each do |w|
  puts '"%s" %s' % [w, w[regex] ? 'matches' : "doesn't match"]
end

输出：

"cat" matches
"act" matches
"tca" matches
"atc" matches
"tac" matches
"cta" matches
"ca" doesn't match
"ac" doesn't match
"cata" doesn't match

我在很多事情上都使用了将数组传递给Regexp.union 的技术；我使用散列的键特别好，并将散列传递给gsub，以便在文本模板上快速搜索/替换。这是来自gsub 文档的示例：

'hello'.gsub(/[eo]/, 'e' => 3, 'o' => '*') #=> "h3ll*"

Regexp.union 创建一个正则表达式，在提取生成的实际模式时使用source 而不是to_s 很重要：

puts regex.to_s
=> (?-mix:\b(?:act|atc|cat|cta|tac|tca)\b)

puts regex.source
=> \b(?:act|atc|cat|cta|tac|tca)\b

注意to_s 如何将模式的标志嵌入到字符串中。如果您不期望它们，您可能会不小心将该模式嵌入到另一个中，这不会像您预期的那样运行。去过那里，做到了，并有凹陷的头盔作为证据。

如果您真的想玩得开心，请查看 CPAN 上可用的 Perl Regexp::Assemble 模块。使用它，加上List::Permutor，让我们生成更复杂的模式。在像这样的简单字符串上，它不会节省太多空间，但在长字符串或所需命中的大型数组上，它可以产生巨大的差异。不幸的是，Ruby 没有这样的东西，但是可以用单词或单词数组编写一个简单的 Perl 脚本，并让它生成正则表达式并将其传回：

use List::Permutor;
use Regexp::Assemble;

my $regex_assembler = Regexp::Assemble->new;
my $perm = new List::Permutor split('', 'act');
while (my @set = $perm->next) {
    $regex_assembler->add(join('', @set));
}
print $regex_assembler->re, "\n";
(?-xism:(?:a(?:ct|tc)|c(?:at|ta)|t(?:ac|ca)))

有关在 Ruby 中使用 Regexp::Assemble 的更多信息，请参阅“Is there an efficient way to perform hundreds of text substitutions in Ruby?”。

Answer 4

我将在这里假设几件事： - 您正在寻找给定字符的排列 - 你正在使用红宝石

str = "act"
permutations = str.split(//).permutation.map{|p| p.join("")}

# and for the actual test
permutations.include?("cat")

虽然它不是正则表达式。

Answer 5

毫无疑问 - 使用正/负前瞻和反向引用的正则表达式很巧妙，但如果你只处理三个字符，我会通过显式枚举@scones 建议的字符排列来避免冗长。

"act".split('').permutation.map(&:join)
=> ["act", "atc", "cat", "cta", "tac", "tca"]

如果你真的需要一个正则表达式来扫描更大的字符串，你总是可以：

Regexp.union "act".split('').permutation.map(&:join)
=> /\b(act|atc|cat|cta|tac|tca)\b/

显然，如果您的搜索字符串增长，此策略不会扩展，但在我看来，这样更容易观察代码的意图。

编辑：根据@theTinMan 的反馈，为cata 的误报添加了单词边界。