C# 如何使用字符串操作生成一整套组合？

我有一个小项目，其中有一个输入语句，用户可以在其中指定变体：

The {small|big} car is {red|blue}

上面是一个示例句子，我想分成4个句子，如下所示：

• 这辆小汽车是红色的
• 这辆大轿车是红色的
• 这辆小汽车是蓝色的
• 这辆大汽车是蓝色的

我似乎无法集中精力解决这个问题。也许有人能帮我

编辑 这是我的初始代码

Regex regex = new Regex("{(.*?)}", RegexOptions.Singleline);
MatchCollection collection = regex.Matches(richTextBox1.Text);
string data = richTextBox1.Text;

//build amount of variations
foreach (Match match in collection)
{
    string[] alternatives = match.Value.Split(new char[] { '|', '{', '}' }, StringSplitOptions.RemoveEmptyEntries);
    foreach (string alternative in alternatives)
    {
        //here i get problems                  
    }
}

---

我建议将输入文本拆分为静态和动态部分的有序列表。每个动态零件本身都包含一个存储其值的列表和一个表示当前选定值的索引。此索引初始设置为零

要打印出所有可能的组合，首先必须实现一种方法，使用动态零件的当前设置索引打印完整列表。对于第一次调用，所有索引都将设置为零

---

现在，您可以增加第一个动态部件的索引并打印完整列表。这将为您提供第一个变体。重复此操作，直到打印出其余动态部分的所有可能值。

我建议将输入文本拆分为静态和动态部分的有序列表。每个动态零件本身都包含一个存储其值的列表和一个表示当前选定值的索引。此索引初始设置为零

要打印出所有可能的组合，首先必须实现一种方法，使用动态零件的当前设置索引打印完整列表。对于第一次调用，所有索引都将设置为零

---

现在，您可以增加第一个动态部件的索引并打印完整列表。这将为您提供第一个变体。重复此操作，直到打印出其余动态部件的所有可能值。

考虑嵌套迭代循环。类似于

foreach(string s in someStringSet)
{
    foreach(string t in someOtherStringSet)
    {
        // do something with s and t
    }
}

---

考虑嵌套迭代循环。类似于

foreach(string s in someStringSet)
{
    foreach(string t in someOtherStringSet)
    {
        // do something with s and t
    }
}

private void ExpandString（列表结果、字符串文本）
{
var start=text.IndexOf（'{'）；
var end=text.IndexOf（'}'）；
如果（开始>=0&&end>start）
{
var head=text.Substring（0，开始）；
var list=text.Substring（start+1，end-start-1）.Split（“|”）；
var tail=text.Substring（end+1）；
foreach（列表中的变量项）
ExpandString（结果，头+项+尾）；
}
其他的
结果.添加（文本）；
}

使用类似于：

    var result = new List<string>();
    ExpandString(result, "The {small|big} car is {red|blue}");

var result=newlist（）；
ExpandString（结果是，{small | big}车是{red | blue}）；

private void ExpandString（列表结果、字符串文本）
{
var start=text.IndexOf（'{'）；
var end=text.IndexOf（'}'）；
如果（开始>=0&&end>start）
{
var head=text.Substring（0，开始）；
var list=text.Substring（start+1，end-start-1）.Split（“|”）；
var tail=text.Substring（end+1）；
foreach（列表中的变量项）
ExpandString（结果，头+项+尾）；
}
其他的
结果.添加（文本）；
}

使用类似于：

    var result = new List<string>();
    ExpandString(result, "The {small|big} car is {red|blue}");

var result=newlist（）；
ExpandString（结果是，{small | big}车是{red | blue}）；

也许您正在寻找： 编辑版本

static void Main(string[] args)
{
    var thisstring = "The {Small|Big} car is {Red|Blue}";           
    string FirstString = thisstring.Substring(thisstring.IndexOf("{"), (thisstring.IndexOf("}") - thisstring.IndexOf("{")) + 1);
    string[] FirstPossibility = FirstString.Replace("{", "").Replace("}", "").Split('|');
    thisstring = thisstring.Replace(FirstString, "[0]");
    string SecondString = thisstring.Substring(thisstring.IndexOf("{"), (thisstring.IndexOf("}") - thisstring.IndexOf("{")) + 1);
    string[] SecondPosibility = SecondString.Replace("{", "").Replace("}", "").Split('|');
    thisstring = thisstring.Replace(SecondString, "{1}").Replace("[0]", "{0}");
    foreach (string tempFirst in FirstPossibility)
    {
        foreach (string tempSecond in SecondPosibility)
        {
            Console.WriteLine(string.Format(thisstring, tempFirst, tempSecond));
        }
    }
    Console.Read();
}

