Kevin Le - 1 year ago 88

C# Question

Was curiouis and looked around for a LINQ permutation solution and found one here:

What is the best way to find all combinations of items in an array?

Here is the code in question:

`static IEnumerable<IEnumerable<T>> GetPermutations<T>(IEnumerable<T> list, int length)`

{

if (length == 1) return list.Select(t => new T[] { t });

return GetPermutations(list, length - 1)

.SelectMany(t => list.Where(o => !t.Contains(o)),

(t1, t2) => t1.Concat(new T[] { t2 }));

}

I understand the solution for the most part, but am unsure what

`t1`

`t2`

`t1`

`t2`

Edit*

Oops, I was looking at the wrong SelectMany docs. The correct one signature is here https://msdn.microsoft.com/en-us/library/bb534631(v=vs.110).aspx.

Recommended for you: Get network issues from **WhatsUp Gold**. **Not end users.**

Answer Source

That second lambda is the `resultSelector`

and allows for modifications of the selected collection (`t2`

) depending on the instance that owns the collection (`t1`

).

In your specific example `t1`

is a permutation of `list`

and `t2`

is an element of all the elements from `list`

that are not part of `t1`

.

Hence `(t1, t2) => t1.Concat(new T[] { t2 })`

is used to yield the next "generation" of permutations from a given permutation `t1`

and the so far unused elements from `list`

.

Let `list`

be `{ 1, 2, 3, 4 }`

and let `t1`

be `{ 1, 2 }`

.

Then the `collectionSelector`

will select all elements from `list`

not inside `t1`

, i.e. `{ 3, 4 }`

, and the `resultSelector`

will append each of those elements to `t1`

once.

Thus yielding the permutations `{ 1, 2, 3 }`

and `{ 1, 2, 4 }`

.

Recommended from our users: **Dynamic Network Monitoring from WhatsUp Gold from IPSwitch**. ** Free Download**