无递归的单行解决方案

Question

我尝试编写一个方法，尽可能简单地返回给定枚举的排列。代码：

using System.Collections.Generic;

public static partial class Permutable {
    static IEnumerable<IEnumerable<T>> PermuteIterator<T>(
        IEnumerable<T> source, int offset) {
        var count=0;

        foreach(var dummy in source)
            if(++count>offset)
                foreach(
                    var sequence in
                        Permutable.PermuteIterator(
                            source.Exchange(offset, count-1), 1+offset)
                    )
                    yield return sequence;

        if(offset==count-1)
            yield return source;
    }

    public static IEnumerable<IEnumerable<T>> AsPermutable<T>(
        this IEnumerable<T> source) {
        return Permutable.PermuteIterator(source, 0);
    }

    public static IEnumerable<T> Exchange<T>(
        this IEnumerable<T> source, int index1, int index2) {
        // exchange elements at index1 and index2
    }
}

由于代码在迭代器块中已经简化，我试图使它只是LINQ的单个查询表达式。

嵌套foreach中有一个带有此代码的递归，甚至可能是foreach之外的另一个递归;对于我来说，在查询语法中重写它是困难的部分。

我读过这个答案：

C# String permutation

但我想这对我来说不是解决方案..

我尝试了各种各样的方法，并认为这样做并不容易。我怎么能完成它？

（Exchange方法是另一个问题，我问过一个问题：

How to exchange the items of enumeration by interating only once?

但我想这不是问题......）

Answer 1

因为您正在寻找利用现有LINQ查询运算符的答案，而不是使用迭代器块，所以这是一个。请注意，它不如其他一些解决方案有效; Eric Lippert的解决方案就是使用这些查询运算符的效率不高。（虽然它要短得多。）

另请注意，由于此解决方案使用接受索引的SelectMany和Where重载，因此需要使用方法语法调用这些运算符，而不是查询语法，而其他几个运算符则需要没有查询语法等价物。我可以将Select更改为查询语法，但为了保持一致，我没有。

public static IEnumerable<IEnumerable<T>> Permuatations<T>(
    this IEnumerable<T> source)
{
    var list = source.ToList();//becase we iterate it multiple times
    return list.SelectMany((item, i) => list.Where((_, index) => index != i)
            .Permuatations()
            .Select(subsequence => new[] { item }.Concat(subsequence)))
        .DefaultIfEmpty(Enumerable.Empty<T>());
}

所以，谈谈这是做什么的。

首先它通过源序列;对于该序列中的每个项目，它创建一个类似于源序列但是取出“当前项目”的序列。（这是list.Where方法）。

接下来（递归地）得到该子序列的所有排列。

之后，它会将“已删除”项目添加到每个子序列的开头。

所有这些子序列都被拼凑在一起，因为它们都在SelectMany内。

DefaultIfEmpty用于确保外部序列永远不会为空。置换空序列会导致序列内部出现空序列。这是递归操作的“基本情况”。

Answer 2

编辑1：

无递归的单行解决方案

我已经重新创建了核心方法（来自本答案中的上一个解决方案），所以现在它不再是递归的了。现在很容易从中获得单线解决方案。

我必须使用Enumerable方法和扩展方法来完成它。没有这些，我认为不可能这样做。

class Permutator
{
    private static IEnumerable<IEnumerable<int>> CreateIndices(int length)
    {
        var factorial = Enumerable.Range(2, length - 1)
            .Aggregate((a, b) => a * b);

        return (from p in Enumerable.Range(0, factorial)
                // creating module values from 2 up to length
                // e.g. length = 3: mods = [ p%2, p%3 ]
                // e.g. length = 4: mods = [ p%2, p%3, p%4 ]
                let mods = Enumerable.Range(2, length - 1)
                    .Select(m => p % m).ToArray()
                select (
                    // creating indices for each permutation
                    mods.Aggregate(
                        new[] { 0 },
                        (s, i) =>
                            s.Take(i)
                            .Concat(new[] { s.Length })
                            .Concat(s.Skip(i)).ToArray())
                    ));
    }

    public static IEnumerable<IEnumerable<T>> Get<T>(IEnumerable<T> items)
    {
        var array = items.ToArray();
        return from indices in CreateIndices(array.Length)
                select (from i in indices select array[i]);
    }
}

现在是最终解决方案

结果就是这种怪异：

class Permutator
{
    public static IEnumerable<IEnumerable<T>> Get<T>(IEnumerable<T> items)
    {
        return
            from p in Enumerable.Range(0,
                Enumerable.Range(2, items.Count() - 1)
                    .Aggregate((a, b) => a * b))
            let mods = Enumerable.Range(2, items.Count() - 1)
                .Select(m => p % m).ToArray()
            select mods.Aggregate(
                items.Take(1).ToArray(),
                (s, i) =>
                    s.Take(i)
                    .Concat(items.Skip(s.Length).Take(1))
                    .Concat(s.Skip(i)).ToArray());
    }
}

以前的解决方案

我创造了一些你可能正在寻找的东西：

