第 59 题：给定两个数组，写一个方法来计算它们的交集。

[zeroone001]

例如：给定 nums1 = [1, 2, 2, 1]，nums2 = [2, 2]，返回 [2, 2]。

var nums1 = [1, 2, 2, 1], nums2 = [2, 2, 3, 4];
// 1.
// 有个问题， [NaN].indexOf(NaN) === -1
var newArr1 = nums1.filter(function(item) {
     return nums2.indexOf(item) > -1;
});
console.log(newArr1);
// 2.
var newArr2 = nums1.filter((item) => {
     return nums2.includes(item);
});
console.log(newArr2);

[ramey502]

let intersection = (...arg) => arg[0].filter(v => arg[1].includes(v));

[sgzhm4444]

var nums1 = [1, 2, 2, 1], nums2 = [2, 2], result=[];
nums1.forEach(function(val) {
	if(nums2.includes(val)) {
		result.push(val);
	}
})
console.log(result);

[jefferyE]

function union (arr1, arr2) {
  return arr1.filter(item => {
  	return arr2.indexOf(item) > - 1;
  })
}
 const a = [1, 2, 2, 1];
 const b = [2, 3, 2];
 console.log(union(a, b)); // [2, 2]

[A0150315]

let intersection = (...arg) => arg[0].filter(v => arg[1].includes(v));

解法有点问题，intersection([1,2,2,1],[2,1])

[yyyddc]

const nums1 = [1, 2, 2, 1];
const nums2 = [2, 2];

const nums = nums1.filter(v => nums2.some(w => w === v))
console.log(nums)

---

之前的错了，更新一下，感觉可以

const nums1 = [1, 2, 2, 1];
const nums2 = [2, 2];

const doit = (array1, array2) => {
    const tmp = [...array2]; // 避免修改array2，使函数doit变得纯洁
    return array1.filter(v => {
        const index = tmp.indexOf(v);
        if(index > -1) {
            tmp.splice(index, 1);
            return true;
        } 
        return false;
    })
}

console.log(doit(nums1, nums2))

[Jon-Millent]

返回所有符合结果的交集。

function isExsitWith(numGroup1, numGroup2) {

	let betterArray = [];

	let eachCode = []
	numGroup1.forEach(val=>{

		eachCode.push(val);
		if(numGroup2.toString().indexOf(eachCode.toString()) == -1) {
			eachCode.pop()
			eachCode.length > 1 && betterArray.push(eachCode)
			eachCode = []
		}

	})

	return betterArray;
}

console.log(
	isExsitWith([1, 2, 2, 1, 1, 9, 9, 6, 1, 1, 2, 3, 3], [2, 2, 9, 9, 6,])
)

[Molunerfinn]

