C# 正则表达式以查找单词中的正则表达式组

我想知道如何生成一个正则表达式来检测单词中正则表达式的所有组合。例如：

“MAKE”

的匹配项应返回

“M”、“MA”、“MAK”、“MAKE”、“AKE”、“AK”、“A”、“KE”、“K”、“E”

所有这些可能值的正则表达式都是

[A-Za-z]+

问题是，如何从单个单词中检索所有可能的值：

Regex regex = new Regex( "[A-Za-z]+" );
foreach( Match m in regex.Matches( word ) )
{
    for( int i = 0; i < m.Groups.Count; i++ )
        Console.WriteLine( m.Groups[i].Value );
}

Regex Regex=newregex（“[A-Za-z]+”）；
foreach（正则表达式中的匹配m.Matches（word））
{
对于（int i=0；i

---

Is只检索我“MAKE”，但我想将所有匹配项分组到这个单词中。

您可以这样做

（（（（M）（（（A）K）E））A）（（（（K）E））K）（（（？=（E））E）

有一种编程方法可以使用给定的单词构造正则表达式。
这就是我手工制作这个正则表达式的方法。 我将把它作为一个练习留给您部署它

 **  Grp 0 -  ( pos 0 : len 4 ) 
MAKE  
 **  Grp 1 -  ( pos 0 : len 4 ) 
MAKE  
 **  Grp 2 -  ( pos 0 : len 3 ) 
MAK  
 **  Grp 3 -  ( pos 0 : len 2 ) 
MA  
 **  Grp 4 -  ( pos 0 : len 1 ) 
M  
 **  Grp 5 -  ( pos 1 : len 3 ) 
AKE  
 **  Grp 6 -  ( pos 1 : len 2 ) 
AK  
 **  Grp 7 -  ( pos 1 : len 1 ) 
A  
 **  Grp 8 -  ( pos 2 : len 2 ) 
KE  
 **  Grp 9 -  ( pos 2 : len 1 ) 
K  
 **  Grp 10 -  ( pos 3 : len 1 ) 
E  

格式和血淋淋的细节：

 (                             # (1 start)
      (                             # (2 start)
           (                             # (3 start)
                ( M )                         # (4)
                (?=
                     (                             # (5 start)
                          (                             # (6 start)
                               ( A )                         # (7)
                               K
                          )                             # (6 end)
                          E
                     )                             # (5 end)
                )
                A
           )                             # (3 end)
           (?=
                (                             # (8 start)
                     ( K )                         # (9)
                     E
                )                             # (8 end)
           )
           K
      )                             # (2 end)
      (?=
           ( E )                         # (10)
      )
      E
 )                             # (1 end)

---

如果只需要一个正则表达式来匹配“MAKE”的所有连续子字符串，则可以使用以下命令：

^(M(|A(|K(|E)))|A(|K(|E))|K(|E)|E)$

或者，如果您不关心字符串匹配的开始和结束，可以将其缩短为：

M(|A(|K(|E)))|A(|K(|E)|K(|E)|E

---

所以我试图用正则表达式制作一个字符串子字符串生成器。 我有这个想法，但我不太清楚，但我终于找到了一种方法。我没有对它进行过太多测试，但现在它可以工作了，为一个大小可变的未知单词创建了所有可能的子字符串（从左到右）

它适用于C#Regex引擎。没有进行基准测试，也没有计算复杂性（看起来像O（N^2）？）

我想用一种不同的方法来解决几个小时前在微软的一次采访中遇到的一个问题。重点是在一个由N个大小为N的单词（在下面的例子中，4个大小为4的单词）组成的矩阵中，按对角线、水平和垂直（从左到右、从上到下）查找所有可能的单词

静态无效校验字（字符串[]字，哈希集有效）
{
//水平的
foreach（大写的var w）
FindWord（w，有效）；
//垂直的
字串=”；
for（int i=0；i对于（int k=1；k您无法使正则表达式引擎在同一个位置多次匹配。这意味着您无法单独使用正则表达式解决此问题。请在没有正则表达式的情况下创建字符串的所有可能排列。@WiktorStribiżew所以我的猜测是手动创建该方法来查找单词中所有可能的子字符串。我只是在发冷试图使引擎爆炸（：抱歉，但regex并不打算创建这种排列。您可以使用嵌套的捕获组来捕获从同一点开始的值（如
（（M）A）K）E）
）但我怀疑这是否是您所需要的。事实上，我成功地创建了一种方法。这是可能的，但我没有对它进行过太多测试，也没有计算它的复杂性：）谢谢！尽管我希望对未知长度的字符串自动执行此操作。我实际上一直在做测试，最终得到了：）
    static void CheckWords( String[] words, HashSet<String> valid )
    {
        //Horizontal
        foreach( var w in words )
            FindWords( w, valid );

        //Vertical
        String word = "";
        for( int i = 0; i < words.Length; i++ )
        {
            for( int j = 0; j < words[i].Length; j++ )
                word += words[j][i];

            FindWords( word, valid );
            word = "";
        }

        //Diagonal
        String word2 = "";
        for( int i = 0, j = 0; i < words.Length; i++, j++ )
        {
            word += words[i][j];
            word2 += words[i][words[i].Length - i - 1];
        }

        FindWords( word, valid );
        FindWords( word2, valid );

    }

    static void FindWords( String word, HashSet<string> valid )
    {
        int len = word.Length;
        //Generate all possible (left to right) substring for String with Length - a [ FOr example, for "MAKE" we can have possible values for "MAKE", "MAK", "MA", "M", "AKE", "KE", "K, "E", "A
        for( int a = 0; a < len; a++ )
        {
            //Find all possible substring with this length { k = 1, k = 2, k = 3, ..., k = word.Length }
            for( int k = 1; k <= word.Length; k++ )
            {
                Match match = new Regex(@"([A-Za-z]{" + k + "}){1}").Match(word);
                //For all found groups, we just care for the first group wich contains the main unrepeated substrings
                for( int i = 0; i < match.Groups.Count - 1; i++ )
                    for( int j = 0; j < match.Groups[i].Captures.Count; j++ ) //Check each permutation for each word with K length. You can Console.Write each value to check it's generated string
                        if( valid.Contains( match.Groups[i].Captures[j].Value ) )
                            Console.WriteLine( match.Groups[i].Captures[j].Value );
            }
            word = word.Substring( 1, word.Length - 1 );
        }
    }

    HashSet<String> words = new HashSet<string>();
    words.Add( "MAKE" );
    words.Add( "MAD" );         
    words.Add( "END" ); 
    words.Add( "MINE" );                

    String[] array = { "MAKE", "IEMY", "NIAH", "ENDN" };

    CheckWords( array, words );