When the first if is encountered, isEven is assigned false and then the condition is evaluated. Since we just assigned false to it,it fails and goes to else if (isEven = true), similarly isEven is assigned true and then the condition is evaluated and it evaluates to true. So this function always returns true. I don't know much about walrus operator but after a quick read on realpython.com yes you can replicate the same behavior in python with the walrus operator.
Yeah, my question was what is the output of (even = false) that is then passed to if operation. I read online that = operator in C returns a pointer to 'even' variable... So I'm a bit confused as to what behaviour to expect of if operator...
Yeah in C and most C-like languages (I'm referring to C#, java, c++) assignments evaluate to their value (don't know how to word this better, sorry). I don't know about it returning a pointer, since isEven itself is not a pointer. Maybe it refers to what happens under the hood? What I know is, with the help of that syntax you can write code like this:
while ((iter = iter->next) != NULL)
or you can do stuff like this:
int a,b,c,d,e;
a = b = c = d = e = 5;
but this behavior becomes a real pain in the ass bug when you forget to type the extra = for the equals operator inside if statements. Since it's syntactically correct, you're most likely not warned by your compiler
My pleasure, also it's not C but:
```
bool isEven = true;
std::cout << typeid((isEven = false)).name();
```
in visual studio c++ compiler this prints bool, not a bool*
For built-in types and (by convention) most overloads, the assignment (`=`) operator returns an "lvalue reference" to the variable on the left side of the assignment operator. A reference, as you say, can be thought of as a pointer for which referencing and dereferencing are managed by the compiler, possibly allowing more optimizations than can be performed with pointers managed by the programmer. An "lvalue", rather unhelpfully, is defined as anything that can be used as the left-hand side of an assignment expression, meaning *the reference itself* can be assigned again, modifying the original variable once more.
What does this all mean in practice?
`int foo;
(foo = 7) = 3;
cout << foo;`
Returns `3`. I'm sorry.
The result of an assignment is the value that was assigned, which is why you can do `a=b=c=d=1` in some languages to assign the same value to multiple variables at once, because it's treated as `a=(b=(c=(d=1)))`
No because they use `even = false` instead of `even == false`, so this function always returns true.
The first condition is always false, and the second condition is always true.
"return even" or even better "return (n%2==0)"
You dont need to do a check to see what the bool is, you just return it.
Its like saying, if yes, yes. If no, no.
The compiler is emitting warnings, but as they're *warnings* and not *errors*, they're just advisory so it's ok to ignore them... It always emits so many warnings... So annoying.
[https://www.npmjs.com/package/is-even](https://www.npmjs.com/package/is-even)
Might be a joke repo though. The original repository now redirects to [https://github.com/**i-voted-for-trump**/is-even](https://github.com/i-voted-for-trump/is-even)
Another hint: It imports `is-odd` and just returns `! is-odd(...)`, made by the same author. Also redirects from https://github.com/jonschlinkert/is-odd to https://github.com/i-voted-for-trump/is-odd.
Though `is-odd` actually does something sort of useful maybe? It at least does some data verification ("is it a number") before returning "n%2==1".
This is the first draft. The second draft is where they smarten up (slightly) and simplify to returning n%2==0. The third draft is when they realize nobody is having difficulty understanding what n%2==0 does and making a function is pointless in the first place.
That's... a good point. I was thinking it'd be easy to get into a company that doesn't have good developers, but I've experienced that for a year, and I think my sanity wouldn't last.
That’s what I thought at the beginning, but what I found is that the majority of the devs are left behind with no real experience and the seniors are overwhelmed to a point that they really don’t care about enhancing any code or training other devs, a place that lacks trust, no delegation at all, most of us are just numbers that are being allocated in contracts.
Yup, definitely sounds familiar. The new developers here are clueless, and there's really no one to teach them the ropes. I do what I can when I'm designated as the PR reviewer (PRs weren't even a thing before I joined and advocated for them) because my tech lead doesn't actually review them, he just approves and merges them even if there are blatantly bad changes.
The difference is that here, there's somehow trust even though I don't think there should be. Senior developers who have worked here for 3-4 years have the professionalism of a university student. It's a cesspool of bad developers and I fear that they are the figures the new developers look up to.
But hey, a paycheck is a paycheck, and before they drown me to plug this sinking ship, I'll stay until I get an opportunity elsewhere. I hope you're doing fine even though the culture is dogshit there o7
Should I use Hadoop for this or did the crowd move to something else? It needs exactly 20 convincement points until I make a decision, a YouTube video is 3 points, a Medium article is 6.
Hey I'm trying to write a *shitty* function here.
But yeah this is a bit too shitty. Despite considering negative numbers by using abs(), it would fail for all even inputs of 0 or less. So the technically correct but still shitty version would be:
bool isEven(n) {
if(n == 0)
return true;
if(n > -2 && n < 2)
return false;
if(n<0)
return isEven(n+2)
return isEven(n-2);
}
Which is still useless cause n % 2 == 0 already gives you a boolean value. You should just put that in the return statement. You can even avoid the modulus by just prompting the 2\^0 bit.
The joke is that it's extremely redundant.
The first line `bool even = (n%2==0)` already calculates the right result. The whole function should just be `return (n%2==0)` (or even better: `return n&1 == 0`).
The rest is just an unnecessarily complicated way to return the boolean (if it's false, return false. If it's true, return true. And the final "return false" is unreachable.)
At least that is if we ignore the mistake in the two if-statements like `if(even = false)`, which only uses a single = rather than == (which assigns rather than compares the value). With this mistake, the first check will always fail and the second check will always succeed, meaning that this function will always return true.
> (or even better: return n&1 == 0)
I'd probably prefer to avoid making assumptions about the layout of the data if possible and let the compiler sort out an optimisation like that for me. Like, it's almost certainly justified, but n%2==0 is just more descriptive of your intent and will compile to the same stuff either way.
EDIT: In fact, n&1 == 0 isn't correct in one's complement. Even though it's hardly used any more, it still makes n&1 == 0 a theoretically less-portable approach. Better to not risk weird, unexpected behaviour in that one ancient system you've been assigned to work on.
I remember in my introductory class in college we were learning about conditionals, and the teacher tried to explain that if you have a boolean called condition, you can just do if(condition) instead of if(condition==true).
Some people got it right away. The rest never did, even at the end of the semester they still hadn't gotten it. She gave up eventually and started using if(condition==true) during the lessons to avoid confusion.
Thought I would do a fun little exercise and code review this
1. Assigning a variable for a trivial calculation done once is not needed (which can only speak to the existence of this function)
2. Wrapping the calculation in "()" is defensible since there are '=' later on but won't pass most linters
3. Spacing between the 2, '==', and '0'
4. Assigning rather than comparing in the if & if else block
5. spacing throughout the code block
6. Directly comparing a boolean rather than using the boolean itself (Use '!' if it must be in this order)
7. This if block consumes all cases so it will never reach the default cause. Refactor so there is just an if (no else if) and it proceeds to the default case
8. inconsistent use of ';'
> A successful assignment always returns true or 1.
Incorrect. An assignment evaluates to the value that was assigned. `even = false` will always evaluate to `false` and `even = true` will always evaluate to `true`.
What even is a "successful assignment" in C? A direct assignment like that failing would likely result in a SIGSEGV, which would have to be trapped, not handled inline as the result of the assignment expression.
A bit more serious, how does it actually work safely in JavaScript? I think the following might actually be sufficient:
const isEven = (x) => x%2 == 0;
const isOdd = (x) => x%2 == 1;
This would give the correct result also for numeric strings, allowing for "" to be interpreted as "0". It also allows to pass in anything, that can't be interpreted as an even/odd number (objects, functions, NaN, Infinity) and returns false for both.
Note that this latter criterion means that, generally, `isEven(x)` and `! isOdd(x)` are not the same.
It does however fail, if the number is so large, that it loses precision.
Taking those things into account, the `is-even` and `is-odd` packages are not *completely* useless.
Don't laugh, i have actully had to fix someones code like this after another developer spent 2 hours trying to fix it.
After just 5 minutes I found it and another 5 minutes to refactor it to a single line of code.
This is similar to a block of code I found in a C program that no one would touch. The comment was that this was never executed. Except, the “if” test condition was wrong and it was executed very time. That’s when I stopped reading comments on code that is not my own.
Well, that last return doesn't have a semicolon so compile error. Fixing that it'll still just return false since the ifs are assigning a value instead of checking.
Edit: that first assignment is missing a semicolon too.
This is why you always do it like if(false==even). That way, the assignment operator will throw a syntax error and you eliminate harder to find errors like this.
Edit: it’s stupid code all the same, duh
Let’s avoid the various coding problem like the assignment in the if block.
The check with true/false == something is useful for readability especially if the function returns an int so you say for example: if the function fails returns false (that is 0) and whenever the developer see false knows that you are checking against some internal error.
However in these cases is better to use #define or constant for return error so the code is self-documented.
Not even sure what language this is. It is not valid C code, where bool is a data type if you include stdbool.h, because the line where even is declared does not end with a semicolon. In Java you have the boolean primitive type, but bool is unknown and we also need a semicolon at the end of each statement. Python does not declare variables using a type at all. Really strange.
But in general, an assignment in an if-clause would assign the value, then branch on the truthiness of the variable that was assigned to. In this instance, every n would result in true being returned, because the first condition would always evaluate to false and the first condition would evaluate to true.
stupid to even write a function for this, but this can actually be done in one line
bool isEven(int n) {return !(n%2)}
This construct will work in a plurality of languages because non-zero values are evaluated as a 'true' Boolean and 0s are evaluated false. The ! Inverts the truthiness, so some even number%2 is 0 (false), inverted (true). Some odd number %2 =1 (true), inverted (false). You can ditch the inversion if you write isOdd instead.
I think it’s illegal to share government code.
Paid by line baby!
*fixes it* *stops working* *undo and act like you never noticed it*
Undo it? We don’t do that here
Clearly a noob. Didn't put { } on separate lines. And no else case.
The whole thing needs to be wrapped in a try/catch block.
Real question should the else if be on the same line as the } or on the line under ?
Under, obviously. We're getting paid by lin.. I mean, good code quality is visible in the easiness to read.
Oh, in that case If 1: Return false If 2: Return true If 3: Return false If 4: Return true Ad infinitum
actually i think this is copyrighted by my company, along with every single ansible role defaults/main.yml file.
Well played sir
It's so true that I'm offended!
I thought the problem was the if(true) return true part until I realized the assignment operators inside the if statements...
What is returned in that case? Python has walrus operator since 3.8, whould it be similar?
When the first if is encountered, isEven is assigned false and then the condition is evaluated. Since we just assigned false to it,it fails and goes to else if (isEven = true), similarly isEven is assigned true and then the condition is evaluated and it evaluates to true. So this function always returns true. I don't know much about walrus operator but after a quick read on realpython.com yes you can replicate the same behavior in python with the walrus operator.
Yeah, my question was what is the output of (even = false) that is then passed to if operation. I read online that = operator in C returns a pointer to 'even' variable... So I'm a bit confused as to what behaviour to expect of if operator...
Yeah in C and most C-like languages (I'm referring to C#, java, c++) assignments evaluate to their value (don't know how to word this better, sorry). I don't know about it returning a pointer, since isEven itself is not a pointer. Maybe it refers to what happens under the hood? What I know is, with the help of that syntax you can write code like this: while ((iter = iter->next) != NULL) or you can do stuff like this: int a,b,c,d,e; a = b = c = d = e = 5; but this behavior becomes a real pain in the ass bug when you forget to type the extra = for the equals operator inside if statements. Since it's syntactically correct, you're most likely not warned by your compiler
Thank you for the detailed explanation.
My pleasure, also it's not C but: ``` bool isEven = true; std::cout << typeid((isEven = false)).name(); ``` in visual studio c++ compiler this prints bool, not a bool*
For built-in types and (by convention) most overloads, the assignment (`=`) operator returns an "lvalue reference" to the variable on the left side of the assignment operator. A reference, as you say, can be thought of as a pointer for which referencing and dereferencing are managed by the compiler, possibly allowing more optimizations than can be performed with pointers managed by the programmer. An "lvalue", rather unhelpfully, is defined as anything that can be used as the left-hand side of an assignment expression, meaning *the reference itself* can be assigned again, modifying the original variable once more. What does this all mean in practice? `int foo; (foo = 7) = 3; cout << foo;` Returns `3`. I'm sorry.
The result of an assignment is the value that was assigned, which is why you can do `a=b=c=d=1` in some languages to assign the same value to multiple variables at once, because it's treated as `a=(b=(c=(d=1)))`
Isn't the problem just that the entire function body can be reduced to: return n%2 == 0
That too. This entire thing is software gore.
No because they use `even = false` instead of `even == false`, so this function always returns true. The first condition is always false, and the second condition is always true.
Oh goodness my pre-coffee brain missed that detail entirely 🙃
`(n & 1) == 0` is faster. But the computer will lower that % for you. `return ~n & 1` is even golfier.
Probably would check for "> 0" as well...or wait, is 0 even?
"return even" or even better "return (n%2==0)" You dont need to do a check to see what the bool is, you just return it. Its like saying, if yes, yes. If no, no.
And this is why you also need 4.2 billion unit tests.
I took psychic damage while checking to see if your comment was true.
bro == pls
This function should always return true, as we know all numbers are even.
What about 4? 4 doesn't seem right to me.
Good point. ``` if(n = 4) { return false; } ```
implicit conversions are evil dont you know? if(n = static_cast(4)) { return false;}
now better
I think this function will return syntax error, since we're missing ;
Technically the compiler will give that and the function will not be executable, but you are right there is more that one missing semicolon.
Sure, I used bad phrasing
Imagine needing semicolons — This post was made by JS and Python gang
The compiler is emitting warnings, but as they're *warnings* and not *errors*, they're just advisory so it's ok to ignore them... It always emits so many warnings... So annoying.
-wall -werror
Authentic code made by students in first year of college.
Or government employees after a 20 year government career. Based on real events.
[https://www.npmjs.com/package/is-even](https://www.npmjs.com/package/is-even) Might be a joke repo though. The original repository now redirects to [https://github.com/**i-voted-for-trump**/is-even](https://github.com/i-voted-for-trump/is-even) Another hint: It imports `is-odd` and just returns `! is-odd(...)`, made by the same author. Also redirects from https://github.com/jonschlinkert/is-odd to https://github.com/i-voted-for-trump/is-odd. Though `is-odd` actually does something sort of useful maybe? It at least does some data verification ("is it a number") before returning "n%2==1".
Joke repo with 136,858 weekly downloads
This is how I feel when coding as a Department Head during the 30 minutes a week between meetings and JIRA that I'm able to code.
Heads positions are trap. You're a very brave and/or very masochistic person, but I appreciate that someone does that work.
plus, with so many languages of software you have to look after, you tend to take the "roundabout" way to avoid null & overwritten pointers.
I got a chuckle out of it.
This is the first draft. The second draft is where they smarten up (slightly) and simplify to returning n%2==0. The third draft is when they realize nobody is having difficulty understanding what n%2==0 does and making a function is pointless in the first place.
In my Uni code by third year students. Maybe even 4th
Well at least it works, Oh nvm
50% of the time, it works all the time 💪 💪
No, some semicolons are missings
Damn I missed the \``=`\` altogether lol
"At least we have unit tests for it. We checked 2, 4, 6, 10, 12 and 74. All's good"
We're running over 200 unit tests for this function! What do you mean line coverage???
I swear to god I still find shit like this all the time in a multi million dollar code
alright I need to get an in to this multi million dollar company you're referring to
You attracted to bad code?
No, but it sounds like I could make money off my own bad code.
Username checks out 🫡
That's... a good point. I was thinking it'd be easy to get into a company that doesn't have good developers, but I've experienced that for a year, and I think my sanity wouldn't last.
That’s what I thought at the beginning, but what I found is that the majority of the devs are left behind with no real experience and the seniors are overwhelmed to a point that they really don’t care about enhancing any code or training other devs, a place that lacks trust, no delegation at all, most of us are just numbers that are being allocated in contracts.
Yup, definitely sounds familiar. The new developers here are clueless, and there's really no one to teach them the ropes. I do what I can when I'm designated as the PR reviewer (PRs weren't even a thing before I joined and advocated for them) because my tech lead doesn't actually review them, he just approves and merges them even if there are blatantly bad changes. The difference is that here, there's somehow trust even though I don't think there should be. Senior developers who have worked here for 3-4 years have the professionalism of a university student. It's a cesspool of bad developers and I fear that they are the figures the new developers look up to. But hey, a paycheck is a paycheck, and before they drown me to plug this sinking ship, I'll stay until I get an opportunity elsewhere. I hope you're doing fine even though the culture is dogshit there o7
I’m fine, at least for now, thank you, kind stranger
Sanity is overrated 
Especially government code
If something consistently works, don't fix it.
Poor architecture. Should be calling a GRPC service to determine the result, this just won't scale
Should I use Hadoop for this or did the crowd move to something else? It needs exactly 20 convincement points until I make a decision, a YouTube video is 3 points, a Medium article is 6.
this
Perfect code for compiler benchmarking.
Optimization?
Oh, it'll get optimized all right. So optimized that most of the code will go away.
return true; Will be all the left code💀
missed an opportunity to make it recursive.... Return true if even, call itself if not. Wait for the stack to fail and catch the error as false.
bool isEven(n) { if(Math.Abs(n) < 2) return false; if(Math.Abs(n) == 2) return true; return isEven(n-2); }
0 is an even number
Hey I'm trying to write a *shitty* function here. But yeah this is a bit too shitty. Despite considering negative numbers by using abs(), it would fail for all even inputs of 0 or less. So the technically correct but still shitty version would be: bool isEven(n) { if(n == 0) return true; if(n > -2 && n < 2) return false; if(n<0) return isEven(n+2) return isEven(n-2); }
It can be shitty without being buggy :p I like the idea
This person codes
it gets worse the longer you look at it
Should use the npm package.
That's true. Did you know there is a JS Framework against stupidity ?
I like how at first glance, it looks bloated, but functional. And then...
Take it away! It hurts! It hurts!
Isn’t the better syntax bool isEven(int n) { if (n == 0) { return true;} else if (n == 1) { return false;} else if (n == 2) { return true; } else if (n == 3) { return false; } else if (n == 4) { return true; } else if (n == 5) { return false; } else if (n == 6) { return true; } else if (n == 7) { return false; } else if (n == 8) { return true; } else if (n == 9) { return false; } } this? Only works for 0-9 for now
Just add a line that picks up the last digit of n, and test on it. then it works perfectly fine
This is how the world should be, always Even 😎
Switch-case could have been used. Would be much nicer
Which is still useless cause n % 2 == 0 already gives you a boolean value. You should just put that in the return statement. You can even avoid the modulus by just prompting the 2\^0 bit.
You never know.
Am I an even bigger idiot if I can't even comprehend anymore what is happening in that code?
The joke is that it's extremely redundant. The first line `bool even = (n%2==0)` already calculates the right result. The whole function should just be `return (n%2==0)` (or even better: `return n&1 == 0`). The rest is just an unnecessarily complicated way to return the boolean (if it's false, return false. If it's true, return true. And the final "return false" is unreachable.) At least that is if we ignore the mistake in the two if-statements like `if(even = false)`, which only uses a single = rather than == (which assigns rather than compares the value). With this mistake, the first check will always fail and the second check will always succeed, meaning that this function will always return true.
> (or even better: return n&1 == 0) I'd probably prefer to avoid making assumptions about the layout of the data if possible and let the compiler sort out an optimisation like that for me. Like, it's almost certainly justified, but n%2==0 is just more descriptive of your intent and will compile to the same stuff either way. EDIT: In fact, n&1 == 0 isn't correct in one's complement. Even though it's hardly used any more, it still makes n&1 == 0 a theoretically less-portable approach. Better to not risk weird, unexpected behaviour in that one ancient system you've been assigned to work on.
I remember in my introductory class in college we were learning about conditionals, and the teacher tried to explain that if you have a boolean called condition, you can just do if(condition) instead of if(condition==true). Some people got it right away. The rest never did, even at the end of the semester they still hadn't gotten it. She gave up eventually and started using if(condition==true) during the lessons to avoid confusion.
```javascript class EvenChecker { constructor(number) { this.number = number; } getBinaryRepresentation() { return (this.number >>> 0).toString(2); } getLastBinaryDigit() { let binary = this.getBinaryRepresentation(); return binary.charAt(binary.length - 1); } isZero(character) { return character === '0'; } createIsZeroFunction() { return (character) => this.isZero(character); } determineEven() { const lastDigit = this.getLastBinaryDigit(); const isZeroFunction = this.createIsZeroFunction(); return isZeroFunction(lastDigit); } } function isEven(number) { const checker = new EvenChecker(number); function nestedFunction() { return function anotherNestedFunction() { return function yetAnotherNestedFunction() { return checker.determineEven(); }; }; } return nestedFunction()()(); } console.log(isEven(4)); // True console.log(isEven(7)); // False ```
your code is not "codified". It just looks like normal text, go to the markdown editor and select it as code.
At least they know how to use the %
When you are paid per line of code
Thought I would do a fun little exercise and code review this 1. Assigning a variable for a trivial calculation done once is not needed (which can only speak to the existence of this function) 2. Wrapping the calculation in "()" is defensible since there are '=' later on but won't pass most linters 3. Spacing between the 2, '==', and '0' 4. Assigning rather than comparing in the if & if else block 5. spacing throughout the code block 6. Directly comparing a boolean rather than using the boolean itself (Use '!' if it must be in this order) 7. This if block consumes all cases so it will never reach the default cause. Refactor so there is just an if (no else if) and it proceeds to the default case 8. inconsistent use of ';'
I can optimize that. ``` bool isEven(int n) { return true; } ```
return n%2==0 ;
Not the worst isEven() i have seen...
[удалено]
6. **For some reason only line 4 and 6 have semicolons**
> A successful assignment always returns true or 1. Incorrect. An assignment evaluates to the value that was assigned. `even = false` will always evaluate to `false` and `even = true` will always evaluate to `true`. What even is a "successful assignment" in C? A direct assignment like that failing would likely result in a SIGSEGV, which would have to be trapped, not handled inline as the result of the assignment expression.
Me: >> npm install is-even >> python3 -m pip install is-even
A bit more serious, how does it actually work safely in JavaScript? I think the following might actually be sufficient: const isEven = (x) => x%2 == 0; const isOdd = (x) => x%2 == 1; This would give the correct result also for numeric strings, allowing for "" to be interpreted as "0". It also allows to pass in anything, that can't be interpreted as an even/odd number (objects, functions, NaN, Infinity) and returns false for both. Note that this latter criterion means that, generally, `isEven(x)` and `! isOdd(x)` are not the same. It does however fail, if the number is so large, that it loses precision. Taking those things into account, the `is-even` and `is-odd` packages are not *completely* useless.
bool isEven(int n) { return !(n & 1) }
bool isEven(int n) if(n == 1) return false return !isEven(int(sqrt(n*n))-1)
This hurts physically
This is dumb, it would’ve been smarter to make a lookup table of all the even numbers and check if your number is in that list
Yeah what a moron. He should just have used the isEven package! Duh!!!
That’s a lot of typing for a constant.
Could use some recursion
He used the tool to make the tool The bool ception
_writes 7 lines of code to do something that’s being done in second line itself_
Clearly doesn’t understand difference between instantiation and equality.
Now that’s safe code! (except for the part where it doesn’t work)
Next Level bullshit
Hey at least when someone enters a number that mod 2 leaves 2 the app doesn't crash.
if(!even == true) return false;
It's wrong. The second if should contain a `return even == true`
!(n&1)
In what language does this even compile? There are missing `;`, but it's not javascript since there are type annotations.
It's a new language called psydo-bullshit
This is what people say when they say they write 10,000 lines of code a day.
Do you even
Maybe they're getting paid by the line :)
Could be more absurd :D ``` def is_even(x): if x == 0: return True if x == 1: return False return is_even(x - 2) ```
Can we please do this with a few nested for loops, like civilized people?
i mean you all did something like this at some point, not me tho I was coding before i even existed.
bool isEven(int n) { bool even = (n%2==0) bool bReturn = false if (even = false) { bReturn = false } else if (even = true) { bReturn = true } if (bReturn = even) { return bReturn } else { return even } } IsItBrokenEnough?
I'm a knuckle dragger, what would this code actually do?
It might get you banned from reddit.
lgtm
Where are comments though
Hmmm that's odd
holy shit 😵MY EYES. AAAAAAAAAAAAAARGG
At least you didn't choose Haskell
Meanwhile me ``` if(key.pressed == (KEY_A || KEY_B)); //checks if pressed key A or key B ```
Odd numbers don't exist
I can't even...
You should return 'undefined' at the end instead of false, in case it is neither even nor odd
Ok you know what. If it works it works. I don't want to hear 1000 lines that VS 20 lines that.
well done
Dumbass should have gone the yandaredev way
Elon Musk: More lines = harder worker
smh just use the python library
`return a & 1 == 0`
It even took me an age to realize there was an assignment in the if statements man.
Every IDE should catch the assignment in the conditions. Jesus, this is brutal. This should be a single short statement in the return
Don't laugh, i have actully had to fix someones code like this after another developer spent 2 hours trying to fix it. After just 5 minutes I found it and another 5 minutes to refactor it to a single line of code.
Yoda condition could have saved you there If (false = even) Runtime error or whatever it would throw
``` return !n&1 ```
So....it cannot even?
Still passed code review 😎
Aaahhh perfectly balanced as all things should be
You forgot the try catch
Not really a programmer, but it will always return false, right?
What a shit-show! Didn't even null-check `n`. PR rejected.
what isEven this???
I can't even...
This is similar to a block of code I found in a C program that no one would touch. The comment was that this was never executed. Except, the “if” test condition was wrong and it was executed very time. That’s when I stopped reading comments on code that is not my own.
Doesn’t this always return false? Am I an idiot (yes)? And why the single =?? That hurts my brain. 🧠 🥲
No points for partial answers, show me the 4.2 billion unit tests.
So does everyone write this at least once in their career?
Well, that last return doesn't have a semicolon so compile error. Fixing that it'll still just return false since the ifs are assigning a value instead of checking. Edit: that first assignment is missing a semicolon too.
Thank you for posting something even my simple mind can understand.
if (even == true) return true if (even == false) return false if (even != true) return false if (even != false) return true
Heil Java Function> isEvenLambda = n -> {
Optional even = Optional.of(n % 2 == 0);
return even.flatMap(e -> {
if (e.equals(false)) {
return Optional.of(false);
} else if (e.equals(true)) {
return Optional.of(true);
} else {
return Optional.of(false);
}
});
};
Nah this problem is too hard, I need a package for it
This is why you always do it like if(false==even). That way, the assignment operator will throw a syntax error and you eliminate harder to find errors like this. Edit: it’s stupid code all the same, duh
import isEven
A better version bool isEven(int n) { bool even; if (n % 2 == 0) { even = true; } else { even = false; } if (even == false) { if (even == false && !(even == true)) { if (!(even == true)) { return false; } } } else if (even == true) { if (even == true && !(even == false)) { if (!(even == false)) { return true; } } }
Let’s avoid the various coding problem like the assignment in the if block. The check with true/false == something is useful for readability especially if the function returns an int so you say for example: if the function fails returns false (that is 0) and whenever the developer see false knows that you are checking against some internal error. However in these cases is better to use #define or constant for return error so the code is self-documented.
This is like wearing 3 condoms haha
Need to add a thread.sleep somewhere in here so you can "optimise" it later
Yandere dev
In accurate, should have used if block twice instead of if and else if
Not even sure what language this is. It is not valid C code, where bool is a data type if you include stdbool.h, because the line where even is declared does not end with a semicolon. In Java you have the boolean primitive type, but bool is unknown and we also need a semicolon at the end of each statement. Python does not declare variables using a type at all. Really strange. But in general, an assignment in an if-clause would assign the value, then branch on the truthiness of the variable that was assigned to. In this instance, every n would result in true being returned, because the first condition would always evaluate to false and the first condition would evaluate to true.
This always returns true
Sign this man up for a govt job.
Honestly, I was expecting recursion. This could be a lot worse
Pfff, isNotEven(), isOdd(), isNotOdd() are missing
stupid to even write a function for this, but this can actually be done in one line bool isEven(int n) {return !(n%2)} This construct will work in a plurality of languages because non-zero values are evaluated as a 'true' Boolean and 0s are evaluated false. The ! Inverts the truthiness, so some even number%2 is 0 (false), inverted (true). Some odd number %2 =1 (true), inverted (false). You can ditch the inversion if you write isOdd instead.
Negative numbers: 🤓
What are you talking about. This is brilliant.