They call me a StackOverflow expert:
private bool isEven(int num) { if (num == 0) return true; if (num == 1) return false; if (num ＜ 0) return isEven(-1 * num); return isEven(num - 2); }bool isEven(int num) { return num == 0 || !isEven(num - (num > 0 ? 1 : -1)); }Damn that’s some solid optimization.
StackoverflowException.
What do I do now?
Nvm. Got it.
if(num % 2 == 0){ int num1 = num/2 int num2 = num/2 return isEven(num1) && isEven(num2) } if(num % 3 == 0){ int num1 = num/3 int num2 = num/3 int num3 = num/3 return isEven(num1) && isEven(num2) && isEven(num3) }Obviously we need to check each part of the division to make sure if they are even or not. /s
Man I love how horrible this is!
…a recursive is-even
wow
I shit you not but one coworker I had dared call himself a data scientist and did something really similar to this but in Python and in production code. He should never have been hired. Coding in python was a requirement. I spent a good year sorting out through his spaghetti code and eventually rebuilt everything he had been working on because it was so bad that it only worked on his computer and he always pip freezes all requirements, and since he never used a virtual environment that meant we got a list of ALL packages he had installed on pip for a project. Out of those 100, only about 20 were relevant to the project.
In prod??
Listen up folks. This is why we do code reviews. This right here.
Code reviews mean fuck all when the “senior” developer doing the review is someone who implements an entire API endpoint group in one single thousand-something lines magic function that is impossible to decipher for mere humans.
A few members of my team were reviewing codes but lots of PRs could be merged without tests or checks passing and only about 2 people before I joined understood what cicd is, no one else believed in its importance. They thought doing otherwise would “slow down the work precess and waste time, we know what we’re doing anyway!”.
I learned a lot from having to implement best practices and introduce tests in teams that don’t give a fuck or were never required to do it. I’m amazed at the industry standards and fully understand why job ads keep listing git as a requirement.
That’s something I would do
Just print True all the time. Half the time it will be correct and the client will be happy, and the other half the time, they will open a ticket that will be marked as duplicate and closed.
Reminds me of the fake thermometers being sold during the peak of COVID that weren’t actually thermometers but just displayed numbers to make people think they were.
I definitely have one of these.
Wow. Amateur hour over here. There’s a much easier way to write this.
A case select:
select(number){ case 1: return false; case 2: return true; }And so on.
Don’t forget that you can have fall-through cases, so you can simplify it even further:
switch (number) { case 1: case 3: case 5: case 7: case 9: ...Teach me
Just do a while loop and subtract 2 if it’s positive or plus 2 is it’s negative until it reaches 1 or 0 and that’s how you know, easy! /s
God, it’s so obvious, you can do it in only two lines of code.
if (number == 1 || number == 3 || number == 5 || number == 7 || number == 9...) return false; else return true;Obviously you couldn’t account for every number with only two lines.
Maybe you couldn’t
Eventually, it would wrap onto a second line, wouldn’t it?
When you run out of space, you just add a monitor to the right side. Honestly, it’s like you guys aren’t real developers.
Only if your line is not long enough…
This is your brain on python:
def is_even (num): return num in [x*2 for x in range(sys.maxsize / 2)]That won’t work tho, you need to make it sys.maxsize//2 to coerce the output into int form
range()accepts floats, does it not?IIRC it doesn’t; that has caused me pain so many times when trying to generate fractional range
The number of comments posting a better solution is funny and somewhat concerning.
Yeah, “just use modulo” - no shit, you must be some kind of master programmer
amateurs
def is_even(n: int): if n ==0： return True elif n < 0: return is_even(-n) else: return not is_even(n-1)here’s a constant time solution:
def is_even(n: int): import math return sum(math.floor(abs(math.cos(math.pi/2 * n/i))) for i in range(1, 2 ** 63)) > 0spoiler
i can’t imagine how long it’ll take to run, my computer took over 3 minutes to compute one value when the upper bound was replaced with 230. but hey, at least it’s O(1).
Nice, how about bitwise & operator?
// n&1 is 1, then odd, else even return (!(n & 1));
Don’t use recursion. Each call will need to allocate a new stack frame which leads to a slower runtime than an iterative approach in pretty much any language.
TCO baby
Since when did Python have tail call optimization?
Just in case anyone was looking for a decent way to do it…
if (((number/2) - round(number/2)) == 0) return true; return false;Or whatever the rounding function is in your language of choice.
EDIT: removed unnecessary else.
Modulo operator my dude.
Every bit aside for the ones bit is even. All you have to do is get the ones bit(the far right) for it being a 1 or 0. Which is the fastest and least amount of code needed.
use bitwise &
// n&1 is true, then odd, or !n&1 is true for even return (!(n & 1));Huh?
return number % 2 == 0
That’s the only sane solution.
Do note how I said “a decent” way, not “the best” way. Get that huh outta here.
Or modulo %
private bool IsEven(int number){ return number % 2 ? false : true; }
number % 2 == 0 and (number & 0b1) == 0Are the only sane ways to do this. No need to floor. Although If its C and you can’t modulo floats then (number/2 == floor(number/2))
If you are using floats, you really do not want to have an isEven function …
Whats the alternative a macro? An inline function is perfectly fine for checking if a nunber is even. Compiler will probably optimize it to a single and instruction.
No. The alternative is to not use a float. Testing if a float is even simply does not make sense.
Even testing two floats for equality rarely makes sense.
What is the correct output of isEven((.2 + .4) ×10)
Hint: (.2 + .4) x 10 != 6
It does if it dosen’t have a decimal. If it has decimal then it automatically isn’t and the function will return false. Are you talking about cases like 0.1 + 0.2 equaling 0.3000000004 because that is just due to the nature of floats and there is nothing a function can do other than use larger floats for more accuracy.
Take out the
elseand I’m inValid point.
You have to make it easy on yourself and just use a switch with default true for evens, then handle all the odd numbers in individual cases. There, cut your workload in half.
while (true){ if (number == 0) return true; if (number == 1) return false; number -= 2 }return !(number % 2)
Setting number to -1 might cause you to wait a while.
You know, shortly after posting this I did think about whether it’s still working if I just pass the underflow that will happen at some point or if I have to fix something in that case (like subtract 1 after the underflow). I deemed it “too complicated” and would just issue a warning that my code is only tested on positive numbers, but I think it will still work.
deleted by creator
Because YandereDev is a legendary moron I can’t even tell if this is a joke or not.
How do you think even/odd detectors work? A team of coders has been working on this else if for years…
If you want to help
I haven’t ever seen a GitHub file that big before in my life
Would be easier to make a script to write that script honestly
imagine generating this at runtime
It’s a re-attribution of a joke tweet made by someone else.
Just do
npm install isEvenand don’t worry about it.looks like it depends on isOdd, which is unmaintained. I have a dependency conflict, what should I do?
Extract an interface and let the consumer supply the implementation.
Still some of YandereDev’s best code
Good job my young padawan, let me teach you about the modulo operator …
Actually the modulo operator is the wrong solution.
No its not the wrong solution! Premature optimization is a waste of time.
Using if or case are not a solution because they are way too verbose and very easy to introduce an error.
Modulo is a solution, and using bit-wise and is another faster solution.
It’s only the wrong solution if you’re writing something where every operation needs to be accounted for. Modulo is a great, easy, readable method otherwise.
Not too certain on C++, but I think this would be the cleanest implementation that still somewhat optimizes itself:
private bool IsEven(int number){ return !(number % 2) }You call it premature optimization. I call it obvious.
You use a flat head as a Phillip’s.
You can call it whatever you like, the fact of the matter remains - code readibility is more important than most optimizations you can ever hope to make.
Bad programmers optimize everything and produce code that is not understandabe and 0.001% “faster”
Optimization isn’t inherently better than Readable code.
What’s most important is what matters to your project.
If your project manages itself with limited resources, Optimization is better than Readable code, and it should be supplemented with comments.
If your project has a wealth of resources, readable code is probably the better option.
The “This is the ONLY WAY” mindset in coding is the only thing that I would argue is completely wrong. The “One-size fits all” mindset in development is short sighted, sure. but what makes it the worst, is when it becomes “One-Size fits all ONLY”.
“One-size fits all” means the project runs well on everything. “Optimized for one” means the project runs exceptionally on one Architecture/OS.
Basically, this situation is the highly unsatisfying “It’s your preference”.
But given the context of Yandere Dev and the Target Audience of Yandere Simulator, his code is perfect. It’s code that runs terribly on everything and the project is for no one.
Okay wow no need to get personal.
I call it making assumptions that may be incorrect, and do you know if the compiler will do the optimization anyway in this case?
What statement do you flag as assumption? Yes, I do. The modulo operator is only a subset of bit masks. It is more explicit to write:
if ( (variable &EVEN_MASK) == 0) …
To act upon even numbers then:
if ( (variable %2) == 0) …
How would you name the 2 in the above statement for more expressive power?
EVEN_MODULO_OP ? That may throw more people off imo.
You shouldn’t rename 2 at all. “Even” has a commonly understood meaning that is instantly recognizable from
(variable %2) == 0. The bitmask is an overgeneralization.I give up, I was wrong to even think about the modulo operator, you are clearly the master programmer. 🥇
This reminds me of a discussion about the ternary operator
? :, some people think its the one true way of writing code because its just so clear what it does. And I say please use it sparingly because if you start doing nested ternary operators its very hard to unpack what your code does, and I prefer readability over compact code, especially with today’s compilers.I feel you said about JavaScript as a whole.
Psh screw those people, they need to see my massive coder wang
if(!i&1){ ... }
Wrong means that it doesn’t produce the right output.
How is the modulo operator the wrong solution?
You are right. I have been biased.
https://realpython.com/python-modulo-operator/#how-to-check-if-a-number-is-even-or-odd
I just wonder why module is the wrong solution.
Not neccessarily wrong, but you could also check the first bit. If it’s 1 the number is uneven, if it’s 0 the number is even. That seems to be more efficient.
That’s what I was thinking too… Although, I wouldn’t be surprised if most languages convert modulo 2 to this automatically.
That could also be the case.
That’s the main issue with premature optimization: do it the “optimized” way and it may still be inefficient, or do it the obvious way and let the compiler turn it into its most optimized form. (Of course, not the case with all languages, but most mainstream compilers optimize the code to a decent extent.)
Modern compilers and interpreters are smart enough to figure out what you’re trying to do and automatically do that for you.
Huh… That makes sense. Til. Ran some tests but speed is pretty similar. Only 4% faster using bitmath or 300 milliseconds difference after 10mil runs.
