Benchmark: Array duplicate removal for duplicates exceeding `N`-number

Tests:

original duplicate removal

// Remove duplicates that occur 3 or more times in an array
// keeping unique values and those with less than 3
function removeMany(arr) {
  const newArr = Array.from(arr).sort()
  let count = 0;
  let result = []

  newArr.forEach((value, index, ar) => {
    count += 1;
    // refactored afterwards from (ar[index + 1] !== value)
    if (ar.lastIndexOf(value) <= index && count <= 2) {
      for (var i = 0; i < arr.length; i++) {
        if (arr[i] === value) {
          result.push(arr[i])
        }
      }
      count = 0
    } else if (ar[index + 1] !== value) {
      count = 0;
    }
  });

  // +1 is there anyway to return a result that mimicks the original order of `numbers`?
  return result;  // [1, 2, 2, 3, 4, 4]
}
const numbers = [1, 2, 3, 2, 4, 4, 5, 5, 5, 5];
console.log(removeMany(numbers));

​x
 
// Remove duplicates that occur 3 or more times in an array// keeping unique values and those with less than 3function removeMany(arr) {  const newArr = Array.from(arr).sort()  let count = 0;  let result = []​  newArr.forEach((value, index, ar) => {    count += 1;    // refactored afterwards from (ar[index + 1] !== value)    if (ar.lastIndexOf(value) <= index && count <= 2) {      for (var i = 0; i < arr.length; i++) {        if (arr[i] === value) {          result.push(arr[i])        }      }      count = 0    } else if (ar[index + 1] !== value) {      count = 0;    }  });​  // +1 is there anyway to return a result that mimicks the original order of `numbers`?  return result;  // [1, 2, 2, 3, 4, 4]}const numbers = [1, 2, 3, 2, 4, 4, 5, 5, 5, 5];console.log(removeMany(numbers));

2-pass approach

 // Remove duplicates that occur 3 or more times in an array
    // keeping unique values and those with less than 3
    function removeMany(arr) {
      let countMappings = arr.reduce(function(carry, item) {
          if (carry[item]!== undefined) {
            carry[item]++;
          }
          else {
            carry[item] = 1;
          }
          return carry;
      }, {});
      return arr.reduce(function(final, item) {
        if (countMappings[item] <3) {
          final.push(item);
        }
        return final;
      }, []);
    }
    const numbers = [1, 2, 3, 2, 4, 4, 5, 5, 5, 5];
    console.log(removeMany(numbers));

 
 // Remove duplicates that occur 3 or more times in an array    // keeping unique values and those with less than 3    function removeMany(arr) {      let countMappings = arr.reduce(function(carry, item) {          if (carry[item]!== undefined) {            carry[item]++;          }          else {            carry[item] = 1;          }          return carry;      }, {});      return arr.reduce(function(final, item) {        if (countMappings[item] <3) {          final.push(item);        }        return final;      }, []);    }    const numbers = [1, 2, 3, 2, 4, 4, 5, 5, 5, 5];    console.log(removeMany(numbers));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
original duplicate removal
2-pass approach

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 7 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36 Edge/14.14393

Browser/OS: Chrome 51 on Windows

View result in a separate tab

Test name	Executions per second
original duplicate removal	167509.2 Ops/sec
2-pass approach	254184.1 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 7 months ago):

Measuring the performance of JavaScript microbenchmarks is crucial to optimize code execution and identify bottlenecks.

Benchmark Overview

The provided benchmark measures the performance of two approaches to remove duplicates from an array that occur 3 or more times:

Original Duplicate Removal: This approach sorts the array, iterates through it, and pushes unique values with a count less than 3 into a new result array.
2-Pass Approach: This approach uses a mapping object to count occurrences of each element in the array and then filters out elements that occur 3 or more times.

Options Compared

Both approaches have their pros and cons:

Original Duplicate Removal
- Pros:
  - Simple and easy to understand
  - No additional data structure is required (aside from a temporary result array)
- Cons:
  - Sorts the entire array, which can be costly for large datasets
  - May have performance issues if the array is very large or has many duplicate elements
2-Pass Approach
- Pros:
  - More efficient than the original approach (especially for large arrays)
  - Uses a mapping object to count occurrences, which reduces the number of iterations required
- Cons:
  - Requires an additional data structure (the mapping object) to store counts
  - May be more complex and harder to understand

Library and Special JS Feature

In this benchmark, there is no specific library or special JavaScript feature being tested. However, the 2-pass approach uses a common JavaScript technique called "mapping" or "counting," which is used to iterate through an array and perform calculations based on each element's value.

Alternative Approaches

Other possible approaches to remove duplicates from an array include:

Using Set data structure (e.g., [...new Set(numbers)])
Using a for...of loop with a reduce() method
Using a library like Lodash or Ramda for functional programming

Keep in mind that each approach has its own trade-offs, and the best choice will depend on the specific requirements of your use case.

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks is crucial to optimize code execution and identify bottlenecks.

**Benchmark Overview**

The provided benchmark measures the performance of two approaches to remove duplicates from an array that occur 3 or more times:

1. **Original Duplicate Removal**: This approach sorts the array, iterates through it, and pushes unique values with a count less than 3 into a new result array.
2. **2-Pass Approach**: This approach uses a mapping object to count occurrences of each element in the array and then filters out elements that occur 3 or more times.

**Options Compared**

Both approaches have their pros and cons:

*   **Original Duplicate Removal**
    *   Pros:
        *   Simple and easy to understand
        *   No additional data structure is required (aside from a temporary result array)
    *   Cons:
        *   Sorts the entire array, which can be costly for large datasets
        *   May have performance issues if the array is very large or has many duplicate elements
*   **2-Pass Approach**
    *   Pros:
        *   More efficient than the original approach (especially for large arrays)
        *   Uses a mapping object to count occurrences, which reduces the number of iterations required
    *   Cons:
        *   Requires an additional data structure (the mapping object) to store counts
        *   May be more complex and harder to understand

**Library and Special JS Feature**

**Alternative Approaches**

Other possible approaches to remove duplicates from an array include:

*   Using `Set` data structure (e.g., `[...new Set(numbers)]`)
*   Using a `for...of` loop with a `reduce()` method
*   Using a library like Lodash or Ramda for functional programming

Keep in mind that each approach has its own trade-offs, and the best choice will depend on the specific requirements of your use case.

Related benchmarks:

Array duplicate removal for duplicates exceeding `N`-number (version: 0)

https://codereview.stackexchange.com/q/175067/120114

Comparing performance of: original duplicate removal vs 2-pass approach

Created: 7 years ago by: Guest

Jump to the latest result