相关疑难解决方法(0)

您将如何在JavaScript中实现多个数组的笛卡尔积？

举个例子,

cartesian([1, 2], [10, 20], [100, 200, 300]) 

如何在N个可变长度的JavaScript数组中生成所有值的组合？

假设我有N个JavaScript数组,例如

var first = ['a', 'b', 'c', 'd'];
var second = ['e'];
var third =  ['f', 'g', 'h', 'i', 'j'];

(在这个例子中有三个数组,但它有N个数组用于解决问题.)

我想输出它们的所有值的组合,以产生

aef
aeg
aeh
aei
aej
bef
beg
....
dej

编辑:这是我工作的版本,使用ffriend接受的答案作为基础.

var allArrays = [['a', 'b'], ['c', 'z'], ['d', 'e', 'f']];

 function allPossibleCases(arr) {
  if (arr.length === 0) {
    return [];
  } 
else if (arr.length ===1){
return arr[0];
}
else {
    var result = [];
    var allCasesOfRest = allPossibleCases(arr.slice(1));  // recur with the rest of array
    for (var …

我试图找到这样的2个数组的每个排列：

// input
lowerWords = ['one', 'two', 'three' ] 
upperWords = [ 'ONE', 'TWO', 'THREE' ]

// output
keywords = {
  'one two three': true,
  'ONE two three': true,
  'ONE TWO three': true,
  'ONE TWO THREE': true,
  'ONE two THREE': true,
  'one TWO three': true,
  'one two THREE': true,
  'one TWO THREE': true,
}

它应具有3个以上的项目，两个数组的长度始终相同。这是我的代码：

const keywords = {}
const lowerWords = ['one', 'two', 'three' ] 
const upperWords = [ 'ONE', 'TWO', 'THREE' ]
const wordCount = lowerWords.length

let currentWord …

我需要调用以下函数cross4次,对于x和y变量的所有排列,值为1和-1;

我的方法:

var p = [-1, 1];

p.forEach(function(x) {
  p.forEach(function(y) {
    cross(x, y);
  });
});

有没有更短的方法这样做？

给定以下数组:

const array1 = ["a1", "b1", "c1", "d1"],
      array2 = ["a2", "b2"],
      array3 = ["a3", "b3", "c3"]

是否有任何ramda函数来简化我可以给出一个或多个数组的以下场景？

const nestedMap = map => {
    const result = []

    for(let item1 of array1) 
        for(let item2 of array2)
            for(let item3 of array3)
                    result.push(map(item1, item2, item3))
    return result
}

整个功能如下:

// Sample usage
nestedMap((item1, item2, item3) => `${item1} ${item2} ${item3}`, array1, array2, array3)

我希望避免重新发明轮子.

^{注意:Vanilla javascript或任何其他库都可以接受.我最初谈到ramda,因为它有很多功能,也许我错过了哪些可以帮助解决这个问题}

尽管阅读了很多关于排列/组合的Q/A:查找JavaScript数组值的所有组合 + JavaScript - 从具有m个元素的n个数组生成组合我还没有找到正确的方法来获得我正在寻找的那种结果.我有一个10值数组:

var arr = [0,1,2,3,4,5,6,7,8,9];

如果我是对的,所有可能的唯一值的置换数组(没有重复)的数量:

[5,9,1,8,2,6,7,0,4,3] [4,8,0,2,1,9,7,3,6,5] ...

是2x3x4x5x6x7x8x9x10 = 3628800

我正在尝试生成一个动态创建'n'数组的函数.例如:

function createArray(0) -> [0,1,2,3,4,5,6,7,8,9]
function createArray(45648) -> [0,1,5,3,2,8,7,9,6] (something like...)
function createArray(3628800) -> [9,8,7,6,5,4,3,2,1,0]

我想要实现它的方式是:

• createArray(1)置换最后2个符号(8,9 - > 9,8)

• createArray(2-> 6)置换最后3个符号(8,7,9 - > 9,8,7)

• createArray(3628800):所有值都被置换(9-> 0)

你认为这可行/容易吗？如果是的话怎么办？

[编辑]

谢谢你的回答

function permute(permutation, val) {

  var length = permutation.length,
  result = [permutation.slice()],
  c = new Array(length).fill(0),
  i = 1, k, p,
  n = 0;
  while (i < length) {
  if (c[i] < i) …

给定

[
  ["blue", "red"],
  [1, 2],
  [true, false],
]

如何在javascript中获得可能的组合？：

blue, 1, true
blue, 1, false
blue, 2, true
blue, 2, false
red, 1, true
red, 1, false
red, 2, true
red, 2, false

顺序无关紧要。

试图将无限数量的对象数组转换为矩阵.

height: [1,3,4,5,6,7]
weight: [23,30,40,50,90,100]

成

1 23
1 30
1 40
1 50
...
3 23
3 30
3 40
...

基本上将所有可能的组合映射到矩阵中

我尝试使用underscore.js中的一些函数来解决问题

                var firstOption = _.first( productOptionKeys );
                $.each( productOptions[ firstOption ].split(","), function(index, value){
                    var matrixRow = [];
                    var matricableOptionKeys = _.reject( productOptionKeys, function(option){ return (option == firstOption); }  );

                    matrixRow.push( value );

                    $.each( matricableOptionKeys, function( index, value ){
                        var matricableOptions = productOptions[ value ].split(",");
                        var matricIndex = 0;
                        for( i=0 ; i<matricableOptions.length; i++ ){
                            matrixRow.push( matricableOptions[ matricIndex …