Question

我想在数组的单个元素中计算笛卡尔积。一次只能有2个值所以如果我的数组是：

[["cat dog mouse"], ["blue red green"]]

预期值为：

猫，狗
猫，老鼠
狗，老鼠
蓝色，红色
蓝色，绿色
红色，绿色

这是我的错误方法：

var arr = [["cat dog mouse"], ["blue red green"], ["apple orange banana"]];

for (i = 0; i < arr.length; i++) {
    for(j = 0; j < arr[i].length; j++){
        if(j >= arr[i].length){
            console.log(arr[i][j].split( " ")  + " "  + arr[i][0])
        }else{
            console.log(arr[i][j].split( " ")  + " "  + arr[i][j+1])
        }
    }
}

它给了我

cat，dog，mouse undefined
蓝色，红色，绿色未定义

Answer 1

您可以使用 split() 和 for 循环

执行此类操作

var arr = [
  ["cat dog mouse"],
  ["blue red green"],
  ["apple orange banana"]
];

// iterate the array
for (i = 0; i < arr.length; i++) {
  // split the string 
  var inArr = arr[i][0].split(' ');
  // iterate the splitted string  array
  for (j = 0; j < inArr.length - 1; j++) {
    // iterate string next to current string
    for (k = j + 1; k < inArr.length; k++)
      // generate the output
      console.log(inArr[j] + ', ' + inArr[k]);
  }
}

Answer 2

你很亲密，一些修改过的代码

var arr = [["cat dog mouse"], ["blue red green"], ["apple orange banana"]];

for (i = 0; i < arr.length; i++) {
    var items = arr[i][0].split(" ")
    for (j = 0; j < items.length - 1; j++) {
        for (k = j+1; k < items.length; k++) {
            console.log(items[j], items[k])
        }
    }
}

结果：

cat dog
cat mouse
dog mouse
blue red
blue green
red green
apple orange
apple banana
orange banana

Answer 3

[["cat dog mouse"], ["blue red green"]].forEach(function (item) {
    item.forEach(function (value) {
         var arr = value.split(' ');
         var hash = {};
         arr.forEach(function (firstItem) {
              arr.forEach(function (secondItem) {
                  if (firstItem !== secondItem && !hash[firstItem + secondItem] && !hash[secondItem + firstItem]) {
                      console.log(firstItem + ', ' + secondItem);
                      hash[firstItem+secondItem] = true;
                  }
              });
         })
    });
});

Answer 4

A solution splited in partial solutions, one for the arrays and one for the combination without repeat.

function combine(array, length) {
    function c(l, r) {
        var ll = l.slice();
            if (r.length === length) {
            result.push(r);
            return;
        }
        while (ll.length) {
            c(ll, r.concat(ll.shift()));
        }
    }
    var result = [];
    c(array, []);
    return result;
}

function get(array) {
    return array.map(function (a) {
        return combine(a[0].split(' '), 2);
    });
}

var result = get([["cat dog mouse"], ["blue red green"], ["apple orange banana"]]);
document.write('<pre>' + JSON.stringify(result, 0, 4) + '</pre>');

Answer 5

您可以功能方式，只需使用 .map（）和 .forEach（）方法：

var arr = [["cat dog mouse"], ["blue red green"], ["apple orange banana"]];


function print(item){
  //If there is one last item we stop the process
  if (item.length <= 1) return;
  else {
    //Retrieve head of our stack and shift the first item
    const head = item.shift();
    item.forEach((elm) => console.log(head + ',' + elm));
    // call our recursive function with the new array
    return print(item);
  }
}

function combine(arr){
  //Return array splited by using .map and .split operations, then iterate by using forEach and call our
  // recursive function
  arr
    .map((array) => array[0].split(' '))
    .forEach((value) => print(value));
}

combine(arr);

您可以查看 Plunker

计算1个数组中元素的笛卡尔积

5 个答案: