js二维数组如何横向穷举？

Question

假设有一个二维数组：
let arr = [
['1','2','3'],
['a','b','c'],
]
怎么样才可以实现"横向的穷举"，不知道我的描述是否准确，结果如下：
['1','2','3'],
['1','b','3'],
['1','2','c'],
['a','2','3'],
['a','b','3'],
['a','b','c'],

想要的效果是：结果中的数组，是不会出现原数组的同一个下标的数据，比如:1 和 a 不会在同一个结果数组中出现，同理，2&b,3&c也是如此

Answer 1

我理解一下题目：
二维数组 arr 每一行长度相等，求每一列对应字符的全排列

全排列用递归：

const matrix = [
  ['a', 'b', 'c'],
  ['1', '2', '3']
]


// 输入新字符和已有排列, 返回新排列
const fn = (resultArr, matrix, index = 0) => {
  if (index >= matrix[0].length) return resultArr
  const newResult = []
  resultArr.forEach(arr => {
    matrix.forEach(row => {
      newResult.push([...arr, row[index]])
    })
  })
  return fn(newResult, matrix, index + 1)
}

console.log(fn([''], matrix))

输出：

[
  [ 'a', 'b', 'c' ],
  [ 'a', 'b', '3' ],
  [ 'a', '2', 'c' ],
  [ 'a', '2', '3' ],
  [ '1', 'b', 'c' ],
  [ '1', 'b', '3' ],
  [ '1', '2', 'c' ],
  [ '1', '2', '3' ]
]

Answer 2

let aArr = ['a', 'b', 'c'];
let bArr = ['1', '2', '3'];

function HorizonArr(aArr, bArr) {
  return aArr.reduce((resultA, itemA, indexA) => {
    resultA.push(bArr.reduce((resultB, itemB, indexB) => {
      indexA !== indexB && resultB.push(itemB)
      return resultB
    }, []).concat(itemA))
    return resultA
  }, [])
}

console.log([aArr,bArr,...HorizonArr(aArr, bArr),...HorizonArr(bArr,aArr)]);
/**
[ [ 'a', 'b', 'c' ],
  [ '1', '2', '3' ],
  [ '2', '3', 'a' ],
  [ '1', '3', 'b' ],
  [ '1', '2', 'c' ],
  [ 'b', 'c', '1' ],
  [ 'a', 'c', '2' ],
  [ 'a', 'b', '3' ] ]
*/

Answer 3

    let arr = [
      [1,   2,    3],
      ["a", "b", "c"]
    ]
    function transformArr(arr){
      let row = arr.length; //2
      let column = arr[0].length; //3
      let num = row ** column;  //8组
      let columnArr = [];// 原数组arr每列的每个元素应该连续出现几次。比如a每四次出现一次；b每两次出现一次。
      for(let i = 1; i <= column; i++){
        columnArr[i-1] = row ** (column-i)
      }
      let resultArr = [];
      for(let i = 0; i < column; i ++){//遍历列
        for(let j = 0; j < num; j++){//遍历行
          if(!Array.isArray(resultArr[j])){
            resultArr[j] = [];
          }
          let index = Math.floor(j/columnArr[i]) % row;
          resultArr[j][i] = arr[index][i];
        }
      }
      console.log(resultArr);
    }
    transformArr(arr);

同时也测试了：

    let arr = [
      [1,   2,    3],
      ["a", "b", "c"],
      ["x", "z", "y"]
    ]

结果：

1.  0: (3) [1, 2, 3]
2.  1: (3) [1, 2, "c"]
3.  2: (3) [1, 2, "y"]
4.  3: (3) [1, "b", 3]
5.  4: (3) [1, "b", "c"]
6.  5: (3) [1, "b", "y"]
7.  6: (3) [1, "z", 3]
8.  7: (3) [1, "z", "c"]
9.  8: (3) [1, "z", "y"]
10.  9: (3) ["a", 2, 3]
11.  10: (3) ["a", 2, "c"]
12.  11: (3) ["a", 2, "y"]
13.  12: (3) ["a", "b", 3]
14.  13: (3) ["a", "b", "c"]
15.  14: (3) ["a", "b", "y"]
16.  15: (3) ["a", "z", 3]
17.  16: (3) ["a", "z", "c"]
18.  17: (3) ["a", "z", "y"]
19.  18: (3) ["x", 2, 3]
20.  19: (3) ["x", 2, "c"]
21.  20: (3) ["x", 2, "y"]
22.  21: (3) ["x", "b", 3]
23.  22: (3) ["x", "b", "c"]
24.  23: (3) ["x", "b", "y"]
25.  24: (3) ["x", "z", 3]
26.  25: (3) ["x", "z", "c"]
27.  26: (3) ["x", "z", "y"]

测试了：

    let arr = [
      [1,   2,    3,  4],
      ["a", "b", "c", "d"]
    ]

结果：

1.  0: (4) [1, 2, 3, 4]
2.  1: (4) [1, 2, 3, "d"]
3.  2: (4) [1, 2, "c", 4]
4.  3: (4) [1, 2, "c", "d"]
5.  4: (4) [1, "b", 3, 4]
6.  5: (4) [1, "b", 3, "d"]
7.  6: (4) [1, "b", "c", 4]
8.  7: (4) [1, "b", "c", "d"]
9.  8: (4) ["a", 2, 3, 4]
10.  9: (4) ["a", 2, 3, "d"]
11.  10: (4) ["a", 2, "c", 4]
12.  11: (4) ["a", 2, "c", "d"]
13.  12: (4) ["a", "b", 3, 4]
14.  13: (4) ["a", "b", 3, "d"]
15.  14: (4) ["a", "b", "c", 4]
16.  15: (4) ["a", "b", "c", "d"]

Answer 4

就是组合吧。
['1', 'a']，['2', 'b'], ['3', 'c']每组各抽取一个出来得到结果。

结果：

[
    ["1","2","3"],
    ["a","2","3"],
    ["1","b","3"],
    ["a","b","3"],
    ["1","2","c"],
    ["a","2","c"],
    ["1","b","c"],
    ["a","b","c"]
]

具体可看https://wintc.top/article/17