以编程方式生成嵌套for循环

Question

下划线mixin和下面的函数以两种不同的方式完成相同的事情，它们获取数组的所有对。我想知道如何创建一个函数（闭包？），使我能够传递多少个“对”或我想要的数组项目，而不是每次嵌套for loops或range-maps。

getPairs: function(arr){ 
    return _.chain(_.range(arr.length)) 
    .map(function(setOne){ 
    return _.chain(_.range(arr.length)) 
    .map(function(setTwo){ 
     return [ 
     arr[setOne], 
     arr[setTwo], 
     ] 
    }) 
    .value() 
    }) 
    .value() 
} 

function getPairs(arr){ 
    var pairs = [] 
    for(var i = 0; i < arr.length; i++){ 
    for(var p = 0; p < arr.length; p++){ 
     var pair = [ 
     arr[i], 
     arr[p], 
     ] 
     pairs.push() 
    } 
    } 
    return pairs 
} 

Answer 1

有趣的问题。为了得到一个简单的解决方案，我必须考虑一下。事实上，整个事情可以通过两个for循环和一些沉重的数学来完成。下面的代码：

function getGroupings(arr, numPerGroup){ 
    numPerGroup > 1 || (numPerGroup = 2); 
    var groups = Math.pow(arr.length, numPerGroup); 
    var groupings = []; 
    for (var i = 0; i < numPerGroup; i++) { 
     for (var j = 0; j < groups; j++) { 
      groupings[j] || groupings.push(Array(numPerGroup)); 
      var index = Math.floor(j/Math.pow(arr.length, i)) % arr.length; 
      groupings[j][i] = arr[index]; 
      if (i === numPerGroup - 1) groupings[j] = groupings[j].reverse(); 
     } 
    } 
    return groupings; 
} 

上是如何工作的几个注意事项：

• 它一旦运行外`for`循环在内部阵列的每个项目，以及内`for`一次循环为外部数组中的每个项目。倒退，你可能会说。
• 内部`for`循环的工作方式类似于一个二进制时钟，其中（时钟的值）===（我们想要访问的传入数组的索引）。
• 凡Ñ =（传入的阵列的长度）时，将每一次递增时钟在一个人的地方，一个（Ñ^1）个如经常在（Ñ^1） （ n^2）th经常在（ n^2）的位置，等等，直到（ n^num-per-group）的地方。
• 在最后一次迭代中，它颠倒了所有内部数组以实际上最后一个位置，倒数第二位等等......不一定必要，但产生一个更多的预期产出。

例子：

假设你有一个数组，var arr = [3, 6, 9]，和你想的3-- getGroupings(arr, 3);所有可能的分组。组的实际数量为arr.length^3 = 27，因此该函数将生成一个由27个数组组成的数组。

（忽略外部for循环 - 想象它的所有迭代一次发生）二进制时钟从0开始，所以第一个分组是arr[0], arr[0], arr[0] - [3, 3, 3]。

在下一次迭代中，1的位置前进一个 - arr[0], arr[0], arr[1] - [3, 3, 6]，然后[3, 3, 9]。

接下来是3个地方前进的时间和地点重置 - arr[0], arr[1], arr[0]，所以第4组是[3, 6, 3]。等到第27阵列，[9, 9, 9]。

这是JSFiddle。试试看！

Answer 2

由于这个问题是更多的关于算法的实现我使用SWIFT实现它：

// provide 2 parameters, an array and the size of one group of elements 
// [[T]] means an array of an array of type T (placeholder for anything) 
func getPair<T>(array: [T], pairCount: Int) -> [[T]] { 
    if pairCount <= 1 { 
     // puts each element of array in a separate array: 
     // [3, 6, 7] -> [[3], [6], [7]] 
     return array.map{ [$0] } 
    } 
    // returns a flattened array of all possible element combinations 
    // flatMap: array gets mapped to all other possible combinations of one less than pairCount and gets flattened/concatenated 
    // el1: element of the array which can be used in the closure 
    return array.flatMap{ el1 in 
     // smaller pairs are mapped to bigger ones 
     // el2: element of the smaller pairs (one small pair) which can be used in the closure 
     return getPair(array, pairCount - 1).map{ el2 in 
      return [el1] + el2 
     } 
    } 
} 

正如你可以看到这个递归函数的代码行方面非常有效，但在与其他C类似的版本相比，它是2-22（平均：4-6）倍，特别是对于一个大的pairCounts。

这里是另一个版本：

// helper function which "creates" for loops and passes the indexes to a closure which takes an array of indexes 
// indexes = [2, 3, 4] ==> for 4 times { for 3 times { for 2 times {} } } 
// the corresponding passed indexes range from [0, 0, 0] to [2 - 1, 3 - 1, 4 - 1] so you can pass array.count directly 
// therefore the index of the inner for loop can be accessed with passedArray[0] and so on 
func forIndexes(indexes: [Int], closure: [Int] ->()) { 
    if indexes.count == 0 { return } 

    // array which gets passed to the closure and modified over time 
    var currentIndexes = Array(count: indexes.count, repeatedValue: 0) 

    // maximum overall count of inner for loop: [2, 4, 5] => 2*4*5 = 40 
    var count = 1 
    for var i = 0; i < indexes.count; i++ { 
     count *= indexes[i] 
    } 

    for var i = 0; i < count; i++ { 
     // call closure with currentIndexes 
     closure(currentIndexes) 

     // increment first current index and check whether the other ones have to be updated 
     if ++currentIndexes[0] == indexes[0] { 
      // condition: j < indexes.count - 1 => prevent out of bounds exception for: currentIndexes[j+1]++ 
      for var j = 0; j < indexes.count - 1; j++ { 
       if currentIndexes[j] >= indexes[j] { 
        currentIndexes[j] -= indexes[j] 
        currentIndexes[j+1]++ 
       } 
      } 
     } 
    } 
} 

func getPair2<T>(array: [T], pairCount: Int) -> [[T]] { 
    var result = [[T]]() 
    // pair count determines the depth of the nested for loops while array.count specifies the loop count 
    forIndexes(Array(count: pairCount, repeatedValue: array.count), closure: { indexes in 
     // map array elements from all possible indexes 
     result.append(indexes.map{ index in 
      return array[index] 
     }) 
    }) 
    return result 
}