返回阵列的函数，该数组是其他两个数组的交点

Question

function arraysCommon(array1, array2) {
  return array1.filter(x => array2.includes(x));
}

此功能无法按照我想要的方式工作。 例如给定array1 = [1,2,3,2,1]和array2 = [5,4,3,2,1] 它返回[1,2,3,2,1]，因为在两个数组中都可以看到elements 1,2,3。 但是我希望它以该顺序返回[1,2,3]，因为1,2,3在array2和被视为单独的实体。

因此，功能几乎应该是

• 第一个数组中的每个元素都可以映射到第二个数组中的最多元素。
• 每个数组中的重复元素被视为单独的实体。
• 第一个数组决定了我试图循环循环阵列的顺序

，并检查和比较每个数组中的重复项数量，但我似乎无法使逻辑正常工作。有其他方法可以解决这个问题吗？

我附上了两个Venn图的图像，可以阐明差异

Answer 1

不幸的是，它变得更加复杂，因为您需要知道已经添加了哪些数字。在这种情况下，您需要一个临时数组来保留结果。我们还需要跟踪数组中是否存在两次数字。

尝试以下操作：

function arraysCommon(array1, array2) {
  //Copy array2 by duplicating and spreading the elements into another array.
  var copyArray2 = [...array2];
  //Temperary Array
  var temp = [];
  for (let x of array1) {
      //Check if the element is in the first array and not already added to the temp array
      if (copyArray2.includes(x)) {
          temp.push(x);
          //Remove item from copy array2 so it cannot be used anymore
          copyArray2.splice(copyArray2.indexOf(x), 1);
      }
  } 
  //Return the temp array
  return temp;
}

console.log(arraysCommon([1,2,3,2,1], [5,4,3,2,1]))
console.log(arraysCommon([1,2,3,2,1], [2,2,3,3,4]))

Answer 2

通过分类和计数应该是可能的。由于当您找到类似字符时，您正在增加，所以这应该没关系：

const array1= [1,4,1,1,5,9,2,7];
const array2 = [1,8,2,5,1]

const array3 = [1,2,3,2,1];
const array4 = [5,4,3,2,1,2]

const array5 = [1,2,3,2,1];
const array6 = [2,2,3,3,4]
function arraysCommon(array1, array2) {
  const ans = [];
  array1.sort();
  array2.sort();
  let j = 0;
  let i = 0;
  while(i<array1.length && j<array2.length){
    if(array1[i] === array2[j]){
      ans.push(array1[i]);
      i++;
      j++;
    }
    else if(array2[i] > array1[j]){
    i++;
    }
    else{
    j++;
    }
  }
  console.log(ans);
}

arraysCommon(array1,array2);
arraysCommon(array3,array4);
arraysCommon(array5,array6);

Answer 3

这应该按照您的意愿起作用！

// test 1 
const array1 = [1,4,1,1,5,9,2,7];
const array2 = [1,8,2,5,1];

// test 2
const array3 = [1,2,3,2,1];
const array4 = [5,4,3,2,1];

const mapper = (array1, array2) => {
  var obj = {};
  array1.forEach((x, indexX) => {
    array2.forEach((y, indexY) => {
      if (x == y) {
        if (!Object.values(obj).includes(indexX) && !obj.hasOwnProperty(indexY)) {
          obj[indexY] = indexX;
          return;
        }
      }
    }) 
  })
  return Object.values(obj).sort().map(values => array1[values]);
}

console.log(mapper(array1, array2));
console.log(mapper(array3, array4));

我希望这会有所帮助。干杯。

Answer 4

您可以实现一个新的集合，Wich仅带来唯一的值，而不是从该集合中重新保留一个数组。

这样的事情：

function arraysCommon(array1, array2) {
  const filtered = array1.filter(x => array2.includes(x));
  const uniqueValues = new Set(filtered)
  return Array.from(uniqueValues)
}