c#如何进行排列组合

[快跑稻草人]

我有5个数组

a1={0,1,2,3,4,5,6,7,8,9};
a2={0,1,2,3,4,5,6,7,8,9};
a3={0,1,2,3,4,5,6,7,8,9};
a4={0,1,2,3,4,5,6,7,8,9};
a5={0,1,2,3,4,5,6,7,8,9};

如何把他们每一位都进行组合，组成一个一个的五位数，比如：00000,00001,00002，如果只用for循环就太慢了，组合半天


请问大神如何进行有效的操作，而且不要重复的

[csdnFUCKINGSUCKS]

楼主所说的排列组合其实是笛卡尔积 排列和组合是分开的概念
下面是笛卡尔积linq的实现方式

private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    return sequences.Aggregate(
      emptyProduct,
      (accumulator, sequence) =>
        from accseq in accumulator
        from item in sequence
        select accseq.Concat(new[] { item }));
}

Reference:
Computing a Cartesian product with LINQ

对上面的方法的扩展 增加去重 但会降低执行效率

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences, bool removeDuplicates, IEqualityComparer<IEnumerable<T>> sequenceComparer)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    var resultsSet = sequences.Aggregate(emptyProduct, (accumulator, sequence) => from accseq in accumulator
                                                                                  from item in sequence
                                                                                  select accseq.Concat(new[] { item }));

    if (removeDuplicates)
        return resultsSet.Distinct(sequenceComparer);
    else
        return resultsSet;
}

class UnorderedSequenceComparer : IEqualityComparer<IEnumerable<int>>
{
    public bool Equals(IEnumerable<int> x, IEnumerable<int> y)
    {
        return x.OrderBy(i => i).SequenceEqual(y.OrderBy(i => i));
    }

    public int GetHashCode(IEnumerable<int> obj)
    {
        return obj.Sum(i => i * i);
    }
}

Reference:
Cartesian Product...with a twist (need to remove duplicates)

[xuzuning]

怎么可能？

        static void Main(string[] args)
        {
            int[] a1 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int[] a2 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int[] a3 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int[] a4 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int[] a5 = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int count = 0;
            Stopwatch sw = new Stopwatch();
            sw.Start();

            var r = from i1 in a1
                    from i2 in a2
                    from i3 in a3
                    from i4 in a4
                    from i5 in a5
                    select i1 + "," + i2 + "," + i3 + "," + i4 + "," + i5;
            count = r.Count();

            sw.Stop();
            TimeSpan ts2 = sw.Elapsed;
            Console.WriteLine("共{0}种组合,耗时{1}ms", count, ts2.TotalMilliseconds);

            sw.Restart();

            count = 0;
            foreach (var i1 in a1)
                foreach (var i2 in a2)
                    foreach (var i3 in a3)
                        foreach (var i4 in a4)
                            foreach (var i5 in a5)
                            {
                                var n = i1 + "," + i2 + "," + i3 + "," + i4 + "," + i5;
                                count++;
                            }

            sw.Stop();
            ts2 = sw.Elapsed;
            Console.WriteLine("共{0}种组合,耗时{1}ms", count, ts2.TotalMilliseconds);
            Console.ReadKey();
        }
  

你总不能把 Console.WriteLine 所花费的时间也算在算法里吧？

[threenewbee]

http://bbs.csdn.net/topics/390778020

[快跑稻草人]

引用 8 楼 ducker3590 的回复:

楼主所说的排列组合其实是笛卡尔积 排列和组合是分开的概念 下面是笛卡尔积linq的实现方式

private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    return sequences.Aggregate(
      emptyProduct,
      (accumulator, sequence) =>
        from accseq in accumulator
        from item in sequence
        select accseq.Concat(new[] { item }));
}

Reference: Computing a Cartesian product with LINQ 对上面的方法的扩展 增加去重 但会降低执行效率

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences, bool removeDuplicates, IEqualityComparer<IEnumerable<T>> sequenceComparer)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    var resultsSet = sequences.Aggregate(emptyProduct, (accumulator, sequence) => from accseq in accumulator
                                                                                  from item in sequence
                                                                                  select accseq.Concat(new[] { item }));

    if (removeDuplicates)
        return resultsSet.Distinct(sequenceComparer);
    else
        return resultsSet;
}

class UnorderedSequenceComparer : IEqualityComparer<IEnumerable<int>>
{
    public bool Equals(IEnumerable<int> x, IEnumerable<int> y)
    {
        return x.OrderBy(i => i).SequenceEqual(y.OrderBy(i => i));
    }

    public int GetHashCode(IEnumerable<int> obj)
    {
        return obj.Sum(i => i * i);
    }
}

Reference: Cartesian Product...with a twist (need to remove duplicates)

如果取出数据组成一个字符串，是不是又要循环取出数据?

