const
    intersect = (nums1, nums2) => {
        const
            count = (c, i) => v => c[v] = (c[v] || 0) + i,
            counts = {};
            
        nums1.forEach(count(counts, 1));
        return nums2.filter((f => v => f(v) >= 0)(count(counts, -1)));
        
    };

console.log(intersect([1, 2, 2, 1], [2, 2]));
console.log(intersect([1, 2, 2, 1], [2]));
console.log(intersect([9, 4, 9, 8, 4], [4, 9, 5]));
console.log(intersect([2, 1], [1, 1])); // failed

function frequency(nums) {
  return nums.reduce((acc, curr) => {
    if (acc[curr]) {
      acc[curr]++;
    } else {
      acc[curr] = 1;

    }
    return acc;
  }, {});
}

var intersect = function(nums1, nums2) {
  const nums1Frequencies = frequency(nums1);
  const nums2Frequencies = frequency(nums2);

         // only consider unique elements from nums1 (we already counted occurrences)
  return Array.from(new Set(nums1))
           // determine how many of N should appear in the result
           .map(n => [n, Math.min(nums1Frequencies[n], nums2Frequencies[n])])
           // filter out N that were not in both arrays
           .filter(([n, min]) => !Number.isNaN(min))
           // create an Array containing the number of N that should go into the result
           .map(([n, min]) => Array(min).fill(n))
           // flatten nested arrays
           .flat()
};

console.log(intersect([1, 2, 2, 1], [2, 2]));        // [2, 2]
console.log(intersect([1, 2, 2, 1], [2]));           // [2]
console.log(intersect([9, 4, 9, 8, 4], [4, 9, 5]));  // [9, 4]
console.log(intersect([2, 1], [1, 1]));              // [1]

/**
 * Counts occurrences of each member of array
 * @param {any[]} arr - array of any values
 * @return {Map} a map of the breakdowns - each key is a unique item in the array  (SameValueZero comparison) and the values are the counts of occurrences
 */
const countMembers = arr => {
  const counts = new Map();
  
  for (const item of arr)
    counts.set(item, (counts.get(item) ?? 0) + 1);
    
  return counts;
};

/**
 * Merge maps where the keys intersect, skip keys that are only in one map
 * @param {Map} map1
 * @param {Map} map2
 * @param valueMergeCallback - determines how the values will be handled. Called with value from map1 and value from map2 as arguments
 * @return {Map} Map with keys that only show up in both map1 and map2 where the value is determined by valueMergeCallback
 */
const intersectMergeMaps = (map1, map2, valueMergeCallback) => {
  const result = new Map();
  
  for (const [key, value1] of map1) {
    if (!map2.has(key))
      continue;
      
    const value2 = map2.get(key);
    result.set(key, valueMergeCallback(value1, value2));
  }
 
  return result;
};

/**
 * Helper function that creates an array of repeated values
 * @param {*} value - item that will show up in array
 * @param {number} repeat - how many times it should appear in the array
 * @return array containing only value repeat number of times
 */ 
const repeatArray = (value, repeat) =>
  Array.from({length: repeat}, () => value);
  
  
/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
const intersect = function (nums1, nums2) {
    const count1 = countMembers(nums1);
    const count2 = countMembers(nums2);
    
    const m = intersectMergeMaps(count1, count2, Math.min);
    
    return Array.from(m)
      .flatMap(([num, count]) => repeatArray(num, count));
};

console.log(intersect([1, 2, 2, 1], [2, 2]));
console.log(intersect([1, 2, 2, 1], [2]));
console.log(intersect([9, 4, 9, 8, 4], [4, 9, 5]));
console.log(intersect([2, 1], [1, 1]));


console.log(intersect([2, 1], [4, 3]));