Question

我有以下对象

var mapping = {
    0: ['A','B','C'],
    1: ['D','E','F'],
    2: ['G', 'H', 'I'],
    ---
    ---

    9: ['X','Z']
}

有一个函数引用上面的对象并找到所有可能的组合。例如，我们有

function combination(value){}
combination([1,0]); // DA, DB, DC, EA, EB, EC, FA, FB, FC

所以在上面的调用中，＆＃34; 1＆＃34;和＆＃34; 0＆＃34;将引用地图对象，并返回这两者的所有可能组合。

我认为解决这个问题的最佳方法是使用递归，但我似乎无法绕过这个

Answer 1

不仅仅是递归，你可以使用多个for循环来实现这个

for (var i = 0 ; i < mapping[index1].length ; i++)
{
    for (var j = 0 ; j < mapping[index2].length ; j++)
    {
        resultArray.push(mapping[i][j]);
    }
}

这里resultArray是输出数组，index1，index2是传递的索引

Answer 2

足够近：

＆＃13;

app.get('/admin-page', isAdmin, function(req, res) {
    res.render('admin', {         //'admin' is your admin template
        user : req.user 
       // or any other data you want to render! 
    });
});

＆＃13;

Answer 3

要找到所有可能的组合，我们必须遍历映射对象以及与给定键对应的数组，这里我创建两个函数combination，它将迭代映射对象键和map将迭代对应于每个给定键的数组：

var mapping = {
0: ['A','B','C'],
1: ['D','E','F'],
2: ['G', 'H', 'I'],
3: ['J', 'K', 'L'],
4: ['M', 'N', 'O']
}

var resultArray = [];

function combination(x){
 for(var i=0;i<x.length;i++){
    for(var j=i+1;j<x.length;j++){
        map(x[i],x[j])
    }
  }
 }
function map(index1,index2){


for (var i in mapping[index1])
{
    if(mapping[index1].hasOwnProperty(i)){
        for (var j in mapping[index2])
        {
            if(mapping[index2].hasOwnProperty(j)){
                resultArray.push(mapping[index1][i]+''+mapping[index2][j]);    
            }

        }        
    }

  }    
}


combination([0,2,1,4])
console.log(resultArray);

Answer 4

您可以使用递归来解决此问题只需遍历索引，并尝试递归添加每个相应的项目。

我为你实现了一个有效的JS函数：

function combination(o) { // just a wrapper for convenient usage
  var current = [];

  function step() { // recursive function
    if (current.length === o.indices.length) { // combination is ready
      o.callback(current); // callback
      return; // and leave recursion
    }

    // current.length is a current position (0, 1, 2, 3 etc.) for which we find a value
    // o.indices[o.current.length] is an index of mapping for current position (0, 2, 2, 1 in a demo below)
    // o.mapping[o.indices[o.current.length]] is simply a row 

    o.mapping[o.indices[current.length]].forEach(function(x) {
      current.push(x);
      step();
      current.pop();
    });
  }

  step(); // start recursion
}

你可以这样使用它：

combination({
  mapping: { // your mapping
    0: ['A', 'B', 'C'],
    1: ['D', 'E', 'F'],
    2: ['G', 'H', 'I']
  },
  indices: [0, 2, 2, 1], // indices may repeat
  callback: function(x) { // callback will be called every time we find a combination 
    document.body.innerHTML += x + "<br/>"; // x is an array
  }
});

这是working JSFiddle demo。

Answer 5

以下是使用递归的解决方案。

它会DFS (Depth First Traversal )找到与输入数组对应的所有长度路径。

对于每次潜水到下一级别，使用slice(1)缩短数组。原始数组未被修改，模式重复。当数组中没有更多元素时，将打印路径。

我添加了一个计数来查看生成了多少组合。计数应该是初始输入数组中所有数组长度的乘积。这是用于输入数组[2,0,3,7]的片段，产品是3 * 3 * 4 * 3 = 108，即108种组合。

基本上描绘了一个树，其中第一级节点包含所有mapping[2]个元素，每个元素都有mapping[0]个子级别为树的2级，每个级别2都有mapping[3]个元素3级和最后mapping[7]的孩子将组成树的叶节点。这可以根据您的输入数组和映射配置进入任何级别。

下面的代码对上面的树进行递归遍历，每次从根到每个叶节点并打印出该路径。

＆＃13;

var mapping = {
    0: ['0A','0B','0C'],
    1: ['1A','1B','1C'],
    2: ['2A','2B','2C'],
    3: ['3A','3B','3C', '3D'],
    4: ['4A','4B','4C'],
    5: ['5A','5B','5C'],
    6: ['6A','6B','6C'],
    7: ['7A','7B','7C']
     
}

var count = 0;

function traverse(arr, comb) {
     if(!arr.length) {
        console.log(++count + " : " + comb+"\n"); 
        return; 
      } 
      for(var j =0; j < mapping[arr[0]].length; j++) 
         traverse(arr.slice(1), comb + " " +  mapping[arr[0]][j]);
}

traverse([2,0,3,7],"");

＆＃13;

找到mutliple数组中每个元素的所有组合

5 个答案: