Question

Please consider the following code:

List<string> a = new List<string>(new string[] { "a1", "a2" });
List<string> b = new List<string>(new string[] { "b1", "b2" });
List<string> c = new List<string>(new string[] { "c1", "c2" });
List<List<string>> input = new List<List<string>>();
input.Add(a);
input.Add(b);
input.Add(c);
List<List<string>> output=List<List<string>> PickOneFromEachSet(input)

PickOneFromEachSet would pick an element from each set without considering the ordering.

We can have 2^3=8 combinations, i.e. the output would be

{"a1","b1","c1"},
{"a1","b1","c2"},
...
{"a2","b2","c2"}

How should we construct such a function?

Answer 1

See Computing a Cartesian Product with LINQ

List<string> a = new List<string>(new string[] { "a1", "a2" });
List<string> b = new List<string>(new string[] { "b1", "b2" });
List<string> c = new List<string>(new string[] { "c1", "c2" });

var result = CartesianProduct(new List<List<string>>(){a,b,c});

foreach (var row in result)
{
    foreach (var item in row)
    {
        Console.Write(item + " ");
    }
    Console.WriteLine();
}

//https://svn.apache.org/repos/asf/incubator/lucene.net/branches/Lucene.Net_2_9_4g/src/contrib/SimpleFacetedSearch/Extensions.cs
public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new IEnumerable<T>[] { Enumerable.Empty<T>() };
    return sequences.Aggregate(
        emptyProduct,
        (accumulator, sequence) =>
        {
            return accumulator.SelectMany(
                (accseq => sequence),
                (accseq, item) => accseq.Concat(new T[] { item })
            );
        }
    );
}

.NET 3.5

public static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<List<T>> sequences)
{
    //SAME
}

OUTPUT:

a1 b1 c1
a1 b1 c2
a1 b2 c1
a1 b2 c2
a2 b1 c1
a2 b1 c2
a2 b2 c1
a2 b2 c2