Benchmark: Square Every Digit, but with toString()

Square Every Digit, but with toString() (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.toString().length; i++) {
        result += `${Number(num.toString()[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); squareDigits(num); }

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

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

LLMs can make mistakes. Check important info.

Let's break down what is tested in the provided benchmark and the different approaches used.

**What is being tested?**

The main goal of this benchmark is to measure how fast an JavaScript function can square every digit of a number and concatenate them, while ignoring special characters and other non-digit characters. The test cases cover various inputs, including numbers with different lengths, zeros, and two test cases with random numbers generated using the `randint` library.

**Options compared**

There are several options being tested:

1. **Using `toString()`**: As seen in the benchmark definition json, one option is to convert the input number to a string using `toString()`. This approach allows for easy manipulation of digits within the string.
2. **Using template literals**: Another option is not present in this particular benchmark definition but it's worth mentioning. Template literals (backticks) can be used to create strings with expressions, which might provide better performance than concatenating strings using the `+` operator.
3. **Looping over digits individually**: The script preparation code uses a loop that iterates over each digit of the input number, converts it to a number using `Number(num.toString()[i])`, squares it, and appends the result to a string.

**Pros and Cons**

1. **Using `toString()`**:
	* Pros: Easy to manipulate digits within the string.
	* Cons: Converts the entire number to a string, which can be inefficient for large numbers.
2. **Looping over digits individually**:
	* Pros: Allows direct access to individual digits without converting the entire number to a string.
	* Cons: Requires more operations (converting digit to number and squaring) than using `toString()`.

**Library usage**

The `randint` library is used in one of the test cases. This library generates random numbers between a specified minimum and maximum value, which can be useful for stress testing or benchmarking JavaScript performance.

**Special JS feature or syntax**

There are no special JavaScript features or syntaxes explicitly mentioned in this benchmark definition. However, the use of `const` for declaring constants and template literals (if present) are modern JavaScript features that might affect performance.

**Alternatives**

Other alternatives to measure the performance of squaring every digit of a number could include:

1. **Benchmarking libraries**: Libraries like Benchmark.js or js-benchmark can simplify the process of creating benchmarks.
2. **Testing frameworks**: Testing frameworks like Jest or Mocha can provide tools for writing and running tests, including benchmarks.
3. **Cloud-based benchmarking services**: Cloud-based services like AWS Lambda Benchmarks or Google Cloud Benchmarking can provide scalable and secure environments for running benchmarks.

Keep in mind that the choice of alternative will depend on the specific requirements of the project and the desired level of complexity.

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	492729.8 Ops/sec
random nums	6181.6 Ops/sec

Related benchmarks: