Question

例如 reassesses 将匹配。它包含完全 4 个不同的字符：'r'，'e'，'a'和's'。

我的尝试是：/^([a-z])([a-z])([a-z])([a-z])(\1|\2|\3|\4)(\1|\2|\3|\4)(\1|\2|\3|\4)$/ （根据需要添加尽可能多的(\1|\2|\3|\4)以匹配单词的长度）

然而，这将只匹配最多4个不同的字母，并且只有它们是前4个字符。

有没有更好的解决方案？

Answer 1

这样的事情：

^([a-z])\1*+([a-z])(?:\1|\2)*+([a-z])(?:\1|\2|\3)*+([a-z])(?:\1|\2|\3|\4)*$

在此模式中使用possessive quantifiers是必不可少的，因为它禁止回溯并避免后续捕获组与找到的字母匹配。

占有量词功能在Java中可用（不要忘记双重转义反向引用），但是如果你需要在没有此功能的语言中使用该模式，你可以找到几个选项来“翻译”我评论中的模式。

构建上述模式是为了检查整个字符串，但是如果要在较大的字符串中查找单词，可以使用它（最终使用不区分大小写的选项）：

(?<![a-z])([a-z])\1*+([a-z])(?:\1|\2)*+([a-z])(?:\1|\2|\3)*+([a-z])(?:\1|\2|\3|\4)*(?![a-z])

Answer 2

尝试

^([a-z])\1*([a-z])(\1*\2*)*([a-z])(\1*\2*\4*)*([a-z])(\1*\2*\4*\6*)*$

修改为不匹配少于4个唯一（例如aaaa）：

^([a-z])\1*(?!\1)([a-z])(\1*\2*)*(?!\1)(?!\2)([a-z])(\1*\2*\4*)*(?!\1)(?!\2)(?!\4)([a-z])(\1*\2*\4*\6*)*$

Answer 3

绝对有效 -
这应该导致仅仅组成4个不同字符的对齐字符串＆gt; = 4的长度。

 #  ^(?=.*(.).*(?!\1)(.).*(?!\1|\2)(.).*(?!\1|\2|\3)(.))(?:\1|\2|\3|\4)+$

 ^ 
 (?=
      .* 
      ( . )
      .* 
      (?! \1 )
      ( . )
      .* 
      (?! \1 | \2 )
      ( . )
      .* 
      (?! \1 | \2 | \3 )
      ( . )
 )
 (?: \1 | \2 | \3 | \4 )+
 $

Perl测试用例：

if ("upepipipeu" =~ /^(?=.*(.).*(?!\1)(.).*(?!\1|\2)(.).*(?!\1|\2|\3)(.))(?:\1|\2|\3|\4)+$/)
{
      print "unique chars: '$1'  '$2'  '$3'  '$4'\n";
      print "matched:      '$&'\n";
}

输出＆gt;＆gt;

unique chars: 'i'  'p'  'e'  'u'
matched:      'upepipipeu'

@aliteralmind的测试用例：

@Ary = ("aabbccdd", "dictionary", "reassess", "aaaa");

for( @Ary )
{
    if ("$_" =~ /^(?=.*(.).*(?!\1)(.).*(?!\1|\2)(.).*(?!\1|\2|\3)(.))(?:\1|\2|\3|\4)+$/)
    {
       print "unique chars: '$1'  '$2'  '$3'  '$4'\n";
       print "matched:      '$&'\n\n";
    }
    else
    {
       print "Failed-> '$_'\n\n";
    }
}

输出＆gt;＆gt;

unique chars: 'a'  'b'  'c'  'd'
matched:      'aabbccdd'

Failed-> 'dictionary'

unique chars: 'r'  'a'  'e'  's'
matched:      'reassess'

Failed-> 'aaaa'

Answer 4

就正则表达而言，这是一个大脑破坏者。这是一个非正则表达式解决方案。一个函数，它使用映射来跟踪唯一字符，并在达到最大唯一字符数时返回true。

import  java.util.Map;
import  java.util.TreeMap;

/**
   <P>{@code java ExactlyFourDiffChars}</P>
 **/
public class ExactlyFourDiffChars  {
   public static final void main(String[] ignored)  {
      System.out.println("aabbccdd: " + hasMoreThanXUniqueChars(4, "aabbccdd"));
      System.out.println("dictionary: " + hasMoreThanXUniqueChars(4, "dictionary"));
      System.out.println("reassesses: " + hasMoreThanXUniqueChars(4, "reassesses"));
   }
   public static final boolean hasMoreThanXUniqueChars(int maxAllowedChars, String str)  {
      Map<Character,Object> charMap = new TreeMap<Character,Object>();

      for(int i = 0; i < str.length(); i++)  {
         Character C = str.charAt(i);
         if(!charMap.containsKey(C))  {
            charMap.put(C, null);

            if(maxAllowedChars-- == 0)  {
               return  false;
            }
         }
      }
      return  true;
   }
}

输出：

[C:\java_code\]java ExactlyFourDiffChars
aabbccdd: true
dictionary: false
reassesses : true

单词由正则表达式组成4个不同的字母？

4 个答案: