Run results for: findCommon elements in th JS v2

Run details:

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:141.0) Gecko/20100101 Firefox/141.0

Browser: Firefox 141

Operating system: Linux

Device Platform: Desktop

Date tested: 8 months ago

Test name	Executions per second
v1 (Mine)	348.8 Ops/sec
v2 (Perplexity)	305.2 Ops/sec
v3 (Gemini)	10.5 Ops/sec
v4 (ChatGPT)	498.2 Ops/sec
v5 (Khoj)	773.2 Ops/sec
v6 (Phind)	10.3 Ops/sec

HTML Preparation code:

Implement a JavaScript function called findCommon Elements that accepts multiple arrays as arguments and returns a new array containing only the elements that are present in every input array.
```
// Function signature

function findCommonElements(...arrays) {
// write your code here
}
// Example input and output:
// Input: findCommonElements([1, 2, 3, 4], [2, 4, 6, 8], [2, 4, 101)
// Expected Output: [2, 4]
```

Script Preparation code:

// ==== Implementation 1: Your current code ====
function findCommonElements_v1(...arrays) {
  if (!arrays || !Array.isArray(arrays) || arrays.length === 0) {
    return [];
  }

  const cleanArrays = arrays.map((arr) => arr.filter((item) => !!item));
  let common = new Set(cleanArrays[0]);

  for (const arr of cleanArrays.slice(1)) {
    let tmpUnique = new Set([...arr]);
    for (const item of [...common]) {
      if (!tmpUnique.has(item)) {
        common.delete(item);
      }
    }
    
    if (common.size === 0) break;
  }
  return [...common];
}

// ==== Implementation 2 ====
function findCommonElements_v2(...arrays) {
  if (arrays.length === 0) return [];
  return [...arrays.reduce((acc, curr) => {
    const currSet = new Set(curr);
    return new Set([...acc].filter(el => currSet.has(el)));
  }, new Set(arrays[0]))];
}

// ==== Implementation 3 ====
function findCommonElements_v3(...arrays) {
  if (!arrays || arrays.length === 0) {
    return [];
  }
  const referenceArray = arrays[0];
  const otherArrays = arrays.slice(1);
  return referenceArray.filter(element => {
    return otherArrays.every(arr => arr.includes(element));
  });
}

// ==== Implementation 4 ====
function findCommonElements_v4(...arrays) {
  if (!arrays || !Array.isArray(arrays) || arrays.length === 0) {
    return [];
  }
  let common = new Set(arrays[0]);
  for (const arr of arrays.slice(1)) {
    let currentSet = new Set(arr);
    common = new Set([...common].filter((val) => currentSet.has(val)));
    if (common.size === 0) break;
  }
  return [...common];
}

// ==== Implementation 5 ====
function findCommonElements_v5(...arrays) {
  if (arrays.length === 0) {
    return [];
  }

  if (arrays.length === 1) {
    return Array.from(new Set(arrays[0]));
  }

  let commonElements = new Set(arrays[0]);

  for (let i = 1; i < arrays.length; i++) {
    const currentArray = arrays[i];
    const newCommonElements = new Set();


    for (const element of currentArray) {
      if (commonElements.has(element)) {
        newCommonElements.add(element);
      }
    }

    commonElements = newCommonElements;

    if (commonElements.size === 0) {
      break;
    }
  }

  return Array.from(commonElements);
}

// ==== Implementation 6 ====
function findCommonElements_v6(...arrays) {
    if (!arrays.length) return [];
    let common = [...arrays[0]];
    for (let i = 1; i < arrays.length; i++) {
        const currentArray = arrays[i];
        common = common.filter(element => 
            currentArray.includes(element)
        );
        if (common.length === 0) break;
    }
    return common;
}


// ==== Large test case generator ====
function generateLargeTestCases(numArrays, arrayLength, valueRange) {
  const cases = [];
  for (let i = 0; i < numArrays; i++) {
    const arr = [];
    for (let j = 0; j < arrayLength; j++) {
      arr.push(Math.floor(Math.random() * valueRange));
    }
    cases.push(arr);
  }
  return cases;
}

// ==== Test cases ====
const testCases = [
  [[1, 2, 3, 4], [2, 4, 6, 8], [2, 4, 101]],
  [[1, 2, 3], [1, 2, 4], [1, 5]],
  [[]],
  [['a', 'b'], ['b', 'c'], ['b', 'd']],
  [[1, 2], [3, 4], [5]],
  generateLargeTestCases(10, 1000, 2000), // 10 arrays, each with 1000 elements
  generateLargeTestCases(5, 5000, 10000), // 5 arrays, each with 5000 elements
  generateLargeTestCases(20, 200, 1000),  // 20 smaller arrays
  generateLargeTestCases(3, 10000, 90000) // huge: 3 arrays with 10k elements
];

// ==== Wrappers for benchmark ====
function runV1() { for (let i = 0; i < testCases.length; i++) findCommonElements_v1(...testCases[i]); }
function runV2() { for (let i = 0; i < testCases.length; i++) findCommonElements_v2(...testCases[i]); }
function runV3() { for (let i = 0; i < testCases.length; i++) findCommonElements_v3(...testCases[i]); }
function runV4() { for (let i = 0; i < testCases.length; i++) findCommonElements_v4(...testCases[i]); }
function runV5() { for (let i = 0; i < testCases.length; i++) findCommonElements_v5(...testCases[i]); }
function runV6() { for (let i = 0; i < testCases.length; i++) findCommonElements_v6(...testCases[i]); }

Tests:

v1 (Mine)
/*When writing async/deferred tests, use `deferred.resolve()` to mark test as done*/ runV1();
v2 (Perplexity)
runV2();
v3 (Gemini)
runV3();
v4 (ChatGPT)
runV4();
v5 (Khoj)
runV5();
v6 (Phind)
runV6()

Run results for: findCommon elements in th JS v2

Mine vs. Gemini vs. ChatGPT vs Perplexity vs. Khoj vs. Phind

v1 (Mine)

v2 (Perplexity)

v3 (Gemini)

v4 (ChatGPT)

v5 (Khoj)

v6 (Phind)