Benchmark: Finite vs Known Multiples (High Limit)

Script Preparation code:

var limit = 10000;
var total = 0;

Tests:

Finite - Test all numbers within limit
for (var i = 0; i < limit; i++) { if (i % 3 === 0 || i % 5 == 0) { total += i; } } console.log(total);
Multiples Only
var multiples = []; var i = 1; while (i * 3 < limit) { let m = i * 3; !multiples.includes(m) && multiples.push(m); i++; } i = 0; while (i * 5 < limit) { let m = i * 5; !multiples.includes(m) && multiples.push(m); i++; } console.log(multiples.reduce((a, b) => a + b, 0));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Finite - Test all numbers within limit
Multiples Only

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 78 on Windows

View result in a separate tab

Test name	Executions per second
Finite - Test all numbers within limit	291.2 Ops/sec
Multiples Only	46.8 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 benchmark and its options.

**Benchmark Definition**

The provided benchmark is designed to test two different approaches to finding multiples of 3 or 5 within a given limit. The limit is set at 10,000.

**Options Compared**

There are two main options compared:

1. **Finite Loop**: This approach uses a traditional for loop to iterate through all numbers within the limit and checks if each number is a multiple of 3 or 5.
2. **Dynamic Array Approach**: This approach uses an array to store multiples of 3 and 5, and then sums them up.

**Pros and Cons**

### Finite Loop

Pros:

* Simple to understand and implement
* Directly calculates the sum of all desired numbers within the limit

Cons:

* May have performance issues due to the brute-force nature of the approach
* Can be slow for large limits

### Dynamic Array Approach

Pros:

* More efficient than the finite loop approach, as it avoids redundant calculations
* Takes advantage of JavaScript's array methods (e.g., includes, push)

Cons:

* More complex to implement and understand
* Requires more memory to store the dynamic array

**Library Used**

None is explicitly mentioned in the provided benchmark definition. However, if we consider libraries like NumJS or Mathjs that can be used for numerical computations in JavaScript, they might provide a similar functionality.

**Special JS Feature/Syntax**

There isn't any special JavaScript feature or syntax being used in these benchmarks. They are standard JavaScript code examples.

**Other Alternatives**

Some alternative approaches to finding multiples of 3 or 5 could include:

* Using a mathematical formula to directly calculate the sum of all desired numbers within the limit (e.g., using the formula for the sum of an arithmetic series)
* Utilizing a more efficient algorithm, such as the Sieve of Eratosthenes to generate all prime numbers up to the limit and then filter for multiples of 3 or 5
* Using a just-in-time compiler like V8 (used by Chrome) to optimize performance

Related benchmarks:

Finite vs Known Multiples (High Limit) (version: 0)

I'm a dog with a bone.

Comparing performance of: Finite - Test all numbers within limit vs Multiples Only

Created: 5 years ago by: Guest

Jump to the latest result

Finite - Test all numbers within limit

Multiples Only

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):