---

也许你正在寻找这个： 编辑版本

static void Main(string[] args)
{
    var thisstring = "The {Small|Big} car is {Red|Blue}";           
    string FirstString = thisstring.Substring(thisstring.IndexOf("{"), (thisstring.IndexOf("}") - thisstring.IndexOf("{")) + 1);
    string[] FirstPossibility = FirstString.Replace("{", "").Replace("}", "").Split('|');
    thisstring = thisstring.Replace(FirstString, "[0]");
    string SecondString = thisstring.Substring(thisstring.IndexOf("{"), (thisstring.IndexOf("}") - thisstring.IndexOf("{")) + 1);
    string[] SecondPosibility = SecondString.Replace("{", "").Replace("}", "").Split('|');
    thisstring = thisstring.Replace(SecondString, "{1}").Replace("[0]", "{0}");
    foreach (string tempFirst in FirstPossibility)
    {
        foreach (string tempSecond in SecondPosibility)
        {
            Console.WriteLine(string.Format(thisstring, tempFirst, tempSecond));
        }
    }
    Console.Read();
}

---

如果您不知道变体的数量，递归是您的朋友：

static public IEnumerable<string> permute(string template)
{
    List<string> options;
    string before;
    string after;
    if (FindFirstOptionList(template, out options, out before, out after))
    {
        foreach (string option in options)
        {
            foreach (string permutation in permute(before + option + after))
            {
                yield return permutation;
            }
        }
    }
    else
    {
        yield return template;
    }
}

static public bool FindFirstOptionList(string template, out List<string> options, out string before, out string after)
{
    before = string.Empty;
    after = string.Empty;
    options = new List<string>(0);
    if (template.IndexOf('{') == -1)
    {
        return false;
    }
    before = template.Substring(0, template.IndexOf('{'));
    template = template.Substring(template.IndexOf('{') + 1);
    if (template.IndexOf('}') == -1)
    {
        return false;
    }
    after = template.Substring(template.IndexOf('}') + 1);
    options = template.Substring(0, template.IndexOf('}')).Split('|').ToList();
    return true;
}

---

如果您不知道变体的数量，递归是您的朋友：

static public IEnumerable<string> permute(string template)
{
    List<string> options;
    string before;
    string after;
    if (FindFirstOptionList(template, out options, out before, out after))
    {
        foreach (string option in options)
        {
            foreach (string permutation in permute(before + option + after))
            {
                yield return permutation;
            }
        }
    }
    else
    {
        yield return template;
    }
}

static public bool FindFirstOptionList(string template, out List<string> options, out string before, out string after)
{
    before = string.Empty;
    after = string.Empty;
    options = new List<string>(0);
    if (template.IndexOf('{') == -1)
    {
        return false;
    }
    before = template.Substring(0, template.IndexOf('{'));
    template = template.Substring(template.IndexOf('{') + 1);
    if (template.IndexOf('}') == -1)
    {
        return false;
    }
    after = template.Substring(template.IndexOf('}') + 1);
    options = template.Substring(0, template.IndexOf('}')).Split('|').ToList();
    return true;
}

---

像这样的方法应该会奏效：

private void Do()
{
    string str = "The {small|big} car is {red|blue}";

    Regex regex = new Regex("{(.*?)}", RegexOptions.Singleline);

    int i = 0;
    var strWithPlaceHolders = regex.Replace(str, m => "{" + (i++).ToString() + "}");

    var collection = regex.Matches(str);

    var alternatives = collection.OfType<Match>().Select(m => m.Value.Split(new char[] { '|', '{', '}' }, StringSplitOptions.RemoveEmptyEntries));
    var replacers = GetReplacers(alternatives);

    var combinations = new List<string>();
    foreach (var replacer in replacers)
    {
        combinations.Add(string.Format(strWithPlaceHolders, replacer));
    }
}

private IEnumerable<object[]> GetReplacers(IEnumerable<string[]> alternatives)
{
    return GetAllPossibilities(0, alternatives.ToList());
}

private IEnumerable<object[]> GetAllPossibilities(int level, List<string[]> list)
{
    if (level == list.Count - 1)
    {
        foreach (var elem in list[level])
            yield return new[] { elem };
    }
    else
    {
        foreach (var elem in list[level])
        {
            var thisElemAsArray = new object[] { elem };
            foreach (var subPossibilities in GetAllPossibilities(level + 1, list))
                yield return thisElemAsArray.Concat(subPossibilities).ToArray();
        }
    }
    yield break;
}

