Как я могу создать любую комбинацию для содержимого двух массивов?

Ответ 1

Петля этой формы

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])
     }
}

Ответ 2

Или, если вы хотите создать комбинации с произвольным числом массивов произвольных размеров... (Я уверен, что вы можете сделать это рекурсивно, но, поскольку это не собеседование, вместо этого я использую итеративное " одометр "для этого... он увеличивает" число "с каждой цифрой" цифра "base-n" на основе длины каждого массива)... например...

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

... возвращается...

[
   "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"
]

... каждый из которых соответствует значению одометра, которое выбирает индекс из каждого массива...

[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]

Метод "одометр" позволяет вам легко генерировать желаемый тип выходных данных, а не только конкатенированные строки, как у нас здесь. Кроме того, избегая рекурсии, мы избегаем возможности - смею ли я сказать это? - переполнение стека...

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() */

Ответ 3

Предполагая, что вы используете недавний веб-браузер с поддержкой Array.forEach:

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

Если у вас нет forEach, это простое упражнение, чтобы переписать это без него. Как и было доказано ранее, есть и некоторые преимущества в производительности без использования... (Хотя я и утверждаю, что не так давно, обычные временные среды JavaScript будут оптимизировать любые текущие преимущества для этого в противном случае.)

Ответ 4

Вот функциональное программирование решения ES6:

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)

Ответ 5

На всякий случай, если кто-то ищет решение Array.map

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

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

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

Ответ 6

Сделайте такую петлю ->

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]);

};

Но вы должны сделать массив "цифр" и "букв" одинаковой длины!

Ответ 7

У меня было похожее требование, но мне нужно было получить все комбинации клавиш объекта, чтобы можно было разбить его на несколько объектов. Например, мне нужно было преобразовать следующее;

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

в следующие 4 объекта

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

Я решил это с помощью функции входа splitToMultipleKeys и рекурсивной функции 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);
}

Ответ 8

Увидев много for петель во всех ответов...

Вот рекурсивное решение, которое я придумал, который найдет все комбинации из N чисел массивов, взяв 1 элемент из каждого массива:

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]))