how to get all the combination from a group of arrays

Question

I have for example these arrays:

a1 = ["1", "2", "3"];
a2 = ["a", "b"];
a3 = ["q", "w", "e"];

result = ["1aq", "1aw", "1ae", "1bq", "1bw", ... "3be"];

How could obtain this without nested loops (also using jquery, for example)? Thanks

Answer 1

I don't see what's wrong with nested loops, but here is a generic solution:

var a = [a1, a2, a3];

var result = [""]; // start with the empty string,
for (var i=0; i<a.length; i++) { // and repeatedly
        var ai = a[i],
            l = ai.length;
    result = $.map(result, function(r) { // make result a new array of
        var ns = []; // new combinations of
        for (var j=0; j<l; j++) // each of the letters in ai
            ns[j] = r + ai[j]; // and the old results
        return ns;
    }); // using the odds of jQuery.map with returned arrays
}
return result;

Answer 2

No nested loops. Can handle as many arrays as needed.

var result = combine(a1, a2, a3);

function combine() {
    return processArrays([].slice.call(arguments), "", []);

    function processArrays(arrays, str, res) {
        for (var i = 0; i < arrays[0].length; i++) {
            if (arrays.length > 1) {
                processArrays(arrays.slice(1), str + arrays[0][i], res);
            } else {
                res.push(str + arrays[0][i]);
            }
        }
        return res;
    }
}

---

Or a slightly different take on the function:

function combine() {
    return processArrays([].slice.call(arguments), "", []);

    function processArrays(arrays, str, res) {
        if (arrays.length === 0)
            res.push(str)
        else
            for (var i = 0; i < arrays[0].length; i++)
                processArrays(arrays.slice(1), str + arrays[0][i], res);
        return res;
    }
}

---

And here's a no loops version:

var result = combine(a1, a2, a3);

function combine() {
    return processArrays(arguments[0], [].slice.call(arguments, 1), "", []);

    function processArrays(head, tail, str, res) {
        if (head === undefined)
            res.push(str)
        else
            processArray(head[0], head.slice(1), tail, str, res);
        return res;
    }
    function processArray(head, tail, arrays, str, res) {
        if (head) {
            processArrays(arrays[0], arrays.slice(1), str + head, res);
            processArray(tail[0], tail.slice(1), arrays, str, res)
        }
    }
}

Answer 3

A generic recursive solution:

function combine() {
    var target = arguments[0];

    if (arguments.length === 1) {
        return target; // end of chain, just return the array
    }

    var result = [];
    // compute all combinations without the first array
    var combinations = combine.apply(null, Array.prototype.slice.call(arguments, 1));

    // put things together
    for (var i = 0, l = target.length; i < l; i++) {
        var element = target[i];
        for (var j = 0, lj = combinations.length; j < lj; j++) {
            result.push(element + combinations[j]);
        }
    }
    return result;
}

// Usage
var result = combine(a1, a2, a3);

Answer 4

Another generic solution.

var reduce = function(a, b) {
    var r = [];
    $.each(a, function(i, ai) {
        $.each(b, function(j, bj) {
            r.push(ai + bj);
        });
    });
    return r;
};

var result = reduce(reduce(a1, a2), a3);

Answer 5

var outputArray = [];
for(var i = 0, finalLength = a1.length * a2.length * a3.length; i < finalLength; i++) {
   outputArray[i] = a1[i % a1.length].toString() + a2[i % a2.length].toString() + a3[i % a3.length].toString(); 
}

But this is really just a stunt. Why avoid the loops? I can guess: You don't know in advance how many arrays you'll have. But it's still going to be a challenge.