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

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

给定2项输入，有4种组合（此处表示为二进制）

第一组| 0 | 1 | 0 | 1
第2组| 0 | 0 | 1 | 1
--------------------------
&结果| 0 | 1 | 2 | 3

这可以概括为组合数为2（组数）（3个组有8个组合，4个组有16个组合等）

所以问题是,；给定一个javascript数组：

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

我需要生成一个数组，其中索引表示

位

属性的and'ing，数组的值是任意的（进一步计算-不相关），因此让我们将其作为组名的数组（用于此问题）。这一结果是可取的：

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
]

您可以在那里的注释中看到，数组中的每个索引都表示将

位

属性与原始属性进行and'运算

我已经准备了一份报告，其中包含了在回答问题时有用的输入和所需的输出

---

，基于，但以我喜欢的风格重新编写。我希望有一个更优雅的解决方案，因为它在数组上有很多不必要的迭代。有更好的解决办法吗

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

var resultCount=Math.pow（2，groups.length）；
var结果=[]；
对于（var i=0；i，这里有一个相对有效的解决方案，它通过索引构建数组：

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

var结果=[]；
var resultCount=Math.pow（2，groups.length）；
对于（变量i=0；i

演示：
这里有一个相对有效的解决方案，它通过索引构建阵列：

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

var结果=[]；
var resultCount=Math.pow（2，groups.length）；
对于（变量i=0；i

演示：
我想你不需要存储位之类的东西就可以完成

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

var组=[
“第一组”，
“第二组”，
“第三组”，
“第4组”
];
var输出=[]；
for（var i=0；i
我想你不需要存储位之类的东西就可以做到

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

var组=[
“第一组”，
“第二组”，
“第三组”，
“第4组”
];
var输出=[]；
for（var i=0；i
我喜欢其他人所做的事情，但在这种情况下，我可能会选择在代码中有点冗长，因为算法的意图很难传达


var组=[
{
名称：“组1”，
比特：1
},
{
名称：“组2”，
比特：2
},
{
名称：“组3”，
比特：4
}];
函数解析迭代（组）{
var-aIterations=[]；
var aBits=[]；
var iGroups=groups.length；
变量Itotalitations=Math.pow（2，i组）；
对于（var i=0；i
我喜欢其他人所做的事情，但在这种情况下，我可能会选择在代码中有点冗长，因为算法的意图很难传达


var组=[
{
名称：“组1”，
比特：1
},
{
名称：“组2”，
比特：2
},
{
名称：“组3”，
比特：4
}];
函数解析迭代（组）{
var-aIterations=[]；
var aBits=[]；
var iGroups=groups.length；
变量Itotalitations=Math.pow（2，i组）；
对于（var i=0；i
解决方案是否需要考虑性能？您预期的最大输入组数量是多少？实际中最大的输入组数量是4个（因此16个组合）.事实上，我会小心谨慎，希望会有6.你能解释一下哪些迭代是不必要的吗？我不明白你怎么能把问题减少到小于（长度^3）如果要枚举所有可能性，则进行迭代。@tau-唯一不必要的组合是反向组合。所有组合都是必需的。解决方案是否需要担心性能？您预期的最大输入组数是多少？实际中最大的组数是多少