[SoulRed]

Console.WriteLine 是比较耗费CPU时间的，我测试的时候有的时候CPU时间会飙升几十倍，间歇性的。 如果楼主想用简洁的代码来实现，不妨试下LINQ排序

[_明月]

引用 6 楼 ljaahh 的回复:

[quote=引用 4 楼 ducker3590 的回复:]

class Program
{

    static IEnumerable<T> Prepend<T>(T first, IEnumerable<T> rest)
    {
        yield return first;
        foreach (var item in rest)
            yield return item;
    }

    static IEnumerable<IEnumerable<int>> M(int p, int t1, int t2)
    {
        if (p == 0)
            yield return Enumerable.Empty<int>();
        else
            for (int first = t1; first <= t2; ++first)
                foreach (var rest in M(p - 1, first, t2))
                    yield return Prepend(first, rest);
    }

    static void Main()
    {
        int count = 0;
        Stopwatch sw = new Stopwatch();
        sw.Start();
        foreach (var sequence in M(5, 0, 9))
        {
            Console.WriteLine(string.Join(", ", sequence));
            count++;
        }
        sw.Stop();
        TimeSpan ts2 = sw.Elapsed;
        Console.WriteLine("共{0}种组合,耗时{1}ms", count, ts2.TotalMilliseconds);
        Console.ReadLine();
    }
}

Reference: Generating Permutations using LINQ

谢谢，这个是没有顺序的，应该有10*10*10*10*10种组合[/quote] 是的，这5个数组的组合种类一共有：10^5 (10的5次方)。 我觉得，你的这个题，使用for循环来做。至于，是否有那种快速的算法，这个我就不知道了。我对算法不懂。

[_明月]

引用 8 楼 ducker3590 的回复:

楼主所说的排列组合其实是笛卡尔积 排列和组合是分开的概念 下面是笛卡尔积linq的实现方式

private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    return sequences.Aggregate(
      emptyProduct,
      (accumulator, sequence) =>
        from accseq in accumulator
        from item in sequence
        select accseq.Concat(new[] { item }));
}

Reference: Computing a Cartesian product with LINQ 对上面的方法的扩展 增加去重 但会降低执行效率

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences, bool removeDuplicates, IEqualityComparer<IEnumerable<T>> sequenceComparer)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    var resultsSet = sequences.Aggregate(emptyProduct, (accumulator, sequence) => from accseq in accumulator
                                                                                  from item in sequence
                                                                                  select accseq.Concat(new[] { item }));

    if (removeDuplicates)
        return resultsSet.Distinct(sequenceComparer);
    else
        return resultsSet;
}

class UnorderedSequenceComparer : IEqualityComparer<IEnumerable<int>>
{
    public bool Equals(IEnumerable<int> x, IEnumerable<int> y)
    {
        return x.OrderBy(i => i).SequenceEqual(y.OrderBy(i => i));
    }

    public int GetHashCode(IEnumerable<int> obj)
    {
        return obj.Sum(i => i * i);
    }
}

Reference: Cartesian Product...with a twist (need to remove duplicates)

请问一下，在您给的这个网址链接中，网页内容都是纯英文单词。你是如何看懂这些英文句子的？你有没有好的学习英语的方法，可否分享一下？谢谢

[csdnFUCKINGSUCKS]

引用 11 楼 ljaahh 的回复:

[quote=引用 8 楼 ducker3590 的回复:] 楼主所说的排列组合其实是笛卡尔积 排列和组合是分开的概念 下面是笛卡尔积linq的实现方式

private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    return sequences.Aggregate(
      emptyProduct,
      (accumulator, sequence) =>
        from accseq in accumulator
        from item in sequence
        select accseq.Concat(new[] { item }));
}

Reference: Computing a Cartesian product with LINQ 对上面的方法的扩展 增加去重 但会降低执行效率

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences, bool removeDuplicates, IEqualityComparer<IEnumerable<T>> sequenceComparer)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    var resultsSet = sequences.Aggregate(emptyProduct, (accumulator, sequence) => from accseq in accumulator
                                                                                  from item in sequence
                                                                                  select accseq.Concat(new[] { item }));

    if (removeDuplicates)
        return resultsSet.Distinct(sequenceComparer);
    else
        return resultsSet;
}

class UnorderedSequenceComparer : IEqualityComparer<IEnumerable<int>>
{
    public bool Equals(IEnumerable<int> x, IEnumerable<int> y)
    {
        return x.OrderBy(i => i).SequenceEqual(y.OrderBy(i => i));
    }

    public int GetHashCode(IEnumerable<int> obj)
    {
        return obj.Sum(i => i * i);
    }
}

Reference: Cartesian Product...with a twist (need to remove duplicates)

