69

给定 2 个数组Array1 = {a,b,c...n}Array2 = {10,20,15....x}我如何生成所有可能的组合作为字符串a(i) b(j) c(k) n(p) 其中

1 <= i <= 10,  1 <= j <= 20 , 1 <= k <= 15,  .... 1 <= p <= x

如:

a1 b1 c1 .... n1  
a1 b1 c1..... n2  
......  
......  
a10 b20 c15 nx (last combination)

所以在所有组合的总数=元素的乘积array2 = (10 X 20 X 15 X ..X x)

类似于笛卡尔积,其中第二个数组定义了第一个数组中每个元素的上限。

具有固定数字的示例,

    Array x =  [a,b,c]
    Array y =  [3,2,4] 

所以我们将有 3*2*4 = 24 种组合。结果应该是:

    a1 b1 c1  
    a1 b1 c2  
    a1 b1 c3  
    a1 b1 c4  

    a1 b2 c1  
    a1 b2 c2  
    a1 b2 c3  
    a1 b2 c4


    a2 b1 c1  
    a2 b1 c2  
    a2 b1 c3  
    a2 b1 c4  

    a2 b2 c1  
    a2 b2 c2  
    a2 b2 c3  
    a2 b2 c4


    a3 b1 c1  
    a3 b1 c2  
    a3 b1 c3  
    a3 b1 c4  

    a3 b2 c1  
    a3 b2 c2  
    a3 b2 c3  
    a3 b2 c4 (last)
4

11 回答 11

164

肯定的事。使用 LINQ 执行此操作有点棘手,但肯定可以仅使用标准查询运算符。

更新:这是我 2010 年 6 月 28 日星期一博客的主题;谢谢你的好问题。此外,我博客上的一位评论者指出,有一个比我给出的更优雅的查询。我将在此处更新代码以使用它。

棘手的部分是制作任意多个序列的笛卡尔积。与此相比,字母中的“压缩”是微不足道的。你应该研究这个以确保你理解它是如何工作的。每个部分都很简单,但它们组合在一起的方式需要一些时间来适应:

static IEnumerable<IEnumerable<T>> CartesianProduct<T>(this 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})                          
        );
 }

要解释它是如何工作的,首先要了解“累积”操作在做什么。最简单的累加操作是“将这个序列中的所有内容加在一起”。你这样做的方式是:从零开始。对于序列中的每一项,累加器的当前值等于该项与累加器先前值的总和。我们正在做同样的事情,只是我们不是根据到目前为止的总和和当前项目来累加总和,而是在进行过程中累加笛卡尔积。

我们这样做的方法是利用我们在 LINQ 中已经有一个运算符来计算两件事的笛卡尔积:

from x in xs
from y in ys
do something with each possible (x, y)

通过重复将累加器的笛卡尔积与输入序列中的下一项相乘,并将结果粘贴在一起,我们可以随时生成笛卡尔积。

所以想想累加器的价值。出于说明目的,我将把累加器的值显示为它包含的序列运算符的结果。这不是累加器实际包含的内容。累加器实际上包含的是产生这些结果的运算符。这里的整个操作只是建立了一个庞大的序列运算符树,其结果是笛卡尔积。但是最终的笛卡尔积本身在执行查询之前实际上并没有被计算出来。 出于说明目的,我将展示每个阶段的结果,但请记住,这实际上包含运算符产生这些结果。

假设我们正在取序列序列的笛卡尔积{{1, 2}, {3, 4}, {5, 6}}。累加器以包含一个空序列的序列开始:{ { } }

在第一次累加时,累加器是 { { } },项目是 {1, 2}。我们这样做:

from accseq in accumulator
from item in sequence 
select accseq.Concat(new[] {item})

所以我们取{ { } }with的笛卡尔积{1, 2},并且对于每一对,我们连接:我们有对({ }, 1),所以我们连接{ }{1}得到{1}。我们有对({ }, 2}),所以我们连接{ }{2}得到{2}。因此我们得到{{1}, {2}}了结果。

所以在第二次累加时,累加器是{{1}, {2}},项目是{3, 4}。同样,我们计算这两个序列的笛卡尔积得到:

 {({1}, 3), ({1}, 4), ({2}, 3), ({2}, 4)}

然后从这些项目中,将第二个连接到第一个。所以结果就是{{1, 3}, {1, 4}, {2, 3}, {2, 4}}我们想要的序列。

