Benchmark: twoSum test - MeasureThat.net

Script Preparation code:


// Naive appraoch - O(n^2)

function twoSum1(arr, target) {
  for (let i = 0; i < arr.length; i++) {
    // for every integer of the array
    for (let j = i + 1; j < arr.length; j++) {
      // go through every integer after it and check the sum
      if (arr[i] + arr[j] === target) return true;
    }
  }

  return false;
}


// Using set - O(n)

function twoSum2(arr, target) {
  // set to store difference of target and element
  const diffs = new Set();

  // iterate through array
  for (let element of arr) {
    // current element exists in diffs, we saw its complement before
    if (diffs.has(element)) return true;
    // otherwise add the complement to the diffs
    else diffs.add(target - element);
  }

  // target sum not found
  return false;
}

Tests:

twoSum1
const testArr = []; for (let i = 0; i < 10000; i++) { testArr.push(i); } twoSum1(testArr)
twoSum2
const testArr = []; for (let i = 0; i < 10000; i++) { testArr.push(i); } twoSum2(testArr)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
twoSum1
twoSum2

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark definition and test cases to understand what's being tested.

**Benchmark Definition**

The benchmark is for two implementations of the `twoSum` function, which takes an array of numbers and a target sum as input, and returns `true` if there are two elements in the array that add up to the target sum, and `false` otherwise. The two implementations are:

1. **Naive Approach**: This implementation has a time complexity of O(n^2), where n is the length of the array. It uses two nested loops to iterate through the array, comparing each element with every other element.
2. **Using Set**: This implementation has a time complexity of O(n), where n is the length of the array. It uses a `Set` data structure to store the differences between the target sum and each element in the array.

**Options Compared**

The two implementations are compared in terms of their performance, specifically:

* Time complexity: O(n^2) vs O(n)
* Number of iterations: Naive Approach (n^2) vs Using Set (n)

**Pros and Cons**

1. **Naive Approach**:
	* Pros: Easy to understand and implement
	* Cons: Slow due to its high time complexity
	* Use case: This approach might be suitable for small arrays or educational purposes.
2. **Using Set**:
	* Pros: Fast due to its efficient use of the `Set` data structure
	* Cons: Requires additional memory to store the set, and may have higher overhead due to hash table operations

**Library Used**

The `Set` data structure is used in the "Using Set" implementation. A `Set` is a collection of unique values, which can be used to store the differences between the target sum and each element in the array.

**Special JS Feature or Syntax**

None mentioned in this benchmark definition.

**Other Alternatives**

If you want to optimize the `twoSum` function further, you could consider using other approaches such as:

* Hash table-based approach (similar to "Using Set", but with a hash table instead of a set)
* Sorting and binary search approach
* Using a more efficient data structure like a trie or a prefix tree

Keep in mind that the choice of implementation will depend on the specific requirements of your use case, such as performance, memory usage, and development time.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36

Browser/OS: Chrome 79 on Mac OS X 10.15.3

View result in a separate tab

Test name	Executions per second
twoSum1	64.7 Ops/sec
twoSum2	3238.7 Ops/sec

Related benchmarks:

twoSum test (version: 0)

Comparing performance of: twoSum1 vs twoSum2

Created: 4 years ago by: Guest

Jump to the latest result

twoSum1

twoSum2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):