如果取出数据组成一个字符串，是不是又要循环取出数据?[/quote] 要取数据必然是要循环的 除非你有特殊的规则 那可以用linq来做 把生成的list作为数据源去查询

[csdnFUCKINGSUCKS]

引用 14 楼 dear_Alice_moon 的回复:

[quote=引用 8 楼 ducker3590 的回复:] 楼主所说的排列组合其实是笛卡尔积 排列和组合是分开的概念 下面是笛卡尔积linq的实现方式

private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    return sequences.Aggregate(
      emptyProduct,
      (accumulator, sequence) =>
        from accseq in accumulator
        from item in sequence
        select accseq.Concat(new[] { item }));
}

Reference: Computing a Cartesian product with LINQ 对上面的方法的扩展 增加去重 但会降低执行效率

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences, bool removeDuplicates, IEqualityComparer<IEnumerable<T>> sequenceComparer)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    var resultsSet = sequences.Aggregate(emptyProduct, (accumulator, sequence) => from accseq in accumulator
                                                                                  from item in sequence
                                                                                  select accseq.Concat(new[] { item }));

    if (removeDuplicates)
        return resultsSet.Distinct(sequenceComparer);
    else
        return resultsSet;
}

class UnorderedSequenceComparer : IEqualityComparer<IEnumerable<int>>
{
    public bool Equals(IEnumerable<int> x, IEnumerable<int> y)
    {
        return x.OrderBy(i => i).SequenceEqual(y.OrderBy(i => i));
    }

    public int GetHashCode(IEnumerable<int> obj)
    {
        return obj.Sum(i => i * i);
    }
}

Reference: Cartesian Product...with a twist (need to remove duplicates)

请问一下，在您给的这个网址链接中，网页内容都是纯英文单词。你是如何看懂这些英文句子的？你有没有好的学习英语的方法，可否分享一下？谢谢 [/quote] 这倒真没什么好的方法 反正就是多看 不懂的就去查 当然 嫌麻烦也可以直接翻译一下 一般情况下也能看懂个大概

[_明月]

引用 16 楼 ducker3590 的回复:

[quote=引用 14 楼 dear_Alice_moon 的回复:] 请问一下，在您给的这个网址链接中，网页内容都是纯英文单词。你是如何看懂这些英文句子的？你有没有好的学习英语的方法，可否分享一下？谢谢

这倒真没什么好的方法 反正就是多看 不懂的就去查 当然 嫌麻烦也可以直接翻译一下 一般情况下也能看懂个大概[/quote] 嗯，好的。谢谢 在以后的工作中，我一定要找到好的学习英语的方法，为自己的“添加”一双可以飞的更高、走的更远的翅膀。

[快跑稻草人]

引用 15 楼 ducker3590 的回复:

[quote=引用 11 楼 ljaahh 的回复:] [quote=引用 8 楼 ducker3590 的回复:] 楼主所说的排列组合其实是笛卡尔积 排列和组合是分开的概念 下面是笛卡尔积linq的实现方式

private static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    return sequences.Aggregate(
      emptyProduct,
      (accumulator, sequence) =>
        from accseq in accumulator
        from item in sequence
        select accseq.Concat(new[] { item }));
}

Reference: Computing a Cartesian product with LINQ 对上面的方法的扩展 增加去重 但会降低执行效率

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(IEnumerable<IEnumerable<T>> sequences, bool removeDuplicates, IEqualityComparer<IEnumerable<T>> sequenceComparer)
{
    IEnumerable<IEnumerable<T>> emptyProduct = new[] { Enumerable.Empty<T>() };
    var resultsSet = sequences.Aggregate(emptyProduct, (accumulator, sequence) => from accseq in accumulator
                                                                                  from item in sequence
                                                                                  select accseq.Concat(new[] { item }));

    if (removeDuplicates)
        return resultsSet.Distinct(sequenceComparer);
    else
        return resultsSet;
}

class UnorderedSequenceComparer : IEqualityComparer<IEnumerable<int>>
{
    public bool Equals(IEnumerable<int> x, IEnumerable<int> y)
    {
        return x.OrderBy(i => i).SequenceEqual(y.OrderBy(i => i));
    }

    public int GetHashCode(IEnumerable<int> obj)
    {
        return obj.Sum(i => i * i);
    }
}

Reference: Cartesian Product...with a twist (need to remove duplicates)

如果取出数据组成一个字符串，是不是又要循环取出数据?[/quote] 要取数据必然是要循环的 除非你有特殊的规则 那可以用linq来做 把生成的list作为数据源去查询[/quote] 规则就是IEnumerable<IEnumerable<T>>中所有数字组合起来， 外层的加一个逗号分隔

[快跑稻草人]

引用 12 楼 DOwnstairs 的回复:

Console.WriteLine 是比较耗费CPU时间的，我测试的时候有的时候CPU时间会飙升几十倍，间歇性的。 如果楼主想用简洁的代码来实现，不妨试下LINQ排序

Linq排序在哪里学啊？

[SoulRed]

引用 19 楼 ljaahh 的回复:

[quote=引用 12 楼 DOwnstairs 的回复:] Console.WriteLine 是比较耗费CPU时间的，我测试的时候有的时候CPU时间会飙升几十倍，间歇性的。 如果楼主想用简洁的代码来实现，不妨试下LINQ排序

Linq排序在哪里学啊？[/quote] Linq就是为微软官方支持的一个类似于数据库查询语句的数据查询语法工具，特别适合你这个题目。 https://msdn.microsoft.com/zh-cn/library/bb384063.aspx 你可以看下

[csdnFUCKINGSUCKS]

static void Main()
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    StringBuilder sb = new StringBuilder();
    var listofInts = new List<List<int>>(5);
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });

    var temp = CartesianProduct(listofInts);

    foreach (var item in temp)
    {
        sb.Append(string.Join("", item) + ",");
    }

    string result = sb.ToString();
    result = result.Substring(0, result.Length - 1);
    sw.Stop();
    Console.WriteLine(result);
    Console.WriteLine("共:" + result.Split(',').Length + "种组合");
    Console.WriteLine("耗时:" + sw.ElapsedMilliseconds + "ms");

    Console.ReadLine();
}

[快跑稻草人]

引用 20 楼 DOwnstairs 的回复:

[quote=引用 19 楼 ljaahh 的回复:] [quote=引用 12 楼 DOwnstairs 的回复:] Console.WriteLine 是比较耗费CPU时间的，我测试的时候有的时候CPU时间会飙升几十倍，间歇性的。 如果楼主想用简洁的代码来实现，不妨试下LINQ排序

Linq排序在哪里学啊？[/quote] Linq就是为微软官方支持的一个类似于数据库查询语句的数据查询语法工具，特别适合你这个题目。 https://msdn.microsoft.com/zh-cn/library/bb384063.aspx 你可以看下[/quote] 谢谢，请问您IEnumerable<IEnumerable<T>>如何取出数据作为一个字符串，比如List<List<int>>这种类型的，我试了好几次都不行

[快跑稻草人]

引用 21 楼 ducker3590 的回复:

static void Main()
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    StringBuilder sb = new StringBuilder();
    var listofInts = new List<List<int>>(5);
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });

    var temp = CartesianProduct(listofInts);

    foreach (var item in temp)
    {
        sb.Append(string.Join("", item) + ",");
    }

    string result = sb.ToString();
    result = result.Substring(0, result.Length - 1);
    sw.Stop();
    Console.WriteLine(result);
    Console.WriteLine("共:" + result.Split(',').Length + "种组合");
    Console.WriteLine("耗时:" + sw.ElapsedMilliseconds + "ms");

    Console.ReadLine();
}

不好意思因为要处理大量的数据，只能接受5s以内

[快跑稻草人]

引用 21 楼 ducker3590 的回复:

static void Main()
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    StringBuilder sb = new StringBuilder();
    var listofInts = new List<List<int>>(5);
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });

    var temp = CartesianProduct(listofInts);

    foreach (var item in temp)
    {
        sb.Append(string.Join("", item) + ",");
    }

    string result = sb.ToString();
    result = result.Substring(0, result.Length - 1);
    sw.Stop();
    Console.WriteLine(result);
    Console.WriteLine("共:" + result.Split(',').Length + "种组合");
    Console.WriteLine("耗时:" + sw.ElapsedMilliseconds + "ms");

    Console.ReadLine();
}

我试用String.Join("",result.SelectMany(x=>x))这样可以组合但是没有分隔符

[xuzuning]

难道 107ms 不在 5s 以内吗？

[快跑稻草人]

引用 21 楼 ducker3590 的回复:

static void Main()
{
    Stopwatch sw = new Stopwatch();
    sw.Start();
    StringBuilder sb = new StringBuilder();
    var listofInts = new List<List<int>>(5);
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
    listofInts.Add(new List<int> { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });

    var temp = CartesianProduct(listofInts);

    foreach (var item in temp)
    {
        sb.Append(string.Join("", item) + ",");
    }

    string result = sb.ToString();
    result = result.Substring(0, result.Length - 1);
    sw.Stop();
    Console.WriteLine(result);
    Console.WriteLine("共:" + result.Split(',').Length + "种组合");
    Console.WriteLine("耗时:" + sw.ElapsedMilliseconds + "ms");

    Console.ReadLine();
}

不好意思我看错了，你这是毫秒

[快跑稻草人]

引用 25 楼 xuzuning 的回复:

难道 107ms 不在 5s 以内吗？

版主我关注你很久了