How can I create every combination possible for the contents of two arrays?

Question

I have two arrays:

var array1 = ["A", "B", "C"];
var array2 = ["1", "2", "3"];

How can I set another array to contain every combination of the above, so that:

var combos = ["A1", "A2", "A3", "B1", "B2", "B3", "C1", "C2", "C3"];

Keef

If you’re looking for a general approach to cartesian products, i.e. [ [ "A", "1" ], [ "A", "2" ],…, [ "C", "3" ] ], see Cartesian product of multiple arrays in JavaScript. – Osbourn

Answer 1

A loop of this form

combos = [] //or combos = new Array(2);

for(var i = 0; i < array1.length; i++)
{
     for(var j = 0; j < array2.length; j++)
     {
        //you would access the element of the array as array1[i] and array2[j]
        //create and array with as many elements as the number of arrays you are to combine
        //add them in
        //you could have as many dimensions as you need
        combos.push(array1[i] + array2[j])
     }
}

Carding

i cant do this with .map , any idea why? – Alyssaalyssum

Not exactly sure what you’re attempting to do, but maybe flatMap is what you need? Can you give more info? – Carding

Answer 2

Just in case anyone is looking for Array.map solution

var array1=["A","B","C"];

var array2=["1","2","3","4"];

console.log(array1.flatMap(d => array2.map(v => d + v)))

Intracutaneous

one thing to note is that flatMap is not supported by IE, otherwise this looks like a clean solution – Caterpillar

Answer 3

Or if you'd like to create combinations with an arbitrary number of arrays of arbitrary sizes...(I'm sure you can do this recursively, but since this isn't a job interview, I'm instead using an iterative "odometer" for this...it increments a "number" with each digit a "base-n" digit based on the length of each array)...for example...

combineArrays([ ["A","B","C"],
                ["+", "-", "*", "/"],
                ["1","2"] ] )

...returns...

[
   "A+1","A+2","A-1", "A-2",
   "A*1", "A*2", "A/1", "A/2", 
   "B+1","B+2","B-1", "B-2",
   "B*1", "B*2", "B/1", "B/2", 
   "C+1","C+2","C-1", "C-2",
   "C*1", "C*2", "C/1", "C/2"
]

...each of these corresponding to an "odometer" value that picks an index from each array...

[0,0,0], [0,0,1], [0,1,0], [0,1,1]
[0,2,0], [0,2,1], [0,3,0], [0,3,1]
[1,0,0], [1,0,1], [1,1,0], [1,1,1]
[1,2,0], [1,2,1], [1,3,0], [1,3,1]
[2,0,0], [2,0,1], [2,1,0], [2,1,1]
[2,2,0], [2,2,1], [2,3,0], [2,3,1]

The "odometer" method allows you to easily generate the type of output you want, not just the concatenated strings like we have here. Besides that, by avoiding recursion we avoid the possibility of -- dare I say it? -- a stack overflow...

function combineArrays( array_of_arrays ){

    // First, handle some degenerate cases...

    if( ! array_of_arrays ){
        // Or maybe we should toss an exception...?
        return [];
    }

    if( ! Array.isArray( array_of_arrays ) ){
        // Or maybe we should toss an exception...?
        return [];
    }

    if( array_of_arrays.length == 0 ){
        return [];
    }

    for( let i = 0 ; i < array_of_arrays.length; i++ ){
        if( ! Array.isArray(array_of_arrays[i]) || array_of_arrays[i].length == 0 ){
            // If any of the arrays in array_of_arrays are not arrays or zero-length, return an empty array...
            return [];
        }
    }

    // Done with degenerate cases...

    // Start "odometer" with a 0 for each array in array_of_arrays.
    let odometer = new Array( array_of_arrays.length );
    odometer.fill( 0 ); 

    let output = [];

    let newCombination = formCombination( odometer, array_of_arrays );

    output.push( newCombination );

    while ( odometer_increment( odometer, array_of_arrays ) ){
        newCombination = formCombination( odometer, array_of_arrays );
        output.push( newCombination );
    }

    return output;
}/* combineArrays() */


