Question

I have a small project where I have an input sentence where it is possible for the user to specify variations:

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

Above is a sample sentence i want to split into 4 sentences, like this:

• The small car is red
• The big car is red
• The small car is blue
• The big car is blue

I can’t seem to wrap my mind around the problem. Maybe someone can helt me pls.

Edit
Here is my initial code

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                  
    }
}

Answer 1

It sounds like you need a dynamic cartesian function for this. Eric Lippert’s blog post written in response to Generating all Possible Combinations.

Firstly, we need to parse the input string:

Regex ex = new Regex(@"(?<=\{)(?<words>\w+(\|\w+)*)(?=\})");
var sentence = "The {small|big} car is {red|blue}";

then the input string should be modified to be used in string.Format-like functions:

int matchCount = 0;
var pattern = ex.Replace(sentence, me => 
{
    return (matchCount++).ToString(); 
});
// pattern now contains "The {0} car is {1}"

then we need to find all the matches and to apply Eric’s excellent CartesianProduct extension method:

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());
}

this will produce:

The small car is red
The small car is blue
The big car is red
The big car is blue

and, finally, the CartesianProduct method (taken from here):

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}));                
}