private void Do（）
{
string str=“这辆{小|大}车是{红|蓝}”；
Regex Regex=newregex（“{（.*）}”，RegexOptions.Singleline）；
int i=0；
var strWithPlaceHolders=regex.Replace（str，m=>“{”+（i++）.ToString（）+“}”）；
var collection=regex.Matches（str）；
var alternatives=collection.OfType（）.Select（m=>m.Value.Split（新字符[]{''.'，'{'，'}}}，StringSplitOptions.RemoveEmptyEntries））；
var replaces=getreplaces（备选方案）；
变量组合=新列表（）；
foreach（替换中的变量替换）
{
Add（string.Format（strwithplaceholder，replacer））；
}
}
私有IEnumerable getreplaces（IEnumerable替代方案）
{
返回getAllObilities（0，alternations.ToList（））；
}
私有IEnumerable GetAllObilities（整数级，列表）
{
if（level==list.Count-1）
{
foreach（列表中的变量元素[级别]）
产生返回新[]{elem}；
}
其他的
{
foreach（列表中的变量元素[级别]）
{
var thiselmasarray=新对象[]{elem}；
foreach（GetAllProbabilities中的var子概率（级别+1，列表））
返回thiselmasarray.Concat（子概率）.ToArray（）；
}
}
屈服断裂；
}

类似的方法应该可以：

private void Do()
{
    string str = "The {small|big} car is {red|blue}";

    Regex regex = new Regex("{(.*?)}", RegexOptions.Singleline);

    int i = 0;
    var strWithPlaceHolders = regex.Replace(str, m => "{" + (i++).ToString() + "}");

    var collection = regex.Matches(str);

    var alternatives = collection.OfType<Match>().Select(m => m.Value.Split(new char[] { '|', '{', '}' }, StringSplitOptions.RemoveEmptyEntries));
    var replacers = GetReplacers(alternatives);

    var combinations = new List<string>();
    foreach (var replacer in replacers)
    {
        combinations.Add(string.Format(strWithPlaceHolders, replacer));
    }
}

private IEnumerable<object[]> GetReplacers(IEnumerable<string[]> alternatives)
{
    return GetAllPossibilities(0, alternatives.ToList());
}

private IEnumerable<object[]> GetAllPossibilities(int level, List<string[]> list)
{
    if (level == list.Count - 1)
    {
        foreach (var elem in list[level])
            yield return new[] { elem };
    }
    else
    {
        foreach (var elem in list[level])
        {
            var thisElemAsArray = new object[] { elem };
            foreach (var subPossibilities in GetAllPossibilities(level + 1, list))
                yield return thisElemAsArray.Concat(subPossibilities).ToArray();
        }
    }
    yield break;
}

private void Do（）
{
string str=“这辆{小|大}车是{红|蓝}”；
Regex Regex=newregex（“{（.*）}”，RegexOptions.Singleline）；
int i=0；
var strWithPlaceHolders=regex.Replace（str，m=>“{”+（i++）.ToString（）+“}”）；
var collection=regex.Matches（str）；
var alternatives=collection.OfType（）.Select（m=>m.Value.Split（新字符[]{''.'，'{'，'}}}，StringSplitOptions.RemoveEmptyEntries））；
var replaces=getreplaces（备选方案）；
变量组合=新列表（）；
foreach（替换中的变量替换）
{
Add（string.Format（strwithplaceholder，replacer））；
}
}
私有IEnumerable getreplaces（IEnumerable替代方案）
{
返回getAllObilities（0，alternations.ToList（））；
}
私有IEnumerable GetAllObilities（整数级，列表）
{
if（level==list.Count-1）
{
foreach（列表中的变量元素[级别]）
产生返回新[]{elem}；
}
其他的
{
foreach（列表中的变量元素[级别]）
{
var thiselmasarray=新对象[]{elem
var set = ex.Matches(sentence)
    .Cast<Match>()
    .Select(m => 
        m.Groups["words"].Value
            .Split('|')
    ).CartesianProduct();

foreach (var item in set)
{
    Console.WriteLine(pattern, item.ToArray());
}

The small car is red
The small car is blue
The big car is red
The big car is blue
static IEnumerable<IEnumerable<T>> CartesianProduct<T>(
    this IEnumerable<IEnumerable<T>> sequences) 
{ 
  IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() }; 
  return sequences.Aggregate( 
    emptyProduct, 
    (accumulator, sequence) =>  
      from accseq in accumulator  
      from item in sequence  
      select accseq.Concat(new[] {item}));                
}