Benchmark: Square Every Digit

Square Every Digit (version: 0)

Welcome. In this kata, you are asked to square every digit of a number and concatenate them. For example, if we run 9119 through the function, 811181 will come out, because 92 is 81 and 12 is 1. Note: The function accepts an integer and returns an integer

Comparing performance of: const nums vs random nums

Created: 2 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/react/16.3.0/cjs/react.production.min.js'></script>

Script Preparation code:

function squareDigits(num) {
    let result = '';
    for (let i = 0; i < `${num}`.length; i++) {
        result += `${Number(`${num}`[i]) ** 2}`;
    }
    return Number(result);
}

Tests:

const nums
squareDigits(3212); squareDigits(2112); squareDigits(0);
random nums
function randint(min, max){ return Math.floor(Math.random() * (max - min + 1)) + min; } for(let i = 1; i <= 100; i++){ let num = randint(1, 10_000_000); let expected = +[...(''+num)].map(x => Math.pow(+x, 2)).join``; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
const nums
random nums

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 107 on Windows

View result in a separate tab

Test name	Executions per second
const nums	523261.4 Ops/sec
random nums	5129.9 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided JSON benchmark and explain what's being tested, compared, and the pros/cons of different approaches.

**Benchmark Definition**

The benchmark definition is a JavaScript function named `squareDigits` that takes an integer as input, squares every digit, and concatenates them. The function returns an integer.

**Script Preparation Code**

The script preparation code is the implementation of the `squareDigits` function:
```javascript
function squareDigits(num) {
  let result = '';
  for (let i = 0; i < `${num}`.length; i++) {
    result += `${Number(`${num}`[i]) ** 2}`;
  }
  return Number(result);
}
```
This code uses a simple loop to iterate over each character in the input number, converts it to a number, squares it, and concatenates the result.

**Html Preparation Code**

The html preparation code includes a script tag that loads a React production minified file from a CDN:
```html
<script src='https://cdnjs.cloudflare.com/ajax/libs/react/16.3.0/cjs/react.production.min.js'></script>
```
This is likely used to run the benchmark in a web environment.

**Individual Test Cases**

There are two test cases:

1. **`const nums`**: This test case runs the `squareDigits` function with three different input values: 3212, 2112, and 0. The results are not expected.
2. **`random nums`**: This test case generates a large number of random numbers between 1 and 10 million using the `randint` function, squares each digit, and concatenates them. No specific result is expected.

**Comparison**

The comparison being made here is likely between different implementations or optimizations of the `squareDigits` function. The two test cases are:

* **`const nums`**: This test case likely compares the performance of the original implementation of the `squareDigits` function (from the Script Preparation Code).
* **`random nums`**: This test case likely compares the performance of a specific optimization or alternative implementation of the `squareDigits` function.

**Pros and Cons**

The pros and cons of different approaches will depend on the specific optimizations being tested. Some possible considerations include:

* Using a more efficient data structure, such as an array instead of a string, to store the squared digits.
* Using a more optimized algorithm for squaring digits, such as using a lookup table or SIMD instructions.
* Minimizing memory allocation and garbage collection by reusing existing arrays or strings.
* Optimizing the loop structure or using a different iteration order.

**Libraries and Special Features**

The React library is used in the Html Preparation Code. It's not clear how this affects the performance of the benchmark, but it may introduce additional overhead due to the complexity of the React framework.

There are no special JavaScript features or syntax being tested in these benchmarks. However, some benchmarks may use features like async/await, Promises, or Web Workers to improve performance.

**Alternatives**

Other alternatives for optimizing the `squareDigits` function might include:

* Using a just-in-time (JIT) compiler to optimize the function for specific inputs or architectures.
* Using a static analysis tool to identify performance-critical regions of the code and generate optimized assembly code.
* Using a parallelization framework like Web Workers to run multiple iterations of the function in parallel.

Note that these alternatives may not be applicable or effective for all use cases, and the specific optimization approach will depend on the requirements and constraints of the benchmark.

Related benchmarks: