Question

我想解决的问题是我想生成一个数组，它表示源数组中所有元素的组合。

如果输入2个项目，则有4种组合（此处表示为二进制）

第1组| 0 | 1 | 0 | 1
  第2组| 0 | 0 | 1 | 1
  --------------------------
  ＆amp;结果| 0 | 1 | 2 | 3

这可以推广，因此组合的数量是2 ^（组数）（所以3组有8种组合，4种有16种等）。

所以问题是;给出一个javascript数组：

var groups = [
{
    name:"group1",
    bit: 1
},
{
    name:"group2",
    bit: 2
},
{
    name:"group3",
    bit: 4
}];

我需要生成一个数组，其中索引表示bit属性的值，并且数组的值是任意的（进一步计算 - 不相关）所以我们只需要使它成为一个数组组名（为了这个问题的目的）。这个结果是可取的：

var result = [
    {groups: []}, //0 
    {groups: ["group1"]}, //1
    {groups: ["group2"]},  //2
    {groups: ["group1","group2"]}, //3
    {groups: ["group3"]}, //4
    {groups: ["group1","group3"]}, //5
    {groups: ["group2","group3"]}, //6
    {groups: ["group1","group2","group3"]} //7
]

您可以在评论中看到数组中的每个索引都代表了原始bit属性的行为。

我准备了一个jsfiddle的输入和必需的输出，如果它对回答问题很有帮助。

This is my current solution，基于mellamokb's answer，但以我的首选格式重写。我希望有一个更优雅的解决方案，因为这在阵列上有很多迭代，这是不必要的。有更好的解决方案吗？

var resultCount = Math.pow(2,groups.length);
var result = [];
for(var i=0;i<resultCount;i++){
    result.push({
        groups: $.map(groups, function(e,idx){ 
           return  ((i & Math.pow(2,idx)) != 0)
               ? e.name
               : null
        })
    });
}

Answer 1

这是一个相对有效的解决方案，它通过索引构建数组：

var result = [];
var resultCount = Math.pow(2, groups.length);

for (var i = 0; i < resultCount; i++) {
    result[i] = { groups: [] };
    for (var g = 0; g < groups.length; g++) {
        if (i & groups[g].bit) result[i].groups.push(groups[g].name);
    }
}

演示：http://jsfiddle.net/7ZsHL/9/

Answer 2

我认为你可以做到这一点，而不必存储位，什么不存储。

var groups = [
    "group1",
    "group2",
    "group3",
    "group4"
];

var output = [];
for (var i = 0; i < Math.pow(2, groups.length); i++) {
    var arr = [];
    output.push(arr);
    for (var j = 0; j < groups.length; j++) {
        if (i & (Math.pow(2, j))) {
            arr.push(groups[j]);
        } else {
            arr.push(0);
        }
    }
}

Answer 3

我喜欢别人做过的事情，但在这样的情况下，我可能会选择在我的代码中使用一点点动词，因为算法的意图难以沟通。

An Update Of Your Fiddle

var groups = [
    {
        name:"group1",
        bit: 1
    },
    {
        name:"group2",
        bit: 2
    },
    {
        name:"group3",
        bit: 4
    }];

function parseIterations(groups){
    var aIterations = [];
    var aBits = [];
    var iGroups = groups.length;
    var iTotalIterations = Math.pow(2, iGroups);
    for (var i = 0; i < iTotalIterations; i++) {
        var oIteration = { groups: [] };
        for (var j = 0; j < iGroups; j++) {
            if (typeof aBits[j] == 'undefined')
                aBits[j] = true;
            // while you could infer the .bit value from j, 
            // i've chosen to use your .bit value here.
            aBits[j] = (i % groups[j].bit == 0) ? !aBits[j] : aBits[j];
            if (aBits[j])
                oIteration.groups.push(groups[j].name);
        }
        aIterations[i] = oIteration;
    }
    return aIterations;
}

var result = parseIterations(groups);

查找数组中元素的所有组合

3 个答案: