Benchmark: Fizz Buzz - MeasureThat.net

Tests:

For
for(i=0;i<100;)console.log((++i%3?'':'Fizz')+(i%5?'':'Buzz')||i)
Array join
console.log( Array.apply(null, {length: 100}).map(function(val, index) { return (++index%3?'':'Fizz')+(index%5?'':'Buzz')||index; }).join('\n') );
Array map
console.log( Array.apply(null, {length: 100}).map(function(val, index) { index++; if (index % 15 == 0){return "FizzBuzz";} if (index % 3 == 0){return "Fizz";} if (index % 5 == 0){return "Buzz";} return index; }).join('\n') );
Wtf
var i, values = [, , 'fizz', , 'buzz', 'fizz', , , 'fizz', 'buzz', , 'fizz', , , 'fizzbuzz']; for (i = 0; i < 100; console.log(values[i++ % 15] || i));
Longread
(function (window) { 'use strict'; var counter = 1; var limit = 100; var options = { 3: 'Fizz', 5: 'Buzz', 'default': function (input) { return input; } }; var noop = function () { return; }; var print = function (input) { var output = []; Object.keys(options).map( function (key) { (((typeof options[key] !== 'function') && ((parseInt(input, 10) % parseInt(key, 10)) === 0)) ? Array.prototype.push : noop).call(output, options[key]); } ); return console.log.call(console, output.length ? output.join('') : options.default.call(this, input)); }; for (; counter <= limit; counter += 1) { print.call(this, counter); } })(this);
For#2
for (var i=0;i<=100;i++) console.log(!(i%15)&&"fizzbuzz"||!(i%5)&&"buzz"||!(i%3)&&"fizz"||i);
Wtf#2
var fizzBuzz = function* () { var i = 0; do { const isFizz = i % 3 === 0; const isBuzz = i % 5 === 0; yield (isFizz ? isBuzz ? "FizzBuzz" : "Fizz" : isBuzz ? "Buzz" : i); } while (++i) } var it = fizzBuzz(); for (let i = 0; i < 100; i++){ console.log(it.next().value); }
For#3
for (var i = 1; i <= 100; i++) { answer = " "; if (i % 3 == 0) { answer += 'Fizz'; } if (i % 5 == 0) { answer += 'Buzz'; } console.log(answer || i); }
22 Iterations
let i = 0 let j = 1 let limit = 100 //prints zero console.log(i); while (true) { if (i > limit - 4) break; //can also kept in loop; but I always enjoy infinte loops breaking ;-) and have to subtract with 4 if needed till 99 i = i + 5; (i - 4) % 3 === 0 ? console.log(i - 4 + " - Fizz") : console.log(i - 4); (i - 3) % 3 === 0 ? console.log(i - 3 + " - Fizz") : console.log(i - 3); (i - 2) % 3 === 0 ? console.log(i - 2 + " - Fizz") : console.log(i - 2); (i - 1) % 3 === 0 ? console.log(i - 1 + " - Fizz") : console.log(i - 1); if (i % 3 === 0) { console.log(i + " - FizzBuzz"); continue } console.log(i + " - Buzz") j++ //Loop Counter } console.log('Total iterations ran: ', j)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
For
Array join
Array map
Wtf
Longread
For#2
Wtf#2
For#3
22 Iterations

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year 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
For	3846.9 Ops/sec
Array join	108991.3 Ops/sec
Array map	112725.5 Ops/sec
Wtf	3690.3 Ops/sec
Longread	2661.4 Ops/sec
For#2	3939.5 Ops/sec
Wtf#2	3754.4 Ops/sec
For#3	3482.9 Ops/sec
22 Iterations	3320.8 Ops/sec

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

LLMs can make mistakes. Check important info.

Based on the provided benchmark results, here are some key takeaways:

1. **Chrome 99 performs consistently**: All test names have the same browser version, Chrome 99, indicating that this is the primary execution environment for these tests.
2. **Desktop platforms dominate**: Most tests are executed on desktop devices (Windows), suggesting that desktop performance is a priority.
3. **Operating System matters**: The fact that Windows-based systems produce the highest executions per second for most tests implies that OS-specific optimizations or differences may be present.
4. **For and Wtf tests perform well**: These two test types exhibit high execution rates, potentially due to optimized implementations or caching mechanisms.
5. **Longread performs poorly**: This test has the lowest execution rate, indicating a possible performance bottleneck in this specific scenario.
6. **22 Iterations is tied with For#3**: Both tests have similar execution rates, suggesting that iteration depth and optimization may be crucial for these particular use cases.

Without more context or specific requirements, it's challenging to provide a definitive answer. However, these observations can serve as a starting point for further analysis and optimization efforts.

Related benchmarks:

Fizz Buzz (version: 0)

Fizz Buzz perfocmance

Comparing performance of: For vs Array join vs Array map vs Wtf vs Longread vs For#2 vs Wtf#2 vs For#3 vs 22 Iterations

Created: 5 years ago by: Guest

Jump to the latest result

For

Array join

Array map

Wtf

Longread

For#2

Wtf#2

For#3

22 Iterations

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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