Benchmark: Array find middle

Script Preparation code:

function test1(array) {
	for (let i = 0; i < array.length; i++) {
		let lsum = array.slice(0, i).reduce((carry, value) => carry + value, 0);
		let rsum = array.slice(i).reduce((carry, value) => carry + value, 0);
		if (lsum === rsum) return i;
	}
	return -1;
}

function test2(array) {
	let sum = array.reduce((carry, value) => carry + value, 0);
	for (let i = 0, lsum = 0, rsum = sum; i < array.length; i++, lsum += array[i - 1], rsum -= array[i - 1]) {
		if (lsum === rsum) {
			return i;
		}
	}
	return -1;
}

Tests:

function 1
test1([1, 5, -8, 0, -2]); test1([-2, 2, 5]); test1([1, 1, 1, 1, -4]);
function 2
test2([1, 5, -8, 0, -2]); test2([-2, 2, 5]); test2([1, 1, 1, 1, -4]);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
function 1
function 2

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.3; Win64; x64; rv:103.0) Gecko/20100101 Firefox/103.0

Browser/OS: Firefox 103 on Windows 8.1

View result in a separate tab

Test name	Executions per second
function 1	428923.5 Ops/sec
function 2	2408855.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and its various components.

**Benchmark Definition:**
The benchmark is defined by two JavaScript functions, `test1` and `test2`. Both functions take an array as input and are expected to find the middle element(s) of the array. The difference between these two functions lies in their approach:

*   `test1`: This function iterates through the array, calculates the sum of elements on both sides of each index (`i`), and checks if they're equal. If a match is found, it returns the current index; otherwise, it returns `-1`.
*   `test2`: This function first calculates the total sum of all elements in the array using the `reduce()` method. Then, it iterates through the array again, maintaining two running sums: `lsum` (left side) and `rsum` (right side). It checks if `lsum` equals `rsum`, returning the current index when a match is found; otherwise, it continues to the next iteration.

**Comparison of Options:**

The benchmark allows for comparison between different JavaScript implementations. The options being compared are:

1.  **Iteration-based approach**: Both functions use iterative approaches with time complexity O(n), where n is the length of the array.
2.  **Sum-based approach**: `test2` uses a sum-based approach, which calculates the total sum of all elements first and then iterates through the array to find the middle element.

**Pros and Cons:**

*   Iterative approach:
    *   Pros: Generally more efficient for small arrays or when the middle element is not present.
    *   Cons: Can be slow for large arrays due to repeated calculations.
*   Sum-based approach:
    *   Pros: Faster for large arrays because it avoids repeated calculations, making it suitable for finding multiple middle elements.
    *   Cons: Requires more memory to store the total sum and may have slower performance if the array is very large.

**Library Usage:**
Neither `test1` nor `test2` uses any external libraries, so there's no library-specific implementation or optimization involved in these benchmark cases.

**Special JS Features/Syntax:**
There are a few features used in this benchmark:

*   `reduce()`: This method applies a function against an accumulator and each element in the array (from left to right) to reduce it to a single value.
*   Arrow functions (`=>`): Used for concise function definitions.

**Other Alternatives:**
If you're looking to optimize or implement similar benchmarks, consider exploring other approaches:

1.  **Using built-in methods**: Some browsers provide optimized implementations of array operations in their built-in functions (e.g., `Array.prototype.indexOf()` instead of manual iteration).
2.  **Native JavaScript algorithms**: Familiarize yourself with standard library algorithms for solving common problems, such as finding middle elements.
3.  **Optimized libraries or frameworks**: Depending on your use case and performance requirements, you might want to explore optimized libraries or frameworks that provide better performance for specific tasks.

These alternatives can help you optimize or implement similar benchmarks more efficiently.

Related benchmarks:

Array find middle (version: 0)

Comparing performance of: function 1 vs function 2

Created: 2 years ago by: Guest

Jump to the latest result

function 1

function 2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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