Benchmark: parleto - MeasureThat.net

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

    const expenses = {
        '2023-01': {
            '01': {
                food: [22.11, 43, 11.72, 2.2, 36.29, 2.5, 19],
                fuel: [210.22],
            },
            '09': {
                food: [11.9],
                fuel: [190.22],
            },
        },
        '2023-03': {
            '07': {
                food: [20, 11.9, 30.2, 11.9],
            },
            '04': {
                food: [10.2, 11.5, 2.5],
                fuel: [],
            },
        },
        '2023-04': {},
    };

    function getFirstSunday(monthOfYear) {
        let firstSunday = 1;
        const weekday = new Date(`${monthOfYear}-01`).getDay();
        if (weekday !== 0) {
            // Offsetujemy dzień, bo getDay() zwraca 0 dla niedzieli
            firstSunday = 8 - weekday;
        }
        return firstSunday;
    }

    function solution1(expenses) {
        let result = null;
        let allExpenses = [];

        for (const monthOfYear in expenses) {
            const month = expenses[monthOfYear];
            const daysWithExpenses = Object.keys(month).map(Number);
            const firstSunday = getFirstSunday(monthOfYear);
            const daysUpToFirstSunday = daysWithExpenses.filter(
                day => day <= firstSunday
            );
            if (daysUpToFirstSunday.length === 0) continue;
            for (const day of daysUpToFirstSunday) {
                const allDayExpenses = month[`0${day}`];
                for (const dayExpenses of Object.values(allDayExpenses)) {
                    for (const expense of dayExpenses) {
                        allExpenses.push(expense);
                    }
                }
            }
        }
        // Jeśli nie ma wydatków to nie ma z czego liczyć medianę, więc zwracamy null
        if (allExpenses.length === 0) return result;
        allExpenses.sort((a, b) => a - b);

        const midIndex = Math.floor(allExpenses.length / 2);
        if (allExpenses.length % 2 === 0) {
            const midValue1 = allExpenses[midIndex - 1];
            const midValue2 = allExpenses[midIndex];
            result = (midValue1 + midValue2) / 2;
        } else {
            result = allExpenses[midIndex];
        }

        return result;
    }

    function findMedian(arr) {
        const midIndex = Math.floor(arr.length / 2);

        if (arr.length % 2 === 1) return quickSelect(arr, midIndex);
        return (
            (quickSelect(arr, midIndex - 1) + quickSelect(arr, midIndex)) / 2
        );
    }

    function quickSelect(arr, k) {
        return quickSelectHelper(arr, 0, arr.length - 1, k);
    }

    function quickSelectHelper(arr, left, right, k) {
        if (left === right) return arr[left];

        const pivotIndex = partition(arr, left, right);

        if (k === pivotIndex) return arr[k];
        if (k < pivotIndex)
            return quickSelectHelper(arr, left, pivotIndex - 1, k);
        return quickSelectHelper(arr, pivotIndex + 1, right, k);
    }

    function partition(arr, left, right) {
        const pivot = arr[right];
        let i = left - 1;

        for (let j = left; j < right; j++) {
            if (arr[j] <= pivot) {
                i++;
                [arr[i], arr[j]] = [arr[j], arr[i]];
            }
        }

        [arr[i + 1], arr[right]] = [arr[right], arr[i + 1]];
        return i + 1;
    }

    function solution2(expenses) {
        let result = null;
        let allExpenses = [];

        for (const monthOfYear in expenses) {
            const month = expenses[monthOfYear];
            const firstSunday = getFirstSunday(monthOfYear);

            for (const day in month) {
                if (Number(day) > firstSunday) continue;
                const allDayExpenses = month[day];
                for (const dayExpenses of Object.values(allDayExpenses)) {
                    if (dayExpenses.length === 0) continue;
                    for (const expense of dayExpenses) {
                        allExpenses.push(expense);
                    }
                }
            }
        }
        // Jeśli nie ma wydatków to nie ma z czego liczyć medianę, więc zwracamy null
        if (allExpenses.length === 0) return null;

        // Kalkulujemy medianę używając algorytmu Quick Select
        // Obrałem daną metodologię, gdyż jest to algorytm najczęściej operujący ze złożonością O(n)
        // Jest to zatem bardziej optymalny sposób, niż zwykłe sortowanie arraya i wybranie z niego środkowych elementów
        // Minusem jest nieco bardziej skomplikowany kod oraz rzadki przypadek, w którym złożoność algorytmu wynosi O(n^2)
        result = findMedian(allExpenses);
        return result;
    }

