We can avoid expensive branches (gasp) by using some bitwise arithmetic to achieve the so-called “absolute value”, an advanced hacker technique I learnt at Blizzard. Also unlike c, c# is not enlightened enough to understand that my code is perfect so it complains about “not all code paths returning a value”.
private bool IsEven(int number)
{
number *= 1 - 2*(int)(((uint)number & 2147483648) >> 31);
if (number > 1) returnIsEven(number - 2);
if (number == 0) returntrue;
if (number == 1) returnfalse;
thrownewException();
}
Why return book? Does that have some Blizzard reference?
And why would number == 2 ⇒ returnfalse? This is a function for getting true when the number is even, right?
After working at blizzard for 51 years, I finally found an elegant solution by using the power of recursion
private bool IsEven(int number){ if (number > 1) return IsEven(number - 2); if (number == 0) return true; if (number == 1) return false; }assert IsEven(-2);Now see, you need the other method. IsNegativeEven()
We can avoid expensive branches (gasp) by using some bitwise arithmetic to achieve the so-called “absolute value”, an advanced hacker technique I learnt at Blizzard. Also unlike c, c# is not enlightened enough to understand that my code is perfect so it complains about “not all code paths returning a value”.
private bool IsEven(int number) { number *= 1 - 2*(int)(((uint)number & 2147483648) >> 31); if (number > 1) return IsEven(number - 2); if (number == 0) return true; if (number == 1) return false; throw new Exception(); }I removed the tail recursion for you:
private book IsEven(int number) { if(number > 1) return IsEven(number - 2) == true; if(number == 0) return true; if(number == 2) return false; }What’d be the result for
IsEven(1)?Stack overflow
I didn’t get this.
Why return
book? Does that have some Blizzard reference?And why would
number == 2⇒return false? This is a function for gettingtruewhen the number is even, right?Haha, you’re right. I’ve now learned two things:
At the end of the day i just wanted the function to be worse, by causing stack overflows