阿里算法题：编写一个函数计算多个数组的交集

[sisterAn]

要求：
输出结果中的每个元素一定是唯一的

[WuChenDi]

var intersection = function (nums1, nums2) {
  let arr1 = Array.from(new Set(nums1));
  let arr2 = Array.from(new Set(nums2));
  let arr3 = new Array();
  for (let [v, k] of arr1.entries()) {
    if (arr2.includes(k)) {
      arr3.push(k)
    }
  }
  return arr3;
};
// 忽略我的命名......

[cyndra0]

const intersection = (arrs) => {

  /** @returns { Set } intersection 两个集合的交集*/
  const intersectTwoSets = (set1, set2) => {
    const result = new Set(set1)
    for (let item of result) {
      if (!set2.has(item)) {
        result.delete(item)
      }
    }
    return result
  }

  /** @description 所有数组的交集 */
  const resultSet = (
    arrs
      .map(arr => new Set(arr))
      // O(N * M)
      .reduce(intersectTwoSets) 
  )

  return Array.from(resultSet)
}

[liwuhou]

万能的reduce

const getIntersection = (...arrs) => {
    return Array.from(new Set(arrs.reduce((total, arr) => {
        return arr.filter(item => total.includes(item));
    })));
}

[mingju0421]

function intersect(arrs) {
      let obj = {},
        result = {};
      for (let i = 0; i < arrs[0].length; i++) {
        obj[i] = 1;
      }
      for (let i = 1; i < arrs.length; i++) {
        result = {};
        arrs[i].forEach(element => {
          obj[element] ? (result[element] = 1) : "";
        });
        obj = result;
      }

      return Object.keys(obj);
    }

[352800205]

一行代码搞定

let intersection = (list , ...args) => list.filter( item => args.every( list => list.includes( item )))
console.log( intersection( [ 2,1 ], [ 2,3 ] ) ) // [ 2 ]
console.log( intersection( [ 2,1 ], [ 4,3 ] ) ) // [ ]

[BoswellJi]

/**
 * 编写一个函数计算多个数组的交集，要求结果中的每个元素都是唯一的
 */

function multArrMerge() {
  let arrs = Array.prototype.slice.call(arguments).map(item => Array.from(new Set(item)));
  let shortArr = arrs[0];
  let mergeArr = [];

  // O(n)
  // 找到最短数组
  arrs.forEach((item, index) => {
    if (shortArr.length > item.length) {
      shortArr = item;
    }
  });

  // O(n^2)
  // 收集最短数组中每个元素的交集
  mergeArr = shortArr.map(item => {
    const temp = [];
    arrs.forEach(item1 => {
      if (item1.indexOf(item) > -1) {
        temp.push(item);
      }
    });
    return temp;
  });

  // O(n)
  // 过滤每个数组的交集
  mergeArr = mergeArr.map(item => {
    if (item.length === arrs.length) {
      return item[0];
    }
  }).filter(item => item)

  return mergeArr;
}

function multArrMerge(...arrs) {
  arrs = arrs.map(item => Array.from(new Set(item)));
  let targetArr = arrs[0];
  for (let i = 1, len = arrs.length; i < len; i++) {
    targetArr = arrs[i].filter(item => targetArr.includes(item));
  }
  return targetArr;
}

[ZWBruce]

function intersection(arr,...args){
  // 记录每次对比两个数组的交集
  let set = new Set(arr);
  for(let e of args){ // 取出不定个参数数组
    let rep = []; // 记录当前数组和之前交集的交集
    for(let ele of e){
      if(set.has(ele)){
        rep.push(ele);
      }
    }
    set = new Set(rep); // 将交集用于和下组数组的对比
  }
  return [...set];
}

[shengq666]

在原先两个数组求交集的基础上使用reduce

function intersect(nums1,nums2){
   return [...new Set(nums1.filter((item)=>nums2.includes(item)))]
}

function intersectAll(...arrs){
    return resultArr = arrs.reduce(function(prev,cur){
	return intersect(prev,cur);
    })
}

合并之后就是

function getIntersect(...arrs) {
    return arrs.reduce(function(prev,cur){
	return [...new Set(cur.filter((item)=>prev.includes(item)))]
    })
}

[kimixue]

const mixed = (...arrs) => {
  return [...new Set(arrs.reduce((sum,arr) => {
    return arr.filter(i => sum.includes(i));
  }))]
}

[hh-cheng]

function intersection(...arr) {
    let result = [];
    arr.forEach(arr => {
        if( arr instanceof Array ){
            // 如果是第一个数组，则直接将该数组去重然后 push 到目标数组中
            if( !result.length ) {
                result.push(...new Set(arr));
                return ;
            }
            // 如果是第二个及以后的数组，则先去重然后用目标数组过滤
            const tempSet = new Set(arr);
            result = result.filter(item=>tempSet.has(item));
        }
    });
    return result;
}

[hecun0000]

var intersection = function (...arrs) {
  let res= arrs[0]
  for (let i = 1; i < arrs.length; i++) {
    res = res.filter(item=> arrs[i].includes(item))    
  }
  return [...new Set(res)]
}

[hhshii]

function intersection(){
  return Array.prototype.slice.call(arguments).reduce((arr, item) => {
        return item.filter(key => arr.includes(key));
  })
}

[sisterAn]

使用 reducer 函数

const intersection = function(...args) {
    if (args.length === 0) {
    return []
  }
  if (args.length === 1) {
    return args[0]
  }
  return [...new Set(args.reduce((result, arg) => {
    return result.filter(item => arg.includes(item))
  }))]
};

[sfsoul]

const intersection = function(...rest) {
        console.log('rest', rest);
        const arr = rest.reduce((prev, next) => {
            console.log('prev', prev);
            console.log('next', next);
            if (prev.length === 0) {
                prev = prev.concat(next);
            } else {
                // prev = [...new Set(prev.filter(item => next.includes(item)))]; 每次计算 prev 值都会进行一次去重
                prev = prev.filter(item => next.includes(item));
            }
            return prev;
        }, []);
        return [...new Set(arr)]; // 不如计算完之后统一去一次重
    };