Benchmark: Merge Version Spec Strings

Merge Version Spec Strings (version: 5)

Compare algorithms implementing the following behavior: A version Spec string is comma separated string of version numbers or version number ranges. Like "1,10-20,24,98-100". A merge operation among version spec strings must result in a string that takes both specifications and merge them.

Comparing performance of: Exhaustive list of version numbers vs Handle only specified ranges

Created: 3 months ago by: Registered User

Jump to the latest result

Script Preparation code:

var versionString1  = '1-999745,999830-999864';
var versionString2 = '999746-999829,999865-999979';
var validInputRegex = /^\s*(\d+(-\d+)?)(,\s*\d+(-\d+)?)*\s*$/;

Tests:

Exhaustive list of version numbers
function mergeVersionStrings(versions1, versions2) { const parsedVersions1 = parseVersions(versions1); const parsedVersions2 = parseVersions(versions2); return generateVersionsString(sortAndRemoveDuplicates([...parsedVersions1, ...parsedVersions2])); } function parseVersions(versions) { // Check if the input string matches any of the expected formats if (!versions || versions.trim().length == 0 || versions === 'undefined') { return []; } if (!versions.match(validInputRegex)) { throw new Error(`Invalid input format. Expected format: '3' or '1,2,3' or '1-3'. Received: ${versions}`); } const result = []; const sections = versions.split(','); for (const section of sections) { if (section.includes('-')) { const [start, end] = section.split('-').map(Number); for (let i = start; i <= end; i++) { result.push(i); } } else { result.push(Number(section)); } } return result; } function sortAndRemoveDuplicates(versions) { return Array.from(new Set(versions)).sort((a, b) => a - b); } function generateVersionsString(versions) { if (versions.length === 0) { return ''; } let result = ''; let normalizedVersions = sortAndRemoveDuplicates(versions); let rangeStart = normalizedVersions[0]; let rangeEnd = normalizedVersions[0]; for (let i = 1; i < normalizedVersions.length; i++) { if (normalizedVersions[i] === rangeEnd + 1) { rangeEnd = normalizedVersions[i]; } else { result += (rangeStart === rangeEnd ? rangeStart : `${rangeStart}-${rangeEnd}`) + ','; rangeStart = normalizedVersions[i]; rangeEnd = normalizedVersions[i]; } } result += (rangeStart === rangeEnd ? rangeStart : `${rangeStart}-${rangeEnd}`); return result; } mergeVersionStrings(versionString1, versionString2);
Handle only specified ranges
function mergeVersionStrings(a, b) { const rangesA = parseVersionString(a); const rangesB = parseVersionString(b); const mergedRanges = optimizeRanges(rangesA.concat(rangesB)); return formatVersionString(mergedRanges); } function parseVersionString(versionString) { const ranges = []; if (!versionString || !versionString.trim()) { return ranges; } const parts = versionString.split(','); for (const part of parts) { if (part.includes('-')) { const [start, end] = part.split('-').map(Number); ranges.push({start, end}); } else { const num = Number(part); ranges.push({start: num, end: num}); } } return optimizeRanges(ranges); } function optimizeRanges(ranges) { return ranges .sort((a, b) => a.start - b.start) .reduce((optimized, current) => { const last = optimized[optimized.length - 1]; if (!last || current.start > last.end + 1) { optimized.push(current); } else { last.end = Math.max(last.end, current.end); } return optimized; }, []); } function formatVersionString(ranges) { return ranges .map((range) => (range.start === range.end ? `${range.start}` : `${range.start}-${range.end}`)) .join(','); } mergeVersionStrings(versionString1, versionString2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Exhaustive list of version numbers
Handle only specified ranges

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll do my best to break down the benchmark and its test cases in a clear and concise manner.

**Benchmark Definition**

The benchmark is designed to compare algorithms for merging version spec strings. A version spec string is a comma-separated list of version numbers or version number ranges (e.g., "1-999745,999830-999864").

**Test Cases**

There are two test cases:

### Test Case 1: Exhaustive List of Version Numbers

This test case generates an exhaustive list of version numbers from the input strings `versionString1` and `versionString2`. The algorithm used is as follows:

1. Parse the input string into a list of versions using the `parseVersions` function.
2. Remove duplicates and sort the list using the `sortAndRemoveDuplicates` function.
3. Generate a new version spec string from the sorted list using the `generateVersionsString` function.

### Test Case 2: Handle Only Specified Ranges

This test case only handles specified ranges in the input strings `versionString1` and `versionString2`. The algorithm used is as follows:

1. Parse the input string into a list of ranges using the `parseVersionString` function.
2. Optimize the list of ranges by merging overlapping ranges using the `optimizeRanges` function.
3. Format the optimized list of ranges into a new version spec string using the `formatVersionString` function.

**Libraries and Features**

* The `validInputRegex` regular expression is used to validate the input strings and ensure they match the expected format.
* The `parseVersions`, `sortAndRemoveDuplicates`, and `generateVersionsString` functions are not built-in JavaScript functions but rather custom implementations.
* The `optimizeRanges` function uses a reduction approach to merge overlapping ranges in the list of versions.

**Pros and Cons**

Here are some pros and cons for each test case:

### Test Case 1: Exhaustive List of Version Numbers

Pros:

* Verifies that the algorithm can handle all possible version numbers.
Cons:

* May be slower due to the need to remove duplicates and sort the list of versions.

### Test Case 2: Handle Only Specified Ranges

Pros:

* Faster than Test Case 1, as it only handles specified ranges.
Cons:

* May not cover all possible edge cases.

**Latest Benchmark Results**

The latest benchmark results show that Test Case 2 ("Handle only specified ranges") is faster than Test Case 1. The average execution time for Test Case 2 is around 3.32 seconds per second, while Test Case 1 averages around 363 seconds per second.

Overall, this benchmark seems to be testing the performance of an algorithm that can efficiently merge version spec strings in different scenarios.

Latest run results:

Run details: (Test run date: 3 months ago)

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

Browser/OS: Chrome 127 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Exhaustive list of version numbers	3.3 Ops/sec
Handle only specified ranges	363321.7 Ops/sec

Related benchmarks: