Benchmark: Testing findMode

Script Preparation code:

// Purposely global
numbers = Array.from({length: 1e6}, () => Math.floor(Math.random() * 1e5))

function findMode(numbers) {
    let counted = numbers.reduce((acc, curr) => { 
        if (curr in acc) {
            acc[curr]++;
        } else {
            acc[curr] = 1;
        }

        return acc;
    }, {});

    let mode = Object.keys(counted).reduce((a, b) => counted[a] > counted[b] ? a : b);

    return mode;
}

function mostCommonNumber(numbers) {
    let map = new Map()
    for (let num of numbers) {
        map.set(num, (map.get(num) || 0) + 1)
    }

    let mostCommonNumber = NaN
    let maxCount = -1
    for (let [num, count] of map.entries()) {
        if (count > maxCount) {
            maxCount = count
            mostCommonNumber = num
        }
    }

    return mostCommonNumber
}

Tests:

findMode
findMode(numbers)
mostCommonNumber
mostCommonNumber(numbers)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
findMode
mostCommonNumber

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON and explain what's being tested.

**Benchmark Definition**

The JSON represents two JavaScript microbenchmarks: `findMode` and `mostCommonNumber`. Both functions take an array of numbers as input and return the most frequently occurring number in the array.

**Options Compared**

For each benchmark, two options are compared:

1. **Using a Map**: The first option uses a `Map` object to count the occurrences of each number in the array. This approach is implemented in the `findMode` function.
2. **Without Using a Map**: The second option does not use a `Map` object and instead uses an object literal to store the counts. This approach is implemented in the `mostCommonNumber` function.

**Pros and Cons**

**Using a Map (findMode)**

Pros:

* More concise and expressive code
* Easier to understand and maintain, especially for large datasets
* Faster lookup times compared to object literals

Cons:

* May have higher memory overhead due to the additional data structure
* Can be slower if the map is not properly optimized for lookup

**Without Using a Map (mostCommonNumber)**

Pros:

* Lower memory overhead
* May be faster in some cases, especially for small datasets

Cons:

* More verbose and less expressive code
* Slower lookup times compared to maps

In general, using a `Map` object is a good choice when working with large datasets or performance-critical applications. However, it may come at the cost of higher memory usage.

**Library**

The `Array.from()` method is used in both benchmarks to create an array of random numbers. This method is a part of the ECMAScript standard and is supported by most modern JavaScript engines.

**Special JS Feature/Syntax**

None of the tested code uses any special JavaScript features or syntax that would make it non-standard or non-portable.

**Alternatives**

If you need to optimize these benchmarks further, here are some alternative approaches:

* Using a `Set` object instead of a `Map` object for counting occurrences.
* Implementing a custom hash function for faster lookup times.
* Using a just-in-time (JIT) compiler or a JavaScript engine with optimized performance.

Keep in mind that optimization should always be done carefully and with a clear understanding of the trade-offs involved.

Related benchmarks:

Testing findMode (version: 0)

Comparing performance of: findMode vs mostCommonNumber

Created: 8 years ago by: Registered User

Jump to the latest result

findMode

mostCommonNumber

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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