所有可能的数组组合算法（匈牙利语，蛮力）

Question

Got task to resolve (person tracking on computer vision) and i have somehow to get all possible combinations of 2 arrays. Input: two arrays

arr1 = ['a', 'b', 'c'];
arr2 = [1, 2, 3];

Task is to write (probably recursive) algo to output array of all possible combinations like this:

[
  {a:1, b:2, c:3},
  {a:1, b:3, c:2},
  {a:2, b:1, c:3},
  {a:2, b:3, c:1},
  {a:3, b:1, c:2},
  {a:3, b:2, c:1},
]

Input arrays may not be same length. For example

arr1 = [a,b];
arr2 = [1,2,3];
// => 
[
  {a:1, b:2},
  {a:1, b:3},
  {a:2, b:1},
  {a:2, b:3},
  {a:3, b:1},
  {a:3, b:2}
]

Or like this

arr1 = [a,b,c];
arr2 = [1,2];
// => 
[
  {a:1, b:2},
  {a:1, c:2},
  {b:1, a:2},
  {b:1, c:2},
  {c:1, a:2},
  {c:1, b:2}
]

Perfectly would be structure like this

[
  {
    combo: {a:1, b:2, c:3}
  },
  ...
]

...but it doesn't really matter

There are lots of topics here on stackoverflow like this, but all those algos are a bit different and easier. They all give something like this:

[a1, a2, b1, b2, c1, c2]

I've gotten this so far:

const combos = (arr1, arr2, func) => {
    let result = [];
    for(let item1 of arr1){
        let subcombo = {};
        let subArr1 = Object.assign({}, arr1);
        delete subArr1[item1];
        for(let item2 of arr2){
            subcombo[item] = {};
        }
    }
};
function give1() {
    return 1;
}
let arr1 = ['a', 'b', 'c'];
let arr2 = ['x', 'y', 'z'];
const res = combos(arr1, arr2, give1);
console.log(res);

Answer 1

You can first create function to do permutations with limit and then based on the length of keys and values do the permutation of keys if keys.length > values.length otherwise do permutation of values and after that create array of objects from that result.

 function permute(data, len) { let result = [] function generate(data, n, c) { if(!data.length) { result.push(c.slice(0, len)); return; } for(var i = 0; i < data.length; i++) { c[n] = data[i] let copy = [...data] copy.splice(i, 1); generate(copy, n + 1, c) } } generate(data, 0, []) return result; } function f(keys, vals) { let byKeys = keys.length > vals.length, permuted = null if(byKeys) permuted = permute(keys, vals.length); else permuted = permute(vals, keys.length); return permuted.map(arr => arr.reduce((r, e, i) => { byKeys ? r[e] = vals[i] : r[keys[i]] = e return r; }, {})) } console.log(f(['a', 'b', 'c'], [1, 2, 3])) console.log(f(['a', 'b', 'c'], [1, 2])) console.log(f(['a', 'b'], [1, 2, 3]))