// Translate "odometer" to combinations from array_of_arrays
function formCombination( odometer, array_of_arrays ){
    // In Imperative Programmingese (i.e., English):
    // let s_output = "";
    // for( let i=0; i < odometer.length; i++ ){
    //    s_output += "" + array_of_arrays[i][odometer[i]]; 
    // }
    // return s_output;

    // In Functional Programmingese (Henny Youngman one-liner):
    return odometer.reduce(
      function(accumulator, odometer_value, odometer_index){
        return "" + accumulator + array_of_arrays[odometer_index][odometer_value];
      },
      ""
    );
}/* formCombination() */

function odometer_increment( odometer, array_of_arrays ){

    // Basically, work you way from the rightmost digit of the "odometer"...
    // if you're able to increment without cycling that digit back to zero,
    // you're all done, otherwise, cycle that digit to zero and go one digit to the
    // left, and begin again until you're able to increment a digit
    // without cycling it...simple, huh...?

    for( let i_odometer_digit = odometer.length-1; i_odometer_digit >=0; i_odometer_digit-- ){ 

        let maxee = array_of_arrays[i_odometer_digit].length - 1;         

        if( odometer[i_odometer_digit] + 1 <= maxee ){
            // increment, and you're done...
            odometer[i_odometer_digit]++;
            return true;
        }
        else{
            if( i_odometer_digit - 1 < 0 ){
                // No more digits left to increment, end of the line...
                return false;
            }
            else{
                // Can't increment this digit, cycle it to zero and continue
                // the loop to go over to the next digit...
                odometer[i_odometer_digit]=0;
                continue;
            }
        }
    }/* for( let odometer_digit = odometer.length-1; odometer_digit >=0; odometer_digit-- ) */

}/* odometer_increment() */

Beltane

Wow this is brilliant and exactly what I needed. A function to create all possible combinations between variable number of arrays each containing variable number of elements. – Crambo

You're a genius. Literally just saved my life. This should be the accepted answer because it covers the OPs situation plus any others. – Trisa

Brilliantly solved, I had twisted my brain for hours and couldn't come up with anything close to this. I extended your version to allow prefixing each array's value with a custom name by adding a new parameter array_prefixes as last parameter in the function calls and then using return accumulator + ' ' + array_prefixes[odometer_index] + ': ' + array_of_arrays[odometer_index][odometer_value]; to add the name before each value. – Lowboy

Answer 4

Seeing a lot of for loops in all of the answers...

Here's a recursive solution I came up with that will find all combinations of N number of arrays by taking 1 element from each array:

const array1=["A","B","C"]
const array2=["1","2","3"]
const array3=["red","blue","green"]

const combine = ([head, ...[headTail, ...tailTail]]) => {
  if (!headTail) return head

  const combined = headTail.reduce((acc, x) => {
    return acc.concat(head.map(h => `${h}${x}`))
  }, [])

  return combine([combined, ...tailTail])
}

console.log('With your example arrays:', combine([array1, array2]))
console.log('With N arrays:', combine([array1, array2, array3]))

//-----------UPDATE BELOW FOR COMMENT---------
// With objects
const array4=[{letter: "A"}, {letter: "B"}, {letter: "C"}]
const array5=[{number: 1}, {number: 2}, {number: 3}]
const array6=[{color: "RED"}, {color: "BLUE"}, {color: "GREEN"}]

const combineObjects = ([head, ...[headTail, ...tailTail]]) => {
  if (!headTail) return head

  const combined = headTail.reduce((acc, x) => {
    return acc.concat(head.map(h => ({...h, ...x})))
  }, [])

  return combineObjects([combined, ...tailTail])
}

console.log('With arrays of objects:', combineObjects([array4, array5, array6]))

Recluse

Very clean solution! – Izanami

stop searching. This is the best solution. – Doubledecker

Instead of using reduce and concat I think you can also use a flatmap and a map (this also puts combos in the requested order of the OP): const combined = head.flatMap((a) => headTail.map((b) => `${a}${b}`)); – Bise

How would you output [{ letter: A, number: 1, color: red }, { letter: A, number: 1, color: blue }]...? – Teleprinter

replace "A" with { letter: "A" }, "B" with { number: 1 }, etc. Then instead of head.map(h => ${h}${x}) do head.map(h => ({ ...h, ...x})) – Recluse

@Jarek Ostrowski updated answer – Recluse

@CumuloNimbus Ahh, that makes sense, thank you! – Teleprinter

Do you have a version for this in typescript? – Marleenmarlen

