C# 正则表达式拼图查找所有有效的字符串组合

我试图找到字符串中满足所有给定条件的可能子集

• 第一个字母是小写的英文字母
• 接下来，它包含以下零个或多个字符的序列：
  小写英文字母、数字和冒号
• 接下来，它包含一个正斜杠“/”
• 接下来，它包含以下一个或多个字符的序列：
  小写英文字母和数字
• 接下来，它包含一个反斜杠“\”
• 接下来，它包含一个或多个小写英文字母的序列

给定一些字符串s，我们定义如下：

s[i..j]是由索引i和索引j之间包含范围内的所有字符组成的子字符串

两个子串s[i..j]和s[i[2]..j[2]]如果i≠ i[2]或j≠ j[2]

例如，您的命令行是

abc:/b1c\xy。

有效的命令子字符串是：

abc:/b1c\xy
bc:/b1c\xy
c:/b1c\xy
abc:/b1c\x
bc:/b1c\x
c:/b1c\x

我将其解为

^（[a-z]）（[a-z0-9:]*）（/）（[a-z0-9]+）（[\\]）（[a-z]*）

但这并不满足第二个条件，我尝试了

^（[a-z]）（[a-z0-9:]*）（/）（[a-z0-9]+（[\\]）（[a-z]+[a-z]*）

，但对于

w:/a\bc

