Ideally you'd skip the square and do the division first (on whichever factor is even) to lower the chance of overflow. I was wondering why there is no test for this.

The gotcha with this is if you get a negative number.

Failed tests.

This one has constant comlexity O(1), while an iterator will have at least linear complexity O(n).
While this doesn't make this automatically more efficient for small values, we can optimise this solution by using bit operation for deviding but the compiler already does that for us.
So that means this solutuon needs 4 arthmic operations to execute, while the iterator solution needs at least n arethmic operations, meaning that if n is bigger than 4 the iterator solution is already worse.

Damn man you are good

Yup that one should be best practice

I feel this one more performant for very large n, under the assumption that sum() function for iterators goes through n elements.

Good use of bit shifting

Please use spoiler flag next time.

wait, **0.5 will not works well with really big integers...

is it O(n)?

this is optimized for cases the array has many duplicate numbers.

btw if there are 1,000,000 i8 elements, we can promise that is true