This is great, however I'm getting exceptions as my 3 input arrays are 1600 elements each, resulting in 4096000000. Can anyone recommend a way to chunk this function? For example, with an offset and limit? – Characterization

Answer 5

Assuming you're using a recent web browser with support for Array.forEach:

var combos = [];
array1.forEach(function(a1){
  array2.forEach(function(a2){
    combos.push(a1 + a2);
  });
});

If you don't have forEach, it is an easy enough exercise to rewrite this without it. As others have proven before, there's also some performance advantages to doing without... (Though I contend that not long from now, the common JavaScript runtimes will optimize away any current advantages to doing this otherwise.)

Rhiamon

could replace forEach with for loops as well. – Tiger

No browser... I'm going to use phonegap to turn it into a native iphone app. Will that still work? – Keef

@Dingredient - Doesn't really depend on the browser, but the supported JavaScript version. If forEach doesn't work, use rubixibuc's answer instead. – Rhiamon

Answer 6

Enhanced Solution for @Nitish Narang's Answer:

Utilize the reduce function in conjunction with flatMap to facilitate the combination of N arrays.

const combo = [
  ["A", "B", "C"],
  ["1", "2", "3", "4"]
];

console.log(combo.reduce((a, b) => a.flatMap(x => b.map(y => x + y)), ['']))

Goodygoody

Answer 7

Here is functional programming ES6 solution:

var array1=["A","B","C"];
var array2=["1","2","3"];

var result = array1.reduce( (a, v) =>
    [...a, ...array2.map(x=>v+x)],
[]);
/*---------OR--------------*/
var result1 = array1.reduce( (a, v, i) =>
    a.concat(array2.map( w => v + w )),
[]);

/*-------------OR(without arrow function)---------------*/
var result2 = array1.reduce(function(a, v, i) {
    a = a.concat(array2.map(function(w){
      return v + w
    }));
    return a;
    },[]
);

console.log(result);
console.log(result1);
console.log(result2)

Gentille

Answer 8

Part II: After my complicated iterative "odometer" solution of July 2018, here's a simpler recursive version of combineArraysRecursively()...

function combineArraysRecursively( array_of_arrays ){

        // First, handle some degenerate cases...

        if( ! array_of_arrays ){
            // Or maybe we should toss an exception...?
            return [];
        }

        if( ! Array.isArray( array_of_arrays ) ){
            // Or maybe we should toss an exception...?
            return [];
        }

        if( array_of_arrays.length == 0 ){
            return [];
        }

        for( let i = 0 ; i < array_of_arrays.length; i++ ){
            if( ! Array.isArray(array_of_arrays[i]) || array_of_arrays[i].length == 0 ){
                // If any of the arrays in array_of_arrays are not arrays or are zero-length array, return an empty array...
                return [];
            }
        }

        // Done with degenerate cases...
        let outputs = [];

        function permute(arrayOfArrays, whichArray=0, output=""){

            arrayOfArrays[whichArray].forEach((array_element)=>{
                if( whichArray == array_of_arrays.length - 1 ){            
                    // Base case...
                    outputs.push( output + array_element );
                }
                else{
                    // Recursive case...
                    permute(arrayOfArrays, whichArray+1, output + array_element );
                }
            });/*  forEach() */
        }

        permute(array_of_arrays);

        return outputs;
        

}/* function combineArraysRecursively() */

const array1 = ["A","B","C"];
const array2 = ["+", "-", "*", "/"];
const array3 = ["1","2"];

console.log("combineArraysRecursively(array1, array2, array3) = ", combineArraysRecursively([array1, array2, array3]) );

Beltane

What if array1 is empty ? Then I need all combinations with array2 and array3. – Keratogenous

Answer 9

Here is another take. Just one function and no recursion.

function allCombinations(arrays) {
  const numberOfCombinations = arrays.reduce(
    (res, array) => res * array.length,
    1
  )

  const result = Array(numberOfCombinations)
    .fill(0)
    .map(() => [])

  let repeatEachElement

  for (let i = 0; i < arrays.length; i++) {
    const array = arrays[i]

    repeatEachElement = repeatEachElement ?
      repeatEachElement / array.length :
      numberOfCombinations / array.length

    const everyElementRepeatedLength = repeatEachElement * array.length

    for (let j = 0; j < numberOfCombinations; j++) {
      const index = Math.floor(
        (j % everyElementRepeatedLength) / repeatEachElement
      )
      result[j][i] = array[index]
    }
  }

  return result
}

