c#如何进行排列组合

2016-12-05 07:17:07 958 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

从零开始，手把手教你用RTL代码设计一个简单的8位CPU（附状态图与ALU设计）本文详细介绍了如何从零开始设计一个简单的8位CPU，包括状态机设计、ALU实现与RTL编码实战。通过具体的指令集分析、状态图设计和Verilog代码示例，帮助读者深入理解CPU工作原理，并掌握RTL代码编写技巧。特别适合计算机系统学习者和硬件设计爱好者。阅读详情

我有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循环就太慢了，组合半天

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

...全文

微信小程序转化数据API自归因实战：PHP实现与2025升级要点解析本文详细解析了2025年微信小程序转化数据API自归因的升级要点与PHP实战实现。核心变化包括接口地址更新、固定access_token的获取方式，以及新增timestamp与nonce等安全参数。文章提供了完整的PHP代码示例，帮助开发者高效完成数据上报，优化腾讯广告投放效果。阅读详情

快跑稻草人

C# 111,129 成员 642,539 内容

+ 关注 + 加入社区

切换为时间正序

快跑稻草人 2016-12-06

打赏
举报

引用 25 楼 xuzuning 的回复:

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

版主我关注你很久了

快跑稻草人 2016-12-06

打赏
举报

引用 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();
}

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

xuzuning 2016-12-06

打赏
举报

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

快跑稻草人 2016-12-06

打赏
举报

引用 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))这样可以组合但是没有分隔符

快跑稻草人 2016-12-06

打赏
举报

引用 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以内

快跑稻草人 2016-12-06

打赏
举报

引用 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>>这种类型的，我试了好几次都不行

csdnFUCKINGSUCKS 2016-12-06

打赏
举报



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();

}

SoulRed 2016-12-06

打赏
举报

引用 19 楼 ljaahh 的回复:

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

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

快跑稻草人 2016-12-06

打赏
举报

引用 12 楼 DOwnstairs 的回复:

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

Linq排序在哪里学啊？

快跑稻草人 2016-12-06

打赏
举报

引用 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>>中所有数字组合起来，外层的加一个逗号分隔

_明月 2016-12-06

打赏
举报

引用 16 楼 ducker3590 的回复:

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

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

csdnFUCKINGSUCKS 2016-12-06

打赏
举报

引用 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] 这倒真没什么好的方法反正就是多看不懂的就去查当然嫌麻烦也可以直接翻译一下一般情况下也能看懂个大概

csdnFUCKINGSUCKS 2016-12-06

打赏
举报

引用 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作为数据源去查询

_明月 2016-12-06

打赏
举报

引用 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)

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

_明月 2016-12-06

打赏
举报

引用 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循环来做。至于，是否有那种快速的算法，这个我就不知道了。我对算法不懂。

SoulRed 2016-12-06

打赏
举报

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

快跑稻草人 2016-12-06

打赏
举报

引用 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)

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

threenewbee 2016-12-05

打赏
举报

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

xuzuning 2016-12-05

打赏
举报

怎么可能？

        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 所花费的时间也算在算法里吧？

csdnFUCKINGSUCKS 2016-12-05

打赏
举报

楼主所说的排列组合其实是笛卡尔积排列和组合是分开的概念
下面是笛卡尔积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)

加载更多回复（7）

c#如何进行排列组合

相关推荐