class Permutator
{
    private static IEnumerable<IEnumerable<int>> CreateIndices(int length)
    {
        return (from p in Enumerable.Range(0, length)
                select (
                    from s in Permutator.CreateIndices(length - 1)
                              .DefaultIfEmpty(Enumerable.Empty<int>())
                    select s.Take(p)
                           .Concat(new[] { length - 1 })
                           .Concat(s.Skip(p))
                    ))
                    .SelectMany(i => i);
    }

    public static IEnumerable<IEnumerable<T>> Get<T>(IEnumerable<T> items)
    {
        var array = items.ToArray();
        return from indices in CreateIndices(array.Length)
                select (from i in indices select array[i]);
    }
}

如何使用它的示例：

var items = new[] { "0", "1", "2" };
var p = Permutator.Get(items);
var result = p.Select(a=>a.ToArray()).ToArray();

如何运作

核心是CreateIndices方法。它为每个排列创建一个包含源元素索引的序列。

最好用一个例子来解释：

CreateIndices(0);
// returns no permutations

CreateIndices(1);
// returns 1 permutation
// [ 0 ]

CreateIndices(2);
// returns 2 permutations
// [ 1, 0 ]
// [ 0, 1 ]

CreateIndices(3);
// returns 6 permutations
// [ 2, 1, 0 ]
// [ 2, 0, 1 ]
// [ 1, 2, 0 ]
// [ 0, 2, 1 ]
// [ 1, 0, 2 ]
// [ 0, 1, 2 ]

它是一个递归方法，仅基于可枚举扩展和LINQ语法查询。

递归的想法是每个级别都基于前一个构建。

CreateIndices(n)将元素n-1添加到CreateIndices(n-1)在所有可用位置返回的排列中。

递归的根是CreateIndices(0)，返回一组空的排列。

逐步解释：CreateIndices(3)

1.让我们从创建CreateIndices(0)：

的结果开始

空

2.然后是CreateIndices(1)的结果：

将元素0（n-1）添加到位置0的每个先前排列中
[0]

3.然后是CreateIndices(2)

的结果

将元素1（n-1）添加到位置0的每个先前排列中
[1,0]
将元素1（n-1）添加到位置1的每个先前排列中
[0,1]

4.然后是CreateIndices(3)

的结果

将元素2（n-1）添加到位置0的每个先前排列中
[2,1,0]
[[2,0,1]
将元素2（n-1）添加到位置1的每个先前排列中
[1,2,0]
[[0,2,1]
将元素2（n-1）添加到位置2的每个先前排列中
[1,0,2]
[[0,1,2]

接下来会发生什么

现在我们有每个排列的索引，我们可以使用它们来构建值的真实排列。这是通用Get方法的作用。

另请注意，Get方法是唯一一个将源序列具体化为数组的方法。 CreateIndices只是一个枚举器，没有任何真实的对象......所以你只需要在枚举序列时支付费用，并在调用Get时付费创建一个源序列数组。

这解释了为什么在示例中调用Get之后，我必须实现结果，以便我们可以使用它：

var items = new[] { "0", "1", "2" };
var p = Permutator.Get(items); // pay to create array from source elements
var result = p.Select(a => a.ToArray() // pay to create arrays for each of the permutations
    ).ToArray(); // pay to get the permutations

如果我们只列举一半的排列，这使我们只需支付一半的费用。

Answer 3

像我一样老，当没有必要时，我从不喜欢递归。

因为你需要迭代源代码，我只需将它存储在一个数组中。我跟踪一个'swappings'数组，告诉程序什么交换什么;索引是交换的源位置，索引是目标位置。

如果您愿意，也可以进行子排列。

如果您真的感到很舒服，我想您也可以将交换更改为复杂的Exchange IEnumerable;我想这是增加大量复杂性同时使一切变慢的好方法。： - ）

我也重用了数组;每次重新编译所有内容似乎都是愚蠢的，当'src'很大时，这会节省你复制数据和进行递归的相当多的时间。这非常有效。

public static IEnumerable<IEnumerable<T>> Permutations<T>(this IEnumerable<T> src)
{
    T[] array = src.ToArray();

    // Initialize
    int[] swappings = new int[array.Length];
    for (int j = 0; j < array.Length; ++j)
    {
        swappings[j] = j;
    }

    yield return array;

    int i = swappings.Length - 2;
    while (i >= 0)
    {
        int prev = swappings[i];
        Swap(array, i, prev);
        int next = prev + 1;
        swappings[i] = next;
        Swap(array, i, next);

        yield return array;

        // Prepare next
        i = swappings.Length - 1;
        while (i >= 0 && swappings[i] == array.Length - 1)
        {
            // Undo the swap represented by permSwappings[i]
            Swap(array, i, swappings[i]);
            swappings[i] = i;
            i--;
        }
    }
}

private static void Swap<T>(T[] array, int i, int next)
{
    var tmp = array[i];
    array[i] = array[next];
    array[next] = tmp;
}

如何使用查询语法创建排列？

3 个答案:

无递归的单行解决方案

以前的解决方案

如何运作