const result = allCombinations([
  ['a', 'b', 'c', 'd'],
  [1, 2, 3],
  [true, false],
])
console.log(result.join('\n'))

Singhal

Answer 10

Here's a short recursive one that takes N arrays.

function permuteArrays(first, next, ...rest) {
  if (rest.length) next = permuteArrays(next, ...rest);
  return first.flatMap(a => next.map(b => [a, b].flat()));
}

Or with reduce (slight enhancement of Penny Liu's):

function multiply(a, b) {
  return a.flatMap(c => b.map(d => [c, d].flat()));
}
[['a', 'b', 'c'], ['+', '-'], [1, 2, 3]].reduce(multiply);

Runnable example:

function permuteArrays(first, next, ...rest) {
  if (rest.length) next = permuteArrays(next, ...rest);
  return first.flatMap(a => next.map(b => [a, b].flat()));
}

const squish = arr => arr.join('');
console.log(
  permuteArrays(['A', 'B', 'C'], ['+', '-', '×', '÷'], [1, 2]).map(squish),
  permuteArrays(['a', 'b', 'c'], [1, 2, 3]).map(squish),
  permuteArrays([['a', 'foo'], 'b'], [1, 2]).map(squish),
  permuteArrays(['a', 'b', 'c'], [1, 2, 3], ['foo', 'bar', 'baz']).map(squish),
)

Artistry

Answer 11

Arbitrary number of arrays, arbitrary number of elements.

Sort of using number base theory I guess - the j-th array changes to the next element every time the number of combinations of the j-1 arrays has been exhausted. Calling these arrays 'vectors' here.

let vectorsInstance = [
  [1, 2],
  [6, 7, 9],
  [10, 11],
  [1, 5, 8, 17]]

function getCombos(vectors) {
  function countComb(vectors) {
    let numComb = 1
    for (vector of vectors) {
      numComb *= vector.length
    }
    return numComb
  }
  let allComb = countComb(vectors)
  
  let combos = []
  for (let i = 0; i < allComb; i++) {
    let thisCombo = []
    for (j = 0; j < vectors.length; j++) {
      let vector = vectors[j]
      let prevComb = countComb(vectors.slice(0, j))
      thisCombo.push(vector[Math.floor(i / prevComb) % vector.length])
    }
    combos.push(thisCombo)
  }
  return combos
}

console.log(getCombos(vectorsInstance))

Robby

Answer 12

While there's already plenty of good answers to get every combination, which is of course the original question, I'd just like to add a solution for pagination. Whenever there's permutations involved, there's the risk of extremely large numbers. Let's say, for whatever reason, we wanted to build an interface where a user could still browse through pages of practically unlimited permutations, e.g. show permutations 750-760 out of one gazillion.

We could do so using an odometer similar to the one in John's solution. Instead of only incrementing our way through the odometer, we also calculate its initial value, similar to how you'd convert for example seconds into a hh:mm:ss clock.

function getPermutations(arrays, startIndex = 0, endIndex) {
  if (
    !Array.isArray(arrays) ||
    arrays.length === 0 ||
    arrays.some(array => !Array.isArray(array))
  ) {
    return { start: 0, end: 0, total: 0, permutations: [] };
  }
  const permutations = [];
  const arrayCount = arrays.length;
  const arrayLengths = arrays.map(a => a.length);
  const maxIndex = arrayLengths.reduce(
    (product, arrayLength) => product * arrayLength,
    1,
  );
  if (typeof endIndex !== 'number' || endIndex > maxIndex) {
    endIndex = maxIndex;
  }
  const odometer = Array.from({ length: arrayCount }).fill(0);
  for (let i = startIndex; i < endIndex; i++) {
    let _i = i; // _i is modified and assigned to odometer indexes
    for (let odometerIndex = arrayCount - 1; odometerIndex >= 0; odometerIndex--) {
      odometer[odometerIndex] = _i % arrayLengths[odometerIndex];
      if (odometer[odometerIndex] > 0 && i > startIndex) {
        // Higher order values in existing odometer are still valid
        // if we're not hitting 0, since there's been no overflow.
        // However, startIndex always needs to follow through the loop
        // to assign initial odometer.
        break;
      }
      // Prepare _i for next odometer index by truncating rightmost digit
      _i = Math.floor(_i / arrayLengths[odometerIndex]);
    }
    permutations.push(
      odometer.map(
        (odometerValue, odometerIndex) => arrays[odometerIndex][odometerValue],
      ),
    );
  }
  return {
    start: startIndex,
    end: endIndex,
    total: maxIndex,
    permutations,
  };
}

So for the original question, we'd do

getPermutations([['A', 'B', 'C'], ['1', '2', '3']]);

-->

{
  "start": 0,
  "end": 9,
  "total": 9,
  "permutations": [
    ["A", "1"],
    ["A", "2"],
    ["A", "3"],
    ["B", "1"],
    ["B", "2"],
    ["B", "3"],
    ["C", "1"],
    ["C", "2"],
    ["C", "3"]
  ]
}

but we could also do

getPermutations([['A', 'B', 'C'], ['1', '2', '3']], 2, 5);

-->

{
  "start": 2,
  "end": 5,
  "total": 9,
  "permutations": [
    ["A", "3"],
    ["B", "1"],
    ["B", "2"]
  ]
}

And more importantly, we could do

getPermutations(
  [
      new Array(1000).fill(0),
      new Array(1000).fill(1),
      new Array(1000).fill(2),
      new Array(1000).fill(3),
      ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'],
      ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
      ['X', 'Y', 'Z'],
      ['1', '2', '3', '4', '5', '6']
  ],
  750,
  760
);
    
-->
    
{
  "start": 750,
  "end": 760,
  "total": 1800000000000000,
  "permutations": [
    [0, 1, 2, 3, "e", "B", "Z", "1"],
    [0, 1, 2, 3, "e", "B", "Z", "2"],
    [0, 1, 2, 3, "e", "B", "Z", "3"],
    [0, 1, 2, 3, "e", "B", "Z", "4"],
    [0, 1, 2, 3, "e", "B", "Z", "5"],
    [0, 1, 2, 3, "e", "B", "Z", "6"],
    [0, 1, 2, 3, "e", "C", "X", "1"],
    [0, 1, 2, 3, "e", "C", "X", "2"],
    [0, 1, 2, 3, "e", "C", "X", "3"],
    [0, 1, 2, 3, "e", "C", "X", "4"]
  ]
}

without the computer hanging.

Biamonte

Answer 13

I had a similar requirement, but I needed get all combinations of the keys of an object so that I could split it into multiple objects. For example, I needed to convert the following;

{ key1: [value1, value2], key2: [value3, value4] }

into the following 4 objects

{ key1: value1, key2: value3 }
{ key1: value1, key2: value4 }
{ key1: value2, key2: value3 }
{ key1: value2, key2: value4 }

I solved this with an entry function splitToMultipleKeys and a recursive function spreadKeys;

function spreadKeys(master, objects) {
  const masterKeys = Object.keys(master);
  const nextKey = masterKeys.pop();
  const nextValue = master[nextKey];
  const newObjects = [];
  for (const value of nextValue) {
    for (const ob of objects) {
      const newObject = Object.assign({ [nextKey]: value }, ob);
      newObjects.push(newObject);
    }
  }

  if (masterKeys.length === 0) {
    return newObjects;
  }

  const masterClone = Object.assign({}, master);
  delete masterClone[nextKey];
  return spreadKeys(masterClone, newObjects);
}

export function splitToMultipleKeys(key) {
  const objects = [{}];
  return spreadKeys(key, objects);
}

Quiberon

Answer 14

one more:

const buildCombinations = (allGroups: string[][]) => {
  const indexInArray = new Array(allGroups.length);
  indexInArray.fill(0);
  let arrayIndex = 0;
  const resultArray: string[] = [];
  while (allGroups[arrayIndex]) {
    let str = "";
    allGroups.forEach((g, index) => {
      str += g[indexInArray[index]];
    });
    resultArray.push(str);
    // if not last item in array already, switch index to next item in array
    if (indexInArray[arrayIndex] < allGroups[arrayIndex].length - 1) {
      indexInArray[arrayIndex] += 1;
    } else {
      // set item index for the next array
      indexInArray[arrayIndex] = 0;
      arrayIndex += 1;
      // exclude arrays with 1 element
      while (allGroups[arrayIndex] && allGroups[arrayIndex].length === 1) {
        arrayIndex += 1;
      }
      indexInArray[arrayIndex] = 1;
    }
  }
  return resultArray;
};

One example:

const testArrays = [["a","b"],["c"],["d","e","f"]]
const result = buildCombinations(testArrays)
// -> ["acd","bcd","ace","acf"]

Photocell

Answer 15

My version of the solution by John D. Aynedjian, which I rewrote for my own understanding.

console.log(getPermutations([["A","B","C"],["1","2","3"]]));
function getPermutations(arrayOfArrays)
{
 let permutations=[];
 let remainder,permutation;
 let permutationCount=1;
 let placeValue=1;
 let placeValues=new Array(arrayOfArrays.length);
 for(let i=arrayOfArrays.length-1;i>=0;i--)
 {
  placeValues[i]=placeValue;   
  placeValue*=arrayOfArrays[i].length;
 }
 permutationCount=placeValue;
 for(let i=0;i<permutationCount;i++)
 {
  remainder=i;
  permutation=[];
  for(let j=0;j<arrayOfArrays.length;j++)
  {
   permutation[j]=arrayOfArrays[j][Math.floor(remainder/placeValues[j])];
   remainder=remainder%placeValues[j];
  }
  permutations.push(permutation.reduce((prev,curr)=>prev+curr,""));  }
 return permutations;
}

First express arrays as array of arrays:

arrayOfArrays=[["A","B","C"],["a","b","c","d"],["1","2"]];

Next work out the number of permuations in the solution by multiplying the number of elements in each array by each other:

//["A","B","C"].length*["a","b","c","d"].length*["1","2"].length //24 permuations

Then give each array a place value, starting with the last:

//["1","2"] place value 1
//["a","b","c","d"] place value 2 (each one of these letters has 2 possibilities to the right i.e. 1 and 2)
//["A","B","C"] place value 8 (each one of these letters has 8 possibilities to the right i.e. a1,a2,b1,b2,c1,c2,d1,d2 
placeValues=[8,2,1]

This allows each element to be represented by a single digit:

arrayOfArrays[0][2]+arrayOfArrays[1][3]+arrayOfArrays[2][0] //"Cc1"

...would be:

2*placeValues[2]+3*placesValues[1]+0*placeValues[2] //2*8+3*2+0*1=22

We actually need to do the reverse of this so convert numbers 0 to the number of permutations to an index of each array using quotients and remainders of the permutation number. Like so:

//0 = [0,0,0], 1 = [0,0,1], 2 = [0,1,0], 3 = [0,1,1]
for(let i=0;i<permutationCount;i++)
{
 remainder=i;
 permutation=[];
 for(let j=0;j<arrayOfArrays.length;j++)
 {
  permutation[j]=arrayOfArrays[j][Math.floor(remainder/placeValues[j])];
  remainder=remainder%placeValues[j];
 }
 permutations.push(permutation.join(""));
}

The last bit turns the permutation into a string, as requested.

Dishonorable

Answer 16

const permute = (...x) => {
    var [a, b, ...c] = x;
    switch (x.length) {
        case 0:
            return [];
        case 1:
            try {
                return [...a] // attempt to iterate a (as is)
            } catch (Error) {
                return permute(String(a)) // iterate a (as string)
            };
        case 2:
            return permute(a).map(a => permute(b).map(b => a + b)).flat(); // all pairs
        default:
            return permute(permute(a, b), ...permute(c)); // recurse for more
    }
}
console.log(permute('ABC', 123)); // ["A1","A2","A3","B1","B2","B3","C1","C2","C3"]

console.log(permute([...permute(23456789), 10, ...permute('JQKA')], '♣♦♥♠')); // cards
console.log(permute('RC', 23, 'DP', 20)); // "..not the droids you're looking for."

Solmization

Answer 17

Make a loop like this ->

let numbers = [1,2,3,4,5];
let letters = ["A","B","C","D","E"];
let combos = [];

for(let i = 0; i < numbers.length; i++) {

combos.push(letters[i] + numbers[i]);

};

But you should make the array of “numbers” and “letters” at the same length thats it!

Tegucigalpa

There are two problems with your code. First, it will through the error Uncaught ReferenceError: A is not defined. ie; the values of the array letters must be string. Second, It will not generate all possible combinations, but give the following results ["A1", "B2", "C3", "D4", "E5"] – Profuse

yeah i didnt see that i didnt put quote there – Tegucigalpa