Tests:

S1
solution1(expenses);
S2
solution2(expenses);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
S1
S2

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 20 days ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
S1	553392.2 Ops/sec
S2	1206181.2 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 20 days ago):

LLMs can make mistakes. Check important info.

The benchmark provided compares two different implementations for extracting and calculating the median of expenses recorded in a JavaScript object. The context revolves around processing expense data categorized by months and dates, where each date includes various items, such as food and fuel expenses.

### Comparison of Options

**1. `solution1(expenses)`**
   - **Description**: This implementation iterates through the expense data, identifying the first Sunday of each month. It collects expenses for all days up to and including that first Sunday. The collected expenses are then sorted and the median is calculated based on the sorted array.
   - **Pros**:
     - It explicitly filters out only the relevant days (up to the first Sunday), ensuring that unnecessary data is ignored during the expense collection phase.
     - The sorting of expenses at the end allows for a straightforward calculation of the median.
   - **Cons**:
     - Sorting introduces a time complexity of \(O(n \log n)\), as the collected expenses must be sorted to find the median.
     - The handling of days in leading zero formats complicates the indexing when accessing the expenses data.

**2. `solution2(expenses)`**
   - **Description**: This function also identifies the first Sunday of the month but modifies the approach by checking each day directly against the first Sunday. It collects expenses as long as they are recorded before or on that day. The actual median calculation leverages a Quick Select algorithm to find the median from the collected expenses.
   - **Pros**:
     - The approach aims to use Quick Select, which generally has an average time complexity of \(O(n)\) for finding the median. This is more optimal than sorting the entire array when only the median is required.
     - It avoids unnecessary sorting of the complete expense array and focuses directly on finding the median.
   - **Cons**:
     - The Quick Select algorithm is more complex and can lead to worst-case scenarios of \(O(n^2)\), especially if poor pivot choices are made.
     - There is an added cognitive load for developers due to the complexity of the Quick Select algorithm compared to simpler sorting and indexing.

### Libraries and Features
- The provided code does not utilize any external libraries; it relies purely on JavaScript's built-in capabilities, such as array manipulation and date handling.
- The mentioned features, like `Array.prototype.sort` and basic mathematical operations, are standard to JavaScript and do not represent any special syntax or advanced features beyond the essential JavaScript programming model.

### Other Alternatives
- **Using a library**: If the problem at hand were more complex or if higher performance were necessary, a developer could consider using libraries like Lodash, which has optimized utility functions for data manipulation (though it may not specifically enhance median finding without the underlying complexity consideration).
  
- **Incorporating Typed Arrays**: If large numbers of expenses were involved, using Typed Arrays could provide marginal performance advantages due to lower memory overhead and faster operations for specific numerical calculations.

- **Storage and Querying Options**: If expenses were to be processed over a more extensive data set or in real-time applications, integrating database solutions with optimized querying capabilities (like SQL or NoSQL databases) to pre-sort and fetch values based on predefined conditions could enhance performance further.

### Conclusion
The JavaScript benchmark effectively contrasts two methods of deriving the median from a statistical perspective, weighing the balance between computational complexity and practicality. While `solution1` offers a more straightforward approach, `solution2` emphasizes performance optimization through a more complex algorithm, potentially yielding better results for larger datasets. Each has its advantages and disadvantages depending on the context and priorities of the application.

Related benchmarks:

parleto (version: 1)

Comparing performance of: S1 vs S2

Created: 20 days ago by: Guest

Jump to the latest result

S1

S2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 20 days ago):