现在我们再次积累。我们将累加器的笛卡尔积{5, 6}

 {({ 1, 3}, 5), ({1, 3}, 6), ({1, 4}, 5), ...

然后将第二个项目连接到第一个项目以获得:

{{1, 3, 5}, {1, 3, 6}, {1, 4, 5}, {1, 4, 6} ... }

我们完成了。我们已经积累了笛卡尔积。

现在我们有了一个可以取任意多个序列的笛卡尔积的效用函数,剩下的比较容易:

var arr1 = new[] {"a", "b", "c"};
var arr2 = new[] { 3, 2, 4 };
var result = from cpLine in CartesianProduct(
                 from count in arr2 select Enumerable.Range(1, count)) 
             select cpLine.Zip(arr1, (x1, x2) => x2 + x1);

现在我们有一个字符串序列,每行一个字符串序列:

foreach (var line in result)
{
    foreach (var s in line)
        Console.Write(s);
    Console.WriteLine();
}

十分简单!

于 2010-06-23T01:42:05.593 回答
23
using System;
using System.Text;

public static string[] GenerateCombinations(string[] Array1, int[] Array2)
{
    if(Array1 == null) throw new ArgumentNullException("Array1");
    if(Array2 == null) throw new ArgumentNullException("Array2");
    if(Array1.Length != Array2.Length)
        throw new ArgumentException("Must be the same size as Array1.", "Array2");

    if(Array1.Length == 0)
        return new string[0];

    int outputSize = 1;
    var current = new int[Array1.Length];
    for(int i = 0; i < current.Length; ++i)
    {
        if(Array2[i] < 1)
            throw new ArgumentException("Contains invalid values.", "Array2");
        if(Array1[i] == null)
            throw new ArgumentException("Contains null values.", "Array1");
        outputSize *= Array2[i];
        current[i] = 1;
    }

    var result = new string[outputSize];
    for(int i = 0; i < outputSize; ++i)
    {
        var sb = new StringBuilder();
        for(int j = 0; j < current.Length; ++j)
        {
            sb.Append(Array1[j]);
            sb.Append(current[j].ToString());
            if(j != current.Length - 1)
                sb.Append(' ');
        }
        result[i] = sb.ToString();
        int incrementIndex = current.Length - 1;
        while(incrementIndex >= 0 && current[incrementIndex] == Array2[incrementIndex])
        {
                current[incrementIndex] = 1;
                --incrementIndex;
        }
        if(incrementIndex >= 0)
            ++current[incrementIndex];
    }
    return result;
}
于 2010-06-22T14:04:52.797 回答
13

替代解决方案:

第一步:阅读我关于如何生成与上下文相关语法匹配的所有字符串的系列文章:

http://blogs.msdn.com/b/ericlippert/archive/tags/grammars/

第二步:定义一个生成你想要的语言的语法。例如,您可以定义语法:

S: a A b B c C
A: 1 | 2 | 3
B: 1 | 2
C: 1 | 2 | 3 | 4

显然,您可以轻松地从两个数组中生成该语法定义字符串。然后将其输入到生成给定语法中所有字符串的代码中,就完成了;你会得到所有的可能性。(请注意,不一定按照您想要的顺序排列。)

于 2010-06-23T14:45:01.737 回答
3

对于另一个不基于 linq 的解决方案,您可以使用:

public class CartesianProduct<T>
    {
        int[] lengths;
        T[][] arrays;
        public CartesianProduct(params  T[][] arrays)
        {
            lengths = arrays.Select(k => k.Length).ToArray();
            if (lengths.Any(l => l == 0))
                throw new ArgumentException("Zero lenght array unhandled.");
            this.arrays = arrays;
        }
        public IEnumerable<T[]> Get()
        {
            int[] walk = new int[arrays.Length];
            int x = 0;
            yield return walk.Select(k => arrays[x++][k]).ToArray();
            while (Next(walk))
            {
                x = 0;
                yield return walk.Select(k => arrays[x++][k]).ToArray();
            }

        }
        private bool Next(int[] walk)
        {
            int whoIncrement = 0;
            while (whoIncrement < walk.Length)
            {
                if (walk[whoIncrement] < lengths[whoIncrement] - 1)
                {
                    walk[whoIncrement]++;
                    return true;
                }
                else
                {
                    walk[whoIncrement] = 0;
                    whoIncrement++;
                }
            }
            return false;
        }
    }

您可以在此处找到有关如何使用它的示例。

于 2011-08-12T10:51:25.430 回答
3

使用Enumerable.Append.NET Framework 4.7.1 中添加的 ,@EricLippert 的答案可以在每次迭代时不分配新数组的情况下实现:

public static IEnumerable<IEnumerable<T>> CartesianProduct<T>
    (this IEnumerable<IEnumerable<T>> enumerables)
{
    IEnumerable<IEnumerable<T>> Seed() { yield return Enumerable.Empty<T>(); }

    return enumerables.Aggregate(Seed(), (accumulator, enumerable)
        => accumulator.SelectMany(x => enumerable.Select(x.Append)));
}
于 2020-09-18T14:34:49.823 回答
2

我不愿意给你完整的源代码。所以这就是背后的想法。

您可以通过以下方式生成元素:

我假设A=(a1, a2, ..., an)B=(b1, b2, ..., bn)(所以AB每个都持有n元素)。

然后递归执行!编写一个接受 anA和 a的方法B并执行您的操作:

如果Aand Beach 只包含一个元素(称为anresp. bn),只需从 1 迭代到bn并连接an到您的迭代变量。

如果Aand Beach 包含多个元素,则获取第一个元素(a1resp b1),从 1 迭代到bn并为每个迭代步骤执行:

  • 使用从第二个元素(即resp )的A子字段开始递归调用该方法。对于递归调用生成的每个元素, concatenate 、迭代变量和递归调用生成的元素。BA'=(a2, a3, ..., an)B'=(b2, b3, ..., bn)a1

在这里,您可以找到一个关于如何在 C# 中生成事物的类比示例,您“只需”使其适应您的需求。

于 2010-06-22T13:57:32.120 回答
1

如果我做对了,那么您将追求笛卡尔积之类的东西。如果是这种情况,您可以使用 LINQ 执行此操作。可能不是确切的答案,但尝试了解这个想法


    char[] Array1 = { 'a', 'b', 'c' };
    string[] Array2 = { "10", "20", "15" };

    var result = from i in Array1
                 from j in Array2
                   select i + j;

这些文章可能会有所帮助

于 2010-06-22T14:00:24.350 回答
1

finalResult 是所需的数组。假设两个数组的大小相同。

char[] Array1 = { 'a', 'b', 'c' };
int[] Array2 = { 3, 2, 4 };

var finalResult = new List<string>();
finalResult.Add(String.Empty);
for(int i=0; i<Array1.Length; i++)
{
    var tmp = from a in finalResult
              from b in Enumerable.Range(1,Array2[i])
              select String.Format("{0} {1}{2}",a,Array1[i],b).Trim();
    finalResult = tmp.ToList();
}

我认为这就足够了。

于 2010-06-22T15:25:45.200 回答
1

对于另一个不基于 linq 的解决方案,更有效:

static IEnumerable<T[]> CartesianProduct<T>(T[][] arrays) {
    int[] lengths;
    lengths = arrays.Select(a => a.Length).ToArray();
    int Len = arrays.Length;
    int[] inds = new int[Len];
    int Len1 = Len - 1;
    while (inds[0] != lengths[0]) {
        T[] res = new T[Len];
        for (int i = 0; i != Len; i++) {
            res[i] = arrays[i][inds[i]];
        }
        yield return res;
        int j = Len1;
        inds[j]++;
        while (j > 0 && inds[j] == lengths[j]) {
            inds[j--] = 0;
            inds[j]++;
        }
    }
}
于 2015-10-13T15:00:40.253 回答
0

如果有人对笛卡尔积算法的工业、测试和支持实现感兴趣,欢迎您使用现成的Gapotchenko.FX.Math.Combinatorics NuGet 包。

它提供了两种操作模式。基于 LINQ 的流畅模式:

using Gapotchenko.FX.Math.Combinatorics;
using System;

foreach (var i in new[] { "1", "2" }.CrossJoin(new[] { "A", "B", "C" }))
    Console.WriteLine(string.Join(" ", i));

还有一个更详细的显式模式:

using Gapotchenko.FX.Math.Combinatorics;
using System;

var seq1 = new[] { "1", "2" };
var seq2 = new[] { "A", "B", "C" };

foreach (var i in CartesianProduct.Of(seq1, seq2))
    Console.WriteLine(string.Join(" ", i));

两种模式产生相同的结果:

1 A
2 A
1 B
2 B
1 C
2 C

但它比这更进一步。例如,对ValueTuple结果的投影是一个简单的单行:

var results = new[] { 1, 2 }.CrossJoin(new[] { "A", "B" }, ValueTuple.Create);

foreach (var (a, b) in results)
  Console.WriteLine("{0} {1}", a, b);

结果的唯一性可以通过自然的方式实现:

var results = new[] { 1, 1, 2 }.CrossJoin(new[] { "A", "B", "A" }).Distinct();

乍一看,这样的做法会造成组合的过度浪费。所以而不是做

new[] { 1, 1, 2 }.CrossJoin(new[] { "A", "B", "A" }).Distinct()

Distinct()在执行昂贵的乘法之前,它可能对序列更有利:

new[] { 1, 1, 2 }.Distinct().CrossJoin(new[] { "A", "B", "A" }.Distinct())

该软件包提供了一个自动计划生成器,可以优化这些特质。结果,两种方法具有相同的计算复杂度。

包的相应源代码比一个片段可以包含的要大一些,但可以在GitHub 上找到

于 2021-07-28T21:28:42.830 回答
-1

这是一个javascript版本,我相信有人可以转换。它已经过彻底的测试。

这是小提琴

function combinations (Asource){

    var combos = [];
    var temp = [];

    var picker = function (arr, temp_string, collect) {
        if (temp_string.length) {
           collect.push(temp_string);
        }

        for (var i=0; i<arr.length; i++) {
            var arrcopy = arr.slice(0, arr.length);
            var elem = arrcopy.splice(i, 1);

            if (arrcopy.length > 0) {
                picker(arrcopy, temp_string.concat(elem), collect);
            } else {
                collect.push(temp_string.concat(elem));
            }   
        }   
    }

    picker(Asource, temp, combos);

    return combos;

}

var todo = ["a", "b", "c", "d"]; // 5 in this set
var resultingCombos = combinations (todo);
console.log(resultingCombos);
于 2014-03-23T10:15:03.853 回答