这道题不是工程题，是道算法题。求的是两个数组的最长公共子序列 (子序列要求顺序，交集不需要）。所以上面用一个filter一个includes或者indexOf的都是错的。

反例很简单。

var nums1 = [1]
var nums2 = [1,1]

或者

var nums1 = [1,1]
var nums2 = [1]

交集应该是[1]

跑一下你们的方法就能知道错了。

这道题两种思路，空间换时间，或者不用额外空间就提升时间复杂度。

空间换时间的思路是用个Hash表来存数组1的元素以及出现的个数（此处需要遍历n次，并存一个n级别的空间）。
遍历数组2，发现数组2里有Hash表里的值就存到Result数组里，并把Hash表内该值次数减一（为0之后就Delete）。如果不存在Hash表里，就跳过。这样时间复杂度就是(m+n)

不用额外空间，就用遍历n的时候，判断值在不在m里，如果在，把m里的该值push到Result数组里，并将该值从m数组里删掉（用splice）。这样就是不用额外空间，但是提高了时间复杂度。

[tongtannan]

    let nums1 = [1, 2, 2, 1], nums2 = [2, 2, 1, 3]
    let result = nums1.filter(item => {
        let idx = nums2.indexOf(item)
        if (idx !== -1) {
            nums2.splice(idx, 1)
            return item
        }
    })
    console.log(result)  //[1, 2, 2]

[dorseysen]

let arr0 = [1, 2, 3, '5', '你好啊', 7],
    arr1 = [2, 7, 9, 3, 'hello', '你好啊', 120];
    

const dorseyHandle = (arr0, arr1) => {

    let res = [],
        map = {},
        _arr1;

    //  确定哪个数组长度更长
    let _arr0 = arr0.length > arr1.length ? ( _arr1 = arr1, arr0 ) : ( _arr1 = arr0 , arr1 );    //  这里是arr0更长

    _arr0.map(( item, index ) => {

        map[item] = 'undefined' !== typeof map[item] ? map[item] + 1 : 1;
    });

    _arr1.forEach(item => {

        if('undefined' !== typeof map[item]){

            res.push(item);

            map[item] === 1 ? delete map[item] : map[item] -= 1;

        }
    });

    return res;
}

console.log(dorseyHandle(arr0, arr1));

另一种方式

    let arr0 = [1, 2, 3, '5', '你好啊', 7],
        arr1 = [2, 7, 9, 3, 'hello', '你好啊', 120];

    const dorseyHandle = ( arr0, arr1 ) => {


        return arr0.filter( item => {

            let index = arr1.indexOf(item);

            if(-1 !== index){

                arr1.splice(index, 1);
                return item;
            }
        });
    }

    console.log(dorseyHandle(arr0, arr1));

[ZodiacSyndicate]

哈希表，时间复杂度O(m + n) m为nums1长度，n为nums2长度

const intersect = (nums1, nums2) => {
  const map = {}
  const res = []
  for (let n of nums1) {
    if (map[n]) {
      map[n]++
    } else {
      map[n] = 1
    }
  }
  for (let n of nums2) {
    if (map[n] > 0) {
      res.push(n)
      map[n]--
    }
  }
  return res
}

[flynngao]

let intersection = (...arg) => arg[0].filter(v => arg[1].includes(v));

[1,2,2,1],[2] 情况不成立

[yeyi361936738]

这道题不是工程题，是道算法题。求的是两个数组的最长公共子序列。所以上面用一个filter一个includes或者indexOf的都是错的。

反例很简单。

var nums1 = [1]
var nums2 = [1,1]

或者

var nums1 = [1,1]
var nums2 = [1]

最长公共子序列应该是[1]

跑一下你们的方法就能知道错了。

我试了 可以啊

 const a = [1]
 const b = [1, 1]

function fn(arr1, arr2) {
   return arr1.filter(item => {
      return arr2.includes(item)
   })
}

 console.log(fn(a, b))//[1]

[YouziXR]

/* 第 59 题：给定两个数组，写一个方法来计算它们的交集。

例如：给定 nums1 = [1, 2, 2, 1]，nums2 = [2, 2]，返回 [2, 2]。 */

// 思路：遍历数组1，对每个元素判断其是否在数组2中，存在则提出来放到一个新数组里，并且从数组2中剔除，以确保下一次遍历不会出现重复的。
// 由于Array.splice()函数效率比较低，所以采用空间换取时间的方式，剔除的过程是将其他非交集元素放到新数组里。
// 想了想，还是用简单的splice吧。

function intersect (ary1, ary2) {
  let longAry, shortAry
  // 不取长短数组也行吧。
  if (ary1.length > ary2.length) {
    longAry = ary1
    shortAry = ary2
  } else {
    longAry = ary2
    shortAry = ary1
  }
  let tmpAry = []
  try {
    longAry.forEach(el => {
      if (shortAry.length === 0) {
        throw new Error('short array.lenth === 0')
      }
      let index = shortAry.indexOf(el)
      if (index > -1) {
        // 短数组中存在元素的情况
        shortAry.splice(index, 1)
        tmpAry.push(el)
      }
    })
  } catch (error) {
    console.log(error)
  }
  return tmpAry
}
console.log(intersect([1, 2, 2, 1], [2, 2]))

[Molunerfinn]

这道题不是工程题，是道算法题。求的是两个数组的最长公共子序列。所以上面用一个filter一个includes或者indexOf的都是错的。
反例很简单。

var nums1 = [1]
var nums2 = [1,1]

或者

var nums1 = [1,1]
var nums2 = [1]

最长公共子序列应该是[1]
跑一下你们的方法就能知道错了。

我试了 可以啊

 const a = [1]
 const b = [1, 1]

function fn(arr1, arr2) {
   return arr1.filter(item => {
      return arr2.includes(item)
   })
}

 console.log(fn(a, b))//[1]

你的a换成[1,1],b换成[1]再试试

[yeyi361936738]

这道题不是工程题，是道算法题。求的是两个数组的最长公共子序列。所以上面用一个filter一个includes或者indexOf的都是错的。
反例很简单。

var nums1 = [1]
var nums2 = [1,1]

或者

var nums1 = [1,1]
var nums2 = [1]

最长公共子序列应该是[1]
跑一下你们的方法就能知道错了。

我试了 可以啊

 const a = [1]
 const b = [1, 1]

function fn(arr1, arr2) {
   return arr1.filter(item => {
      return arr2.includes(item)
   })
}

 console.log(fn(a, b))//[1]

你的a换成[1,1],b换成[1]再试试

是有问题。有受到调用数组长度影响。