，它应该是两个子集[

w:/a\b，w:/a\bc

），但按规则来说，它的1是obviuos。我做错了什么

正则表达式工具：

---

编辑：为什么w:/a\bc应该产生两个子集[

w:/a\b，w:/a\bc

]，因为它满足所有6个约束条件，并且它的独特之处是“

w:/a\bc

”是

w:/a\b

的超集，直观的方式可能不正确

var regex = new Regex(@"(^[a-z])([a-z0-9:]*)(/)([a-z0-9]+)([\\])([a-z]+)");
        var counter = 0;
        for (var c = 0; c < command.Length; c++)
        {
            var isMatched = regex.Match(string.Join(string.Empty, command.Skip(c)));
            if (isMatched.Success)
            {
                counter += isMatched.Groups.Last().Value.ToCharArray().Length;
            }
        }
        return counter;

var regex=new regex（@“（^[a-z]）（[a-z0-9:]*）（/）（[a-z0-9]+）（[\\]）（[a-z]+）”；
var计数器=0；
for（var c=0；c

直观的方式可能不正确

var regex = new Regex(@"(^[a-z])([a-z0-9:]*)(/)([a-z0-9]+)([\\])([a-z]+)");
        var counter = 0;
        for (var c = 0; c < command.Length; c++)
        {
            var isMatched = regex.Match(string.Join(string.Empty, command.Skip(c)));
            if (isMatched.Success)
            {
                counter += isMatched.Groups.Last().Value.ToCharArray().Length;
            }
        }
        return counter;

var regex=new regex（@“（^[a-z]）（[a-z0-9:]*）（/）（[a-z0-9]+）（[\\]）（[a-z]+）”；
var计数器=0；
for（var c=0；c

匹配字符串后，必须执行子字符串操作

例如： 您的字符串是“abc:/b1c\xy”，您使用正则表达式对其进行了匹配，现在是获取所需数据的时候了

int startIndex=1;
String st="abc:/b1c\xy";
regex1="[a-z0-9:]*(/)"
regex2="(/)([a-z0-9]+)([\\])";
regex3="([\\])([a-z])+";
String PrefixedString=regex1.match(st).group(0);
String CenterString=regex2.match(st).group(0);
String PostfixedString=regex3.match(st).group(0);
if(PrefixedString.contains(":"))
{  startIndex=2; }
for(int i=;i<PrefixedString.length-startIndex;i++)//ends with -startIndex because '/' is included in the string or ':' may be
{
    String temp=PrefixedString[i];
    if(i!=PrefixedString.length)
    {
        for(int j=i+1;j<PrefixedString.length;j++)
        {
             temp+=PrefixedString[j];
        }
    }
    print(temp+CenterString+PostfixedString);
}
for(int i=1;i<PostfixedString.length;i++)//starts with -1 because '\' is included in the string
{
    String temp=PrefixedString+CenterString+PostfixedString[i];
    if(i!=PostfixedString.length)
    {
        for(int j=i+1;j<PostfixedString.length;j++)
        {
             temp+=PostfixedString[j];
        }
    }
    print(temp);
}

intstartindex=1；
字符串st=“abc:/b1c\xy”；
regex1=“[a-z0-9:][*（/）”
regex2=“（/）（[a-z0-9]+）（[\\]）”；
regex3=“（[\\]）（[a-z]）+”；
字符串PrefixedString=regex1.match（st.group）（0）；
String CenterString=regex2.match（st.group）（0）；
String PostfixedString=regex3.match（st）.group（0）；
if（PrefixedString.contains（“：”）
{startIndex=2；}
对于（inti=；i，必须在匹配字符串后执行子字符串操作

例如：
您的字符串是“abc:/b1c\xy”，您使用正则表达式对其进行了匹配，现在是获取所需数据的时候了

int startIndex=1;
String st="abc:/b1c\xy";
regex1="[a-z0-9:]*(/)"
regex2="(/)([a-z0-9]+)([\\])";
regex3="([\\])([a-z])+";
String PrefixedString=regex1.match(st).group(0);
String CenterString=regex2.match(st).group(0);
String PostfixedString=regex3.match(st).group(0);
if(PrefixedString.contains(":"))
{  startIndex=2; }
for(int i=;i<PrefixedString.length-startIndex;i++)//ends with -startIndex because '/' is included in the string or ':' may be
{
    String temp=PrefixedString[i];
    if(i!=PrefixedString.length)
    {
        for(int j=i+1;j<PrefixedString.length;j++)
        {
             temp+=PrefixedString[j];
        }
    }
    print(temp+CenterString+PostfixedString);
}
for(int i=1;i<PostfixedString.length;i++)//starts with -1 because '\' is included in the string
{
    String temp=PrefixedString+CenterString+PostfixedString[i];
    if(i!=PostfixedString.length)
    {
        for(int j=i+1;j<PostfixedString.length;j++)
        {
             temp+=PostfixedString[j];
        }
    }
    print(temp);
}

intstartindex=1；
字符串st=“abc:/b1c\xy”；
regex1=“[a-z0-9:][*（/）”
regex2=“（/）（[a-z0-9]+）（[\\]）”；
regex3=“（[\\]）（[a-z]）+”；
字符串PrefixedString=regex1.match（st.group）（0）；
String CenterString=regex2.match（st.group）（0）；
String PostfixedString=regex3.match（st）.group（0）；
if（PrefixedString.contains（“：”）
{startIndex=2；}
对于（int i=；i，您可以创建一个正则表达式来帮助您分离所有相关的结果部分，但据我所知，您无法创建一个正则表达式，它通过一次搜索提供所有结果集

棘手的部分是前两个条件，因为当字母、数字和冒号混合在一起时，可能有许多可能的起点

为了找到可能的起点，我建议在正斜杠前面的零件采用以下模式：
（？：（[a-z]+）（？：[a-z0-9::*？）+

这将匹配可能的多个捕获，其中捕获中的每个字母都可能是子字符串的起点

整个正则表达式：
（？：（[a-z]+）（？：[a-z0-9:]*？）+/[a-z0-9]+\\（[a-z]*）

通过组合组1的所有捕获的所有后缀子长度和组2的所有前缀子长度来创建结果

示例代码：

var testString = @"a:ab2c:/b1c\xy";

var reg = new Regex(@"(?:([a-z]+)(?:[a-z0-9:]*?))+/[a-z0-9]+\\([a-z]*)");

var matches = reg.Matches(testString);

foreach (Match match in matches)
{
    var prefixGroup = match.Groups[1];
    var postfixGroup = match.Groups[2];

    foreach (Capture prefixCapture in prefixGroup.Captures)
    {
        for (int i = 0; i < prefixCapture.Length; i++)
        {
            for (int j = 0; j < postfixGroup.Length; j++)
            {
                var start = prefixCapture.Index + i;
                var end = postfixGroup.Index + postfixGroup.Length - j;
                Console.WriteLine(testString.Substring(start, end - start));
            }
        }
    }
}

您可能可以创建一个正则表达式来帮助您分离所有相关的结果部分，但据我所知，您不能创建一个正则表达式来通过一次搜索提供所有结果集

棘手的部分是前两个条件，因为当字母、数字和冒号混合在一起时，可能有许多可能的起点

为了找到可能的起点，我建议在正斜杠前面的零件采用以下模式：
（？：（[a-z]+）（？：[a-z0-9::*？）+

这将匹配可能的多个捕获，其中捕获中的每个字母都可能是子字符串的起点

整个正则表达式：
（？：（[a-z]+）（？：[a-z0-9:]*？）+/[a-z0-9]+\\（[a-z]*）

通过组合组1的所有捕获的所有后缀子长度和组2的所有前缀子长度来创建结果

示例代码：

var testString = @"a:ab2c:/b1c\xy";

var reg = new Regex(@"(?:([a-z]+)(?:[a-z0-9:]*?))+/[a-z0-9]+\\([a-z]*)");

var matches = reg.Matches(testString);

foreach (Match match in matches)
{
    var prefixGroup = match.Groups[1];
    var postfixGroup = match.Groups[2];

    foreach (Capture prefixCapture in prefixGroup.Captures)
    {
        for (int i = 0; i < prefixCapture.Length; i++)
        {
            for (int j = 0; j < postfixGroup.Length; j++)
            {
                var start = prefixCapture.Index + i;
                var end = postfixGroup.Index + postfixGroup.Length - j;
                Console.WriteLine(testString.Substring(start, end - start));
            }
        }
    }
}

您认为可以从字符串中的同一位置获得两个匹配项的想法是错误的。@MaciejLos，这是正确的，请参见示例1和示例4。如果我理解这些条件的含义，我会有所帮助。为什么
w:/a\bc
yield
['w:/a\b'，'w:/a\bc']
？为什么它们不同？@Wiktor同意你的观点，但这是个诀窍，区分不同的原因w:/a\b，w:/a\bc将是两个不同的集合，而不是一个。你的第一个条件不满足。我建议测试这个正则表达式模式：
^（[a-z]）{1}（[a-z0-9]{0，}:/）([