JavaScript. Как сравнить входные массивы

Question

Я застрял с этой проблемой уже 3 дня ... Кто-то, пожалуйста, помогите мне.

Задача 5
Создайте функцию intersection, которая сравниваетвходные массивы и возвращает новый массив с элементами, найденными во всех входных данных.

function intersection(arrayOfArrays) {

}

console.log(intersection([[5, 10, 15, 20], [15, 88, 1, 5, 7], [1, 10, 15, 5, 20]]));

// should log: [5, 15]

Answer 1

Работает даже если в одном массиве есть дубликаты .. как в моем примере добавлено 5 дважды в arrayEle [1];

var arrayEle = [[5, 10, 15, 20], [15, 88, 1, 5, 5], [1, 10, 15, 5, 20]]
var startIndex = 1;
var newArray = [];
for (var x = 0; x < arrayEle[0].length; x++) {
  var temVal = 1;
  var value;
  for (var y = 1; y < arrayEle.length; y++) {
    for (var z = 0; z < arrayEle[y].length; z++) {
      if (arrayEle[y][z] == arrayEle[0][x]) {
        temVal++;
        value = arrayEle[y][z];
        break;
      }
    }
  }
  if (temVal == arrayEle.length) {
    newArray.push(value);
    console.log(value);
  }
}
console.log(newArray);


//log: [5, 15]

Answer 2

Я думаю, вы хотите общие элементы.Позвольте мне показать вам, как:

var Array1 = [5, 10, 15, 20]
var Array2 = [15, 88, 1, 5, 7]
var Array3 = [1, 10, 15, 5, 20]
var found = []
var Final = []
var c = 1;e = 1;
for (i = 1;i<=Array1.length;i++){
    for (k = 1;k<=Array2.length;i++){
        if (Array1[i] == Array2[k]){
            Found[c] = Array[i];
            c++;
        }
    }
}
for (n = 1;n <= Found.length ; n++){
    for (m = 1;m <= Array3.length ; n++){
        if (Found[n] == Array3[m]){
            Final[e] = Found[n]
            e++; 
        }
    }
}
//the Array Final Contains 5 , 15

Answer 3

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

Вот пример:

function intersection(input) {
    let firstArray = input[0];
    let restOfArrays = input.splice(1);
    return firstArray.filter(v => restOfArrays.every(arr => arr.includes(v)));    
}

const input = [[5, 10, 15, 20], [15, 88, 1, 5, 7], [1, 10, 15, 5, 20]];
const result = intersection(input);

console.log(result);

Answer 4

Сначала попытайтесь выяснить пересечение двух массивов, которое является base problem. Затем попробуйте создать переменное число массивов, переданных в качестве аргументов для пересечения. Для этого вы можете использовать reduce().

function intersectionOfTwoArrays(arr1, arr2)
{
   return arr1.filter(x => arr2.some(y => y === x)); 
}


function intersection(...arrayOfArrays)
{
	return arrayOfArrays
	       .reduce((a, b) => intersectionOfTwoArrays(a, b));
}

intersection(
[5, 10, 15, 20], 
[15, 88, 1, 5, 7], 
[1, 10, 15, 5, 20]
);

Answer 5

Вы можете уменьшить массив путем фильтрации, просто проверив, содержит ли другой массив значение.

Это работает для массивов с уникальными значениями.

Array#reduce

Если initialValue не указано, то accumulator будет равно первому значению в массиве, а currentValue будет равно второму.

Обратный звонок

a.filter(v => b.includes(v))

массив фильтров a. Если массив b содержит значение a, то это значение v включается в accumulator для следующей итерации или в качестве окончательного результата.

     accumulator            currentValue           new accumulator
          a                       b                    result
--------------------    --------------------    --------------------
[     5, 10, 15, 20]    [15, 88,  1,  5,  7]    [             5, 15]
[             5, 15]    [ 1, 10, 15,  5, 20]    [             5, 15]

function intersection(arrayOfArrays) {
    return arrayOfArrays.reduce((a, b) => a.filter(v => b.includes(v)));
}

console.log(intersection([[5, 10, 15, 20], [15, 88, 1, 5, 7], [1, 10, 15, 5, 20]]));

Answer 6

Уменьшите массивов до Карта отсчетов со значением в качестве ключа. Распространение Карта на записей .Используйте Array.filter() в записях карты, чтобы удалить все записи, значение которых не равно длине arrayOfArrays.Извлеките исходный номер из записей, используя Array.map():

function intersection(arrayOfArrays) {
  return [...arrayOfArrays.reduce((r, s) => {
    s.forEach((n) => r.set(n, (r.get(n) || 0) + 1));
    
    return r;
  }, new Map())]
  .filter(([k, v]) => v === arrayOfArrays.length)
  .map(([k]) => k);
}

console.log(intersection([[5, 10, 15, 20], [15, 88, 1, 5, 7], [1, 10, 15, 5, 20]]));