1

I have an array of values, e.g. { 0, 1, 2 } which can be in one of two states { 0, 1 }.

Is there a simple way (perhaps using a linq query) to get a list of all combinations of { value, state } (where value is unique) so that I get results like:

{
{ { 0, 0 }, { 1, 0 }, { 2, 0 } },
{ { 0, 0 }, { 1, 0 }, { 2, 1 } },
{ { 0, 0 }, { 1, 1 }, { 2, 0 } },
{ { 0, 0 }, { 1, 1 }, { 2, 1 } },
{ { 0, 1 }, { 1, 0 }, { 2, 0 } },
{ { 0, 1 }, { 1, 0 }, { 2, 1 } },
{ { 0, 1 }, { 1, 1 }, { 2, 0 } },
{ { 0, 1 }, { 1, 1 }, { 2, 1 } },
}

The "value" array can be of varying size, but they can only ever be in one of two states.

(It's not a cartesian product exactly, and I'm not sure what term can be used to describe it, so don't know what to google).

Thanks!

Improve this question
3
  • That's not permutations, that is combinations. Permutations would for example be turning 123 into {123,132,213,231,312,321}. Commented Mar 23, 2011 at 18:59
  • It's not even combinations. It's a cartesian product in disguise :-). Commented Mar 23, 2011 at 19:00
  • Well, I changed permutation to combination anyway. Commented Mar 23, 2011 at 19:01

4 Answers 4

Reset to default
3

It's a Cartesian product of Cartesian products:

var groups = from x in 
                (from v in values
                 from s in states
                 select new {v,s})
             group x by x.v into gx
             select gx;

var perms = from a in groups[0]
            from b in groups[1]
            from c in groups[2]
            select new {a,b,c};

The groups query produces a Lookup (conceptually a read-only Dictionary of IEnumerables) containing the simple Cartesian product of all values and states (6 elements), grouped by their value. Then, the second query produces a Cartesian product of the elements of the Cartesian product taken three at a time, one from each group in the Lookup.

To make this work with an unknown number of dimensions would be tricky; if you don't absolutely have to make it work that way I would avoid it. I think the most elegant way would be to define a set of extension methods for the System.Tuple generic classes:

public static Tuple<T1,T2> Append(this Tuple<T1> tuple, T2 addend)
{
   return Tuple.Create(tuple.Item1, addend);
}

public static Tuple<T1,T2, T3> Append(this Tuple<T1,T2> tuple, T3 addend)
{
   return Tuple.Create(tuple.Item1, tuple.Item2, addend);
}

...

Then, you can take these helpers and use them in a looped version of the second query:

var perms = from a in groups[0] select Tuple.Create(a);

foreach(var group in groups.Skip(1)) perms = from a in perms from b in group select a.Append(b);

This will produce an enumerable of Tuples of the required length, containing the elements of the anonymous type produced in the first query (which can be refactored to produce strongly-typed 2-item Tuples if you wish). You may have an issue with using the perms collection variable to refer to collections of ever-growing Tuples; this is the tricky part.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

I'm somewhat confused by this answer. I think it needs to be "group x by" in the groups query? Also how does gx get to the second query? The fact that you're using indices 0 1 2 explicitly makes me think that this won't handle varying values array sizes? (Sorry, I'm pretty new to linq, so might be missing something obvious).
True on all counts; I updated the group by clause and the references to the grouped data. To make this work with an unknown number of dimensions would be tricky, but possible; basically you would loop through a query that took the result of the previous query and Cartesian-joined the next dimension to each result. The trick would be flattening that structure back out from these nested arrays or anonymous types back into a one-dimensional collection of tuples.
Thanks for the edits. I had to use .ToArray() in order to be able to index the groups variable. I'll have a go at varying the dimensions and see what I can come up with.
a tip for writing queries that can be read more easily: "from x in (SUBQUERY) TAIL" can also be written "SUBQUERY into x TAIL". So your query could be "from v in values from s in states select new {v,s} into x group x by x.v into gx select gx". The benefit of that syntax is that it is easier to read top-to-bottom; you don't end up introducing a range variable x that is then not used until much later. This "query continuation" syntax puts the range variable introductions close to their usages.
As a last note, I got this working for variable dimensions by using the code from here. After creating the lookup groups, I can just call 'var cornerCoords = CartesianProduct(groups.ToArray());'
2

try 

var values = new int[]{0,1,2};
var states = new int[]{0,1};

var permutations = from v in values
                   from s in states
                   select new {v,s}

you simply need a cross product of two arrays regardless of size of arrays

Improve this answer

1 Comment

No, what's being asked for isn't a cross-product. Your code will produce 6 pairs, whereas what's wanted is 8 triples of pairs.
0

Maybe something like:

var lst1 = new List<int> { 0, 1, 2 };
var lst2 = new List<int> { 0, 1 };

lst1.ForEach(i => {
    Console.WriteLine("{");
    lst2.ForEach(j => Console.Write("{ " + i + "," + j + "}"));
    Console.WriteLine("}");
});

This won't really be in the format you want; you should build some kind of array(s) and then join it on "," and/or "}, {". This should give you the general idea, though.

Improve this answer

Comments

0

As the two states can be seen as bits, you can get the combinations by simply counting and converting the bits to items in an array:

int maxValue = 2;
int[][][] values = Enumerable.Range(0, 1 << maxValue).Select(n =>
  Enumerable.Range(0, maxValue + 1).Select(m =>
    new[] { m, (n >> (maxValue - m)) & 1 }
  ).ToArray()
).ToArray();
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.