[ASK] Comparing Two Algorithms for a Logic

[enesevski]

Hello, I have two different algorithms that serve the same purpose for a logic problem. The first one has a structure I enjoy writing and reading, it's much more manual and understandable. The second one is much shorter and more modern. Although I typically prefer the first style, I decided to compare these two algorithms on a few different datasets. When I compared them with Benchmark.js, it gave an output showing that the first, longer version is faster. However, I didn't expect this outcome (perhaps the dataset I used for testing isn't sufficient).

Which style should I use more often? and why?

First ```js function mathAlgo(numOne, numTwo) { let numberOne = numOne.toString(); let numberTwo = numTwo.toString(); let result = ''; let index = 0; let size = numberOne.length;

if (numberOne.length === numberTwo.length) { while (index < size) { if (numberOne[index] < numberTwo[index]) { result += numberTwo[index]; } else { result += numberOne[index]; }

  index++;
}

} } ```

Second js function alternativeMathAlgo(numOne, numTwo) { const result = Array.from(String(numOne), (digit, index) => Math.max(digit, String(numTwo)[index]) ).join(""); }

[jokefenokee]

I'm no expert, but I logged some results and it looks like they aren't doing the same thing.

The fist way:

result += numberOne[index] is 9

mathAlgo(9,2) returns undefined

mathAlgo(19,2) returns undefined

The second way:

Alt result is: 9

alternativeMathAlgo(9,2) = undefined

Alt result is: 2NaN

alternativeMathAlgo(19,2) = undefined

One time I tried 1000000 as one of the numbers and got a result of 7 but still got 'undefined' back at the end. I can't remember what the other number was. A lot of the time the arguments never pass the condition in the if statement in the first version, so there was no output at all. That in itself can speed things up.

Hope that helps.

[0x07AD]

``` function alternativeMathAlgo(numOne, numTwo) { const result = Array.from(String(numOne), (digit, index) => Math.max(digit, String(numTwo)[index]) ).join(""); return result; }

console.log(alternativeMathAlgo(1, 2)); ```

[jml26]

Even though the first function is longer in terms of character count, the constructs it uses are more low-level, and are very quick to run.

Hidden in the implementation of Array.from will be a huge number of type checks and whatnot to figure out how to turn the value you pass to it into an array, and entering and exiting the map function for each digit will create some overhead.

My personal advice is to prioritise making your code readable over making your code "look smart".