Creating a combination from arrays and turn it into a multi-dimensional permutations in javascript?

Question

Source Arrays:

var arr1 = ["a", "b"];
var arr2 = ["c"];
var arr3 = ["d", "e", "f"];

I can do permutations:(No duplicate)

["a", "c", "d"], 
["b", "c", "d"], 
["b", "c", "e"],
["b", "c", "f"],
["a", "c", "e"],
["a", "c", "f"]

But how can I get the results permutation like?

["a", "c"],
["a", "d"], 
["a", "e"],
["a", "f"],
["b", "c"],
["b", "d"],
["b", "e"],
["b", "f"],
["c", "d"],
["c", "e"],
["c", "f"]

I only got my single array permutation snippet here

var arr3 = ['d', 'e', 'f'];

function permutation (list, n) {
    var results = []
    function _perm (list, n, res, start) {
        if (res.length === n) {
            return results.push(res.join(','))
        }
        if (start === list.length) { return }
        _perm(list, n, res.slice(), start + 1)
        res.push(list[start])
        _perm(list, n, res, start + 1)
    }
    _perm(list, n, [], 0)
    return results
}
console.log(permutation(arr3, 2)) // print ["e,f", "d,f", "d,e"]

Because of the source arrays could be unlimited, I need to combine and permute them at the same time. I would like to know what is the best to achieve like this:

var arr1 = ['a', 'b'];
var arr2 = ['c'];
var arr3 = ['d', 'e', 'f'];
...
var arrN = ['x', 'y', 'z'];

permutation([arr1, arr2, arr3, arr4], 2)
permutation([arr1, arr2, arr3, arr4], 3)
permutation([arr1, arr2, arr3, arr4], 4)

I really appreciate any helps.

Answer 1

You are looking to get the subsets of length N from your selection of arrays, then create the cartesian product of each subset.

// returns power set of arr filtered by length
function powerset(arr, len, pref=[]) {
    if (len == 0) return [pref];
    if (len > arr.length) return [];
    if (len == arr.length) return [pref.concat(arr)]; // premature optimisation
    const next = arr.slice(1);
    return powerset(next, len-1, [...pref, arr[0]]).concat(powerset(next, len, pref));
}
// returns cartesian product of the arrays in the argument
function cartesian(arg) {
    var r = [], max = arg.length-1;
    function helper(arr, i) {
        for (var j=0, l=arg[i].length; j<l; j++) {
            var a = arr.slice(0); // clone arr
            a.push(arg[i][j]);
            if (i==max)
                r.push(a);
            else
                helper(a, i+1);
        }
    }
    helper([], 0);
    return r;
}

var arrays = [
  ['a', 'b'],
  ['c'],
  ['d', 'e', 'f'],
  ['x', 'y', 'z']
];
console.log(powerset(arrays, 2).flatMap(cartesian));
console.log(powerset(arrays, 3).flatMap(cartesian));
console.log(powerset(arrays, 4).flatMap(cartesian));

Answer 2

here is the code without eval

var arr1 = ['a', 'b'];
var arr2 = ['c'];
var arr3 = ['d', 'e', 'f'];
var arr4 = ['x', 'y', 'z'];

comb=[arr1,arr2,arr3,arr4]
conc=comb.flat()
resx=[]
  function permut(){ // number of arrays
        for(let i=0;i<conc.length;i++){
          for(let j=i+1;j<conc.length;j++){
             b=[conc[i],conc[j]]
               comb.forEach(x=>{
                 if (x.includes(conc[i]) && !x.includes(conc[j])) resx.push(b)

              })
          }
        }
  }
  permut()
console.log(resx)