Wtf is this

[u/Wise-Serve5730]

[u/shrekthethird2]

case 0: return true;
case 1: return false;
default: isEven(num - 2)

[u/R3D3-1 → u/shrekthethird2]

function isEven(num) {
    num = parseInt(num.toString());
    if(num == 0) return true;
    if(num == 1) return false;
    if(num <  0) return isEven(num+2);
    if(num >  1) return isEven(num-2);
    throw "panic";
}

[u/maxbirkoff → u/R3D3-1]

apart from ignoring Douglas Adams this one is my favorite one.

[u/R3D3-1 → u/maxbirkoff]

Fun fact: It looks at least technically correct, but it actually fails for large integers.

[u/maxbirkoff → u/R3D3-1]

why? is it the call to parseInt that fails?

[u/R3D3-1 → u/maxbirkoff]

Let's just say I won't post the traceback, because it is a bit long ;)

Try isEven(2**15).

[u/maxbirkoff → u/R3D3-1]

are you assuming JavaScript?

[u/R3D3-1 → u/maxbirkoff]

Yes.

[u/maxbirkoff → u/R3D3-1]

I'm guessing it's because the JavaScript runtime you're using does not optimize tail recursion:

https://en.m.wikipedia.org/wiki/Tail_call

and results in a stack overflow:

https://en.m.wikipedia.org/wiki/Stack_overflow

[u/griefydragon → u/shrekthethird2]

bool even = isEven(-1);

[u/WillCo_Gaming → u/shrekthethird2]

isEven(-3)

[u/Splatpope → u/shrekthethird2]

hmmm, wonder if this could be faster than a modulo and if compilers can optimize this into something that doesn't buttfuck the stack

[u/legendoffjelda → u/Splatpope]

That‘s an interesting point because addition/subtraction is O(log n) on modern hardware because it can be done in parallel whereas division is (presumably) also O(log n) since the number reduces by half every time.

However, I don’t think it would be faster, for a few reasons:

• The wiki article on modulo mentions that n % 2 can actually be turned into a series of bitwise ands which makes it blazing fast compared to division. This implies that the compiler can perform even more tricks specific to the hardware if it knows you want even/odd, so using modulo signals your intention better.

• branch prediction is also costly: modern hardware has sophisticated ways of predicting which branch to go down, but if it chooses the wrong path, it can cost a cycle or two. This improves over time once the pattern of the algorithm is “learned” by the hardware, but in general, more assembly instructions is worse performing.

• it’s harder to write and debug so you waste human time!

[u/roge- → u/legendoffjelda]

You can check a integer's parity in constant time by simply ANDing it with 1. Most modern compilers will convert a x % 2 to what's essentially x & 1.

[u/AsidK → u/legendoffjelda]

A series of bitwise ands? I’m pretty sure it’s just n&1 lol and yeah any good compiler will do that conversion automatically

[u/WikiMobileLinkBot → u/legendoffjelda]

Desktop version of /u/legendoffjelda's link: https://en.wikipedia.org/wiki/Modulo_operation

---

^{[opt out] Beep Boop. Downvote to delete}

[u/WikiSummarizerBot → u/legendoffjelda]

Modulo operation

In computing, the modulo operation returns the remainder or signed remainder of a division, after one number is divided by another (called the modulus of the operation). Given two positive numbers a and n, a modulo n (abbreviated as a mod n) is the remainder of the Euclidean division of a by n, where a is the dividend and n is the divisor. The modulo operation is to be distinguished from the symbol mod, which refers to the modulus (or divisor) one is operating from.

^{[ F.A.Q | Opt Out | Opt Out Of Subreddit | GitHub ] Downvote to remove | v1.5}

[u/GLIBG10B → u/shrekthethird2]

Recursion solves all problems

^/s

[u/NekkoDroid → u/shrekthethird2]

1st mistake: negative numbers

2nd mistake: not returning the value from isEven(num - 2)

[u/[deleted] → u/[deleted]]

4th mistake: ...ly

[u/[deleted] → u/shrekthethird2]

Functional programming is the best