[milawynsrealm]

milawynsrealm, on 12 May 2011 - 06:53 PM, said:

Here's mine:

bool isEven(int f)
{
	return ((f & 1) ? true : false);
}

Sorry, didn't realize that Mod and & were the samething. I figured it was some sort of function. If I post another, it will be the correct version.

[Bench]

milawynsrealm, on 13 May 2011 - 06:06 PM, said:

milawynsrealm, on 12 May 2011 - 06:53 PM, said:

Here's mine:

bool isEven(int f)
{
	return ((f & 1) ? true : false);
}

Sorry, didn't realize that Mod and & were the samething. I figured it was some sort of function. If I post another, it will be the correct version.

Mod is not the same thing as &. In the context which you're using it, the & symbol represents the bitwise-AND operator.

[quantizer]

Spoiler

cout<<"Number is "<<if(

[RetardedGenius]

I hope I'm not too late to the game guys, this is the simplest method I could think of:

Spoiler

bool isEven(int f)
{
    return (f & 1) == 0 ? true : false;
}

Actually scrap that this also works, but with less characters of code! (I'm sure the other people in this thread have come up with much more elegant solutions.)

Spoiler

bool isEven(int f)
{
    return !(f & 1);
}

This post has been edited by RetardedGenius: 19 May 2011 - 05:58 AM

[ishkabible]

nope, two others(including me) have the same solution as your second one. even more if you count variations.

it's pretty well as elegant as it gets.

another challenge with well known solution, find 1 expression that checks weather an integer is a power of 2.

int x = ?;
if(<expression>) {
   //'x' is a power of 2;
}

find "<expression>"

This post has been edited by ishkabible: 19 May 2011 - 01:32 PM

[RevTorA]

Spoiler

if(x & (x-1) == 0)
{
    cout << "x is a power of 2" << endl;
}

Is that it?

[RetardedGenius]

I found that slightly harder, anyway here's my solution:

Spoiler

bool IsPowerOf2(int n)
{
    return n > 0 && (n & n - 1) == 0;
}

[ishkabible]

yes both are correct, the solution i was referring to was RevTorA though, they're both basically the same however. i prefer using the '!' operator instead of '== 0', seems cleaner to me.

Spoiler

if(!(x & x - 1) {
   //'x' is a power of 2
}

This post has been edited by ishkabible: 20 May 2011 - 08:29 AM

[RetardedGenius]

ishkabible, on 20 May 2011 - 04:25 PM, said:

yes both are correct, the solution i was referring to was RevTorA though, they're both basically the same however. i prefer using the '!' operator instead of '== 0', seems cleaner to me.

Spoiler

if(!(x & x - 1) {
   //'x' is a power of 2
}

That'd definitely win you a round of Code golf, although you may want to add an extra right-parenthesis!

[ishkabible]

o yea... oops

[Aphex19]

quantizer, on 16 May 2011 - 09:46 AM, said:

Spoiler

cout<<"Number is "<<if(

[ishkabible]

lol, we will say it works for now

edit:
dose lisp count?

(defun(x)(evenp x))

This post has been edited by ishkabible: 29 May 2011 - 05:08 PM

[lakhbir.lk]

codeprada, on 01 March 2011 - 09:18 AM, said:

Complete this program in just one line. It tells the user whether a number is even or odd.

Limitations:

• No use of the Mod(%) operator
  
• no use of functions
  
• no use of classes
  
• no use of / * - +
  
• a line is counted by the amount of semicolons used. so your return statement counts as one line
  
• you cannot alter any other line in the code

Good luck

#include <iostream>
using namespace std;

bool isEven(int f)
{
    return(!(f&1));
}

int main (int argc, char * argv[])
{
    int f = 10;
    cout << f << ( isEven(f)  ?  " is even" : " is odd" ) << endl;
    return 0;
}

its simple you have to look for last bit i.e if last bit of the number is 1 then it is odd number otherwise it is an even.

This post has been edited by lakhbir.lk: 04 June 2011 - 01:28 PM

[codeprada]

Yes it is simple, note the title, but you must do it in one line like the others did.

[NickDMax]

I tried to think outside the box on this one but when I read back over the rules my solution didn't really fit the requirements:

Spoiler

#include <iostream>

using namespace std;

union BitCheck {
    struct {
        unsigned bit : 1;
        unsigned rest : 31;
    };
    int integer;
    BitCheck(int n) : integer(n) { }
};


bool isEven(int f)
{
    return !BitCheck(f).bit;
}

int main (int argc, char * argv[])
{
    int f = 10;
    cout << f << ( isEven(f)  ?  " is even" : " is odd" ) << endl;
    return 0;
}

SO... I worked on a second one:

Spoiler

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/repetition/for.hpp>


#define PRED(r, state) state
#define OP(r, state) BOOST_PP_DEC(state) 
#define MACRO(r, state) * 2

using namespace std;

bool isEven(int f)
{
    return !(f BOOST_PP_FOR(31, PRED, OP, MACRO));
}

int main (int argc, char * argv[])
{
    srand(time(0));
    int f = rand();
    cout << f << ( isEven(f)  ?  " is even" : " is odd" ) << endl;
    return 0;
}

this expends the isEven() function to:

bool isEven(int f)
{
return !(f * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2  );
}

which is simply a bit shift by 31 places and essentially the same as

bool isEven(int f)
{
return !(f << 31);
}

This post has been edited by NickDMax: 05 July 2011 - 01:32 PM
Reason for edit:: added spoiler tags...