Question

Can someone explain to me how this code works which generates permutations?

I see that it’s using recursive list building but I can’t quite get my brain around the exact mechanics.

public static IEnumerable<IEnumerable<T>> Permute<T>(this IEnumerable<T> list)
{
    if (list.Count() == 1)
        return new List<IEnumerable<T>> { list };
    return list
        .Select((a, i1) => 
                    Permute(list.Where((b, i2) => i2 != i1))
                   .Select(b => (new List<T> { a }).Union(b)))
        .SelectMany(c => c);
}

Answer 1

Firstly, I’d point out that this relies on the ordering of Union, which is unspecified, and only works if the values in the original collection are unique. Changing Union to Concat would fix that.

I suspect it’s also frighteningly expensive. Anyway…

You can understand it by induction. It definitely works for a single element collection, based on the if. So, let’s go from there.

Suppose we start with the assumption that it works for a collection of size n like this:

{ e1, ... en }

Now let’s see whether it works for a collection of size n + 1. The call will bypass the “if”, and go into the recursive return part. So we’re left with:

list.Select((a, i1) => 
                Permute(list.Where((b, i2) => i2 != i1))
               .Select(b => (new List<T> { a }).Union(b)))
    .SelectMany(c => c);

The SelectMany part just flattens a collection of collections – that’s straightforward. So let’s focus on the Select call. It’s saying…

• For each element (a) in the original collection, which we know has index i1…
  • Work out the list except that element (that’s the list.Where(...) part)
  • For each permutation of that smaller list (that’s the Permute call)…
  • … generate a new list consisting of element a followed by the “current permutation” (That’s the new List(...).Union(b) part.)

So if our collection was { x, y, z } we’d get:

• Every collection of { y, z } prefixed by x
• Every collection of { x, z } prefixed by y
• Every collection of { x, y } prefixed by z

That pretty much defines “every permutation”… so it works for n + 1.

Given the base case and the induction step, it therefore works for collections of any size greater than or equal to 1.