How do I check if an integer is even or odd

Question

How can I check if a given number is even or odd in C

User · Answer

In the  creative but confusing category  I offer   int isOdd int n    return n   n   n   isOdd n   n    n      A variant on this theme that is specific to Microsoft C       declspec naked  bool   fastcall isOdd const int x          asm               mov eax ecx         mul eax         mul eax         mul eax         mul eax         mul eax         mul eax         ret

User · Answer

Checking even or odd is a simple task      We know that any number exactly divisible by 2 is even number else odd      We just need to check divisibility of any number and for checking divisibility we use   operator  Checking even odd using if else    if num 2   0          printf  Even      else       printf  Odd        C program to check even or odd using if else    Using Conditional Ternary operator   num 2   0  printf  Even     printf  Odd      C program to check even or odd using conditional operator     Using Bitwise operator  if num  amp  1          printf  Odd      else        printf  Even

User · Answer

I know this is just syntactic sugar and only applicable in  net but what about extension method     public static class RudiGroblerExtensions       public static bool IsOdd this int i                return   i   2     0             Now you can do the following  int i   5  if  i IsOdd             Do something

User · Answer

Reading this rather entertaining discussion  I remembered that I had a real-world  time-sensitive function that tested for odd and even numbers inside the main loop  It s an integer power function  posted elsewhere on StackOverflow  as follows  The benchmarks were quite surprising  At least in this real-world function  modulo is slower  and significantly so  The winner  by a wide margin  requiring 67  of modulo s time  is an or       approach  and is nowhere to be found elsewhere on this page    static dbl  IntPow dbl st0  int x         UINT OrMask   UINT MAX -1      dbl  st1 1 0      if 0  x  return  dbl 1 0       while 1    x              if  UINT MAX     x OrMask             if LSB is 1                  if x  amp  1              if x   2                st1    st0                        x   x  gt  gt  1      shift x right 1 bit              st0    st0            return st1   st0      For 300 million loops  the benchmark timings are as follows    3 962 the   and mask approach  4 851 the  amp  approach  5 850 the   approach  For people who think theory  or an assembly language listing  settles arguments like these  this should be a cautionary tale  There are more things in heaven and earth  Horatio  than are dreamt of in your philosophy

User · Answer

I d say just divide it by 2 and if there is a 0 remainder  it s even  otherwise it s odd   Using the modulus     makes this easy   eg  4   2   0 therefore 4 is even 5   2   1 therefore 5 is odd

User · Answer

Joke mode  on    public enum Evenness     Unknown   0    Even   1    Odd   2    public static Evenness AnalyzeEvenness object o       if  o    null      return Evenness Unknown     string foo   o ToString       if  String IsNullOrEmpty foo       return Evenness Unknown     char bar   foo foo Length - 1      switch  bar           case  0        case  2        case  4        case  6        case  8          return Evenness Even       case  1        case  3        case  5        case  7        case  9          return Evenness Odd       default         return Evenness Unknown           Joke mode  off    EDIT  Added confusing values to the enum

User · Answer

To give more elaboration on the bitwise operator method for those of us who didn t do much boolean algebra during our studies  here is an explanation  Probably not of much use to the OP  but I felt like making it clear why NUMBER  amp  1 works    Please note like as someone answered above  the way negative numbers are represented can stop this method working  In fact it can even break the modulo operator method too since each language can differ in how it deals with negative operands    However if you know that NUMBER will always be positive  this works well   As Tooony above made the point that only the last digit in binary  and denary  is important   A boolean logic AND gate dictates that both inputs have to be a 1  or high voltage  for 1 to be returned   1  amp  0   0   0  amp  1   0    0  amp  0   0   1  amp  1   1   If you represent any number as binary  I have used an 8 bit representation here   odd numbers have 1 at the end  even numbers have 0   For example   1   00000001  2   00000010  3   00000011  4   00000100  If you take any number and use bitwise AND   amp  in java  it by 1 it will either return 00000001    1 meaning the number is odd  Or 00000000   0  meaning the number is even   E g  Is odd   1  amp  1     00000001  amp   00000001    00000001  lt     Odd  2  amp  1    00000010  amp   00000001    00000000  lt     Even  54  amp  1    00000001  amp   00110110    00000000  lt     Even  This is why this works   if number  amp  1         Number is odd    else         Number is even     Sorry if this is redundant

User · Answer

Here is an answer in  Java   public static boolean isEven  Integer Number        Pattern number   Pattern compile          02  8    6 4           String num   Number toString Number       Boolean numbr   new Boolean number matcher num  matches         return numbr booleanValue

User · Answer

A number is even if  when divided by two  the remainder is 0   A number is odd if  when divided by 2  the remainder is 1      Java public static boolean isOdd int num       return num   2    0        C    int isOdd int num       return num   2      Methods are great

User · Answer

One more solution to the problem  children are welcome to vote   bool isEven unsigned int x      unsigned int half1   0  half2   0    while  x           if  x    half1    x--         if  x    half2    x--           return half1    half2

User · Answer

In response to ffpf - I had exactly the same argument with a colleague years ago  and the answer is no  it doesn t work with negative numbers   The C standard stipulates that negative numbers can be represented in 3 ways    2 s complement 1 s complement sign and magnitude   Checking like this   isEven    x  amp  1     will work for 2 s complement and sign and magnitude representation  but not for 1 s complement   However  I believe that the following will work for all cases   isEven    x  amp  1      -1  amp  1      x  lt  0    0   1       Thanks to ffpf for pointing out that the text box was eating everything after my less than character

User · Answer

This is a follow up to the discussion with  RocketRoy regarding his answer  but it might be useful to anyone who wants to compare these results   tl dr From what I ve seen  Roy s approach   0xFFFFFFFF     x   0xFFFFFFFE   is not completely optimized to x  amp  1 as the mod approach  but in practice running times should turn out equal in all cases   So  first I compared the compiled output using Compiler Explorer   Functions tested   int isOdd mod unsigned x        return  x   2      int isOdd and unsigned x        return  x  amp  1      int isOdd or unsigned x        return  0xFFFFFFFF     x   0xFFFFFFFE           CLang 3 9 0 with -O3   isOdd mod unsigned int                               isOdd mod unsigned int          and     edi  1         mov     eax  edi         ret  isOdd and unsigned int                               isOdd and unsigned int          and     edi  1         mov     eax  edi         ret  isOdd or unsigned int                                isOdd or unsigned int          and     edi  1         mov     eax  edi         ret   GCC 6 2 with -O3   isOdd mod unsigned int           mov     eax  edi         and     eax  1         ret  isOdd and unsigned int           mov     eax  edi         and     eax  1         ret  isOdd or unsigned int           or      edi  -2         xor     eax  eax         cmp     edi  -1         sete    al         ret   Hats down to CLang  it realized that all three cases are functionally equal  However  Roy s approach isn t optimized in GCC  so YMMV   It s similar with Visual Studio  inspecting the disassembly Release x64  VS2015  for these three functions  I could see that the comparison part is equal for  mod  and  and  cases  and slightly larger for the Roy s  or  case      x   2 test bl 1   je  some address       x  amp  1 test bl 1   je  some address       Roy s bitwise or mov eax ebx   or eax 0FFFFFFFEh   cmp eax 0FFFFFFFFh   jne  some address    However  after running an actual benchmark for comparing these three options  plain mod  bitwise or  bitwise and   results were completely equal  again  Visual Studio 2005 x86 x64  Release build  no debugger attached     Release assembly uses the test instruction for and and mod cases  while Roy s case uses the cmp eax 0FFFFFFFFh approach  but it s heavily unrolled and optimized so there is no difference in practice   My results after 20 runs  i7 3610QM  Windows 10 power plan set to High Performance      Test  Plain mod 2   AVERAGE TIME  689 29 ms  Relative diff    0 000    Test  Bitwise or    AVERAGE TIME  689 63 ms  Relative diff    0 048    Test  Bitwise and   AVERAGE TIME  687 80 ms  Relative diff   -0 217     The difference between these options is less than 0 3   so it s rather obvious the assembly is equal in all cases   Here is the code if anyone wants to try  with a caveat that I only tested it on Windows  check the  if LINUX conditional for the get time definition and implement it if needed  taken from this answer     include  lt stdio h gt    if LINUX  include  lt sys time h gt   include  lt sys resource h gt  double get time         struct timeval t      struct timezone tzp      gettimeofday  amp t   amp tzp       return t tv sec   t tv usec 1e-6     else  include  lt windows h gt  double get time         LARGE INTEGER t  f      QueryPerformanceCounter  amp t       QueryPerformanceFrequency  amp f       return  double t QuadPart    double f QuadPart   1000 0     endif   define NUM ITERATIONS  1000   1000   1000      using a macro to avoid function call overhead  define Benchmark accumulator  name  operation          double startTime   get time          double dummySum   0 0  elapsed        int x        for  x   0  x  lt  NUM ITERATIONS  x                if  operation  dummySum    x                elapsed   get time   - startTime        accumulator    elapsed        if  dummySum  gt  2000            printf   Test   -12s   0 2f ms r n   name  elapsed        void DumpAverage char  test  double totalTime  double reference        printf   Test   -12s  AVERAGE TIME   0 2f ms  Relative diff     6 3f    r n           test  totalTime   totalTime - reference    reference   100 0      int main void        int repeats   20      double runningTimes 3      0        int k       for  k   0  k  lt  repeats  k              printf  Run  d of  d    r n   k   1  repeats           Benchmark runningTimes 0    Plain mod 2    x   2            Benchmark runningTimes 1    Bitwise or    0xFFFFFFFF     x   0xFFFFFFFE             Benchmark runningTimes 2    Bitwise and    x  amp  1                         double reference   runningTimes 0    repeats          printf   r n            DumpAverage  Plain mod 2   runningTimes 0    repeats  reference           DumpAverage  Bitwise or   runningTimes 1    repeats  reference           DumpAverage  Bitwise and   runningTimes 2    repeats  reference              getchar         return 0

User · Answer

As some people have posted  there are numerous ways to do this  According to this website  the fastest way is the modulus operator   if  x   2    0                 total    1    even number         else                total -  1    odd number   However  here is some other code that was bench marked by the author which ran slower than the common modulus operation above   if   x  amp  1     0                 total    1    even number         else                total -  1    odd number  System Math DivRem  long x   long 2  out outvalue           if   outvalue    0                 total    1    even number         else                total -  1    odd number  if    x   2    2     x                 total    1    even number         else                total -  1    odd number  if    x  gt  gt  1   lt  lt  1     x                 total    1    even number         else                total -  1    odd number          while  index  gt  1                 index -  2          if  index    0                 total    1    even number         else                total -  1    odd number  tempstr   x ToString            index   tempstr Length - 1            this assumes base 10         if  tempstr index      0     tempstr index      2     tempstr index      4     tempstr index      6     tempstr index      8                  total    1    even number         else                total -  1    odd number   How many people even knew of the Math System DivRem method or why would they use it

User · Answer

Try this  return    a gt  gt 1  lt  lt 1     a   Example   a        10101011 ----------------- a gt  gt 1 -- gt  01010101 a lt  lt 1 -- gt  10101010  b        10011100 ----------------- b gt  gt 1 -- gt  01001110 b lt  lt 1 -- gt  10011100

User · Answer

If you want to be efficient  use bitwise operators  x  amp  1   but if you want to be readable use modulo 2  x   2

User · Answer

i   2    0

User · Answer

Use the modulo     operator to check if there s a remainder when dividing by 2   if  x   2       x is odd        A few people have criticized my answer above stating that using x  amp  1 is  faster  or  more efficient   I do not believe this to be the case    Out of curiosity  I created two trivial test case programs      modulo c     include  lt stdio h gt   int main void        int x      for  x   0  x  lt  10  x            if  x   2              printf   d is odd n   x       return 0        and c     include  lt stdio h gt   int main void        int x      for  x   0  x  lt  10  x            if  x  amp  1              printf   d is odd n   x       return 0      I then compiled these with gcc 4 1 3 on one of my machines 5 different times    With no optimization flags  With -O With -Os With -O2 With -O3   I examined the assembly output of each compile  using gcc -S  and found that in each case  the output for and c and modulo c were identical  they both used the andl  1   eax instruction   I doubt this is a  new  feature  and I suspect it dates back to ancient versions  I also doubt any modern  made in the past 20 years  non-arcane compiler  commercial or open source  lacks such optimization  I would test on other compilers  but I don t have any available at the moment   If anyone else would care to test other compilers and or platform targets  and gets a different result  I d be very interested to know   Finally  the modulo version is guaranteed by the standard to work whether the integer is positive  negative or zero  regardless of the implementation s representation of signed integers  The bitwise-and version is not  Yes  I realise two s complement is somewhat ubiquitous  so this is not really an issue

User · Answer

C  bool isEven     i   2     0

User · Answer

Modulus operator     can be used to check whether a number is odd or even That is when a number is divided by 2 and if the remainder is 0 then its an even number else its an odd number    include  lt stdio h gt  int main         int n   using modulus operator     scanf   d   amp n    take input n from STDIN      printf   s  n 2  0  Even   Odd     prints Even Odd depending on n to STDOUT     return 0      But using Bit manipulation is quite faster than the above method so if you take a number and apply logically AND   amp   to it  if the answer is 1 then its even else its odd That is basically we have to check the last bit of the number n in binary If the last bit is 0 then n is even else its odd   for example   suppose N   15   in binary N   1111   now we AND it with 1      1111     0001     amp -----     0001   Since the result is 1 the number N 15 is Odd  Again suppose N   8   in binary N   1000   now we AND it with 1      1000     0001     amp -----     0000   Since the result is 0 the number N 8 is Even    include  lt stdio h gt   int main         int n   using AND operator     scanf   d   amp n    take input n from STDIN      printf   s  n amp 1  Odd   Even     prints Even Odd depending on n to STDOUT     return 0

User · Answer

Portable   i   2   odd   even    Unportable   i  amp  1   odd   even   i  lt  lt   BITS PER INT - 1    odd   even

User · Answer

For the sake of discussion     You only need to look at  the last digit in any given number to see if it is even or odd   Signed  unsigned  positive  negative - they are all the same with regards to this  So this should work all round  -  void tellMeIfItIsAnOddNumberPlease int iToTest     int iLastDigit    iLastDigit   iToTest -  iToTest   10   10     if  iLastDigit   2    0       printf  The number  d is even  n   iToTest       else       printf  The number  d is odd  n   iToTest           The key here is in the third line of code  the division operator performs an integer division  so that result are missing the fraction part of the result  So for example 222   10 will give 22 as a result  Then multiply it again with 10 and you have 220  Subtract that from the original 222 and you end up with 2  which by magic is the same number as the last digit in the original number   -  The parenthesis are there to remind us of the order the calculation is done in  First do the division and the multiplication  then subtract the result from the original number  We could leave them out  since the priority is higher for division and multiplication than of subtraction  but this gives us  more readable  code   We could make it all completely unreadable if we wanted to  It would make no difference whatsoever for a modern compiler  -  printf   d s n  iToTest 0   iToTest-iToTest 10 10  2   is even    is odd      But it would make the code way harder to maintain in the future  Just imagine that you would like to change the text for odd numbers to  is not even   Then someone else later on want to find out what changes you made and perform a svn diff or similar     If you are not worried about portability but more about speed  you could have a look at the least significant bit  If that bit is set to 1 it is an odd number  if it is 0 it s an even number   On a little endian system  like Intel s x86 architecture it would be something like this  -  if  iToTest  amp  1         Even   else        Odd

User · Answer

int isOdd int i     return i   2       done

User · Answer

I execute this code for ODD  amp  EVEN    include  lt stdio h gt  int main         int number      printf  Enter an integer          scanf   d    amp number        if number   2    0          printf   d is even    number       else         printf   d is odd    number

User · Answer

66  faster  gt    i 2    i 2    0 int isOdd int n        return n  amp  1     The code checks the last bit of the integer if it s 1 in Binary Explanation Binary      Decimal ------------------- 0000        0 0001        1 0010        2 0011        3 0100        4 0101        5 0110        6 0111        7 1000        8 1001        9 and so on      Notice the rightmost bit is always 1 for Odd numbers   the  amp  bitwise AND operator checks the rightmost bit in our return line if it s 1 Think of it as true  amp  false When we compare n with 1 which means 0001 in binary  number of zeros doesn t matter   then let s just Imagine that we have the integer n with a size of 1 byte  It d be represented by 8-bit   8-binary digits  If the int n was 7 and we compare it with 1  It s like 7  1-byte int      0  0  0  0    0  1  1  1         amp  1  1-byte int      0  0  0  0    0  0  0  1                                              Result             F  F  F  F    F  F  F  T  Which F stands for false and T for true   It compares only the rightmost bit if they re both true  So  automagically 7  amp  1 is True   What if I want to check the bit before the rightmost  Simply change n  amp  1 to n  amp  2 which 2 represents 0010 in Binary and so on  I suggest using hexadecimal notation if you re a beginner to bitwise operations return n  amp  1   gt  gt  return n  amp  0x01

User · Answer

You guys are waaaaaaaay too efficient  What you really want is   public boolean isOdd int num      int i   0    boolean odd   false     while  i    num        odd    odd      i   i   1         return odd      Repeat for isEven   Of course  that doesn t work for negative numbers  But with brilliance comes sacrifice

User · Answer

I would build a table of the parities  0 if even 1 if odd  of the integers  so one could do a lookup  D   but gcc won t let me make arrays of such sizes   typedef unsigned int uint   char parity uint  UINT MAX   char parity sint shifted    uint  INT MAX      uint  abs  INT MIN     char  parity sint   parity sint shifted - INT MIN   void build parity tables          char parity   0      unsigned int ui      for  ui   1  ui  lt   UINT MAX    ui            parity uint  ui - 1    parity          parity    parity            parity   0      int si      for  si   1  si  lt   INT MAX    si            parity sint  si - 1    parity          parity    parity            parity   1      for  si   -1  si  gt   INT MIN  --si            parity sint  si    parity          parity    parity           char uparity  unsigned int n        if  n    0            return 0            return parity uint  n - 1      char sparity  int n        if  n    0            return 0            if  n  lt  0              n            return parity sint  n - 1       So let s instead resort to the mathematical definition of even and odd instead   An integer n is even if there exists an integer k such that n   2k   An integer n is odd if there exists an integer k such that n   2k   1   Here s the code for it   char even  int n        int k      for  k   INT MIN  k  lt   INT MAX    k            if  n    2   k                return 1                      return 0     char odd  int n        int k      for  k   INT MIN  k  lt   INT MAX    k            if  n    2   k   1                return 1                      return 0      Let C-integers denote the possible values of int in a given C compilation   Note that C-integers is a subset of the integers    Now one might worry that for a given n in C-integers that the corresponding integer k might not exist within C-integers  But with a little proof it is can be shown that for all integers n   n   lt    2n       where  n  is  n if n is positive and -n otherwise   In other words  for all n in integers at least one of the following holds  exactly either cases  1 and 2  or cases  3 and 4  in fact but I won t prove it here    Case 1  n  lt   2n   Case 2  -n  lt   -2n   Case 3  -n  lt   2n   Case 4  n  lt   -2n   Now take 2k   n   Such a k does exist if n is even  but I won t prove it here  If n is not even then the loop in even fails to return early anyway  so it doesn t matter   But this implies k  lt  n if n not 0 by     and the fact  again not proven here  that for all m  z in integers 2m   z implies z not equal to m given m is not 0  In the case n is 0  2 0   0 so 0 is even we are done  if n   0 then 0 is in C-integers because n is in C-integer in the function even  hence k   0 is in C-integers   Thus such a k in C-integers exists for n in C-integers if n is even   A similar argument shows that if n is odd  there exists a k in C-integers such that n   2k   1   Hence the functions even and odd presented here will work properly for all C-integers

User · Answer

The bitwise method depends on the inner representation of the integer  Modulo will work anywhere there is a modulo operator  For example  some systems actually use the low level bits for tagging  like dynamic languages   so the raw x  amp  1 won t actually work in that case

User · Answer

Number Zero parity   zero http   tinyurl com oexhr3k  Python code sequence     defining function for number parity check def parity number          Parity check function          if number is 0  zero  return  Zero neither ODD nor EVEN         otherwise number amp 1  checking last bit  if 0  then EVEN         if 1  then ODD      return  number    0 and  Zero neither ODD nor EVEN                 or  number amp 1 and  ODD  or  EVEN      cycle trough numbers from 0 to 13  for number in range 0  14       print   0  gt 4     0 08b     1    format number  parity number        Output       0   00000000   Zero neither ODD nor EVEN    1   00000001   ODD    2   00000010   EVEN    3   00000011   ODD    4   00000100   EVEN    5   00000101   ODD    6   00000110   EVEN    7   00000111   ODD    8   00001000   EVEN    9   00001001   ODD   10   00001010   EVEN   11   00001011   ODD   12   00001100   EVEN   13   00001101   ODD

User · Answer

int isOdd int i     return i   2       done

User · Answer

IsOdd int x    return true     Proof of correctness - consider the set of all positive integers and suppose there is a non-empty set of integers that are not odd   Because positive integers are well-ordered  there will be a smallest not odd number  which in itself is pretty odd  so clearly that number can t be in the set   Therefore this set cannot be non-empty   Repeat for negative integers except look for the greatest not odd number

User · Answer

A nice one is     forward declaration  C compiles in one pass   bool isOdd unsigned int n    bool isEven unsigned int n      if  n    0       return true       I know 0 is even   else     return isOdd n-1       n is even if n-1 is odd    bool isOdd unsigned int n      if  n    0      return false     else     return isEven n-1       n is odd if n-1 is even     Note that this method use tail recursion involving two functions  It can be implemented efficiently  turned into a while until kind of loop  if your compiler supports tail recursion like a Scheme compiler  In this case the stack should not overflow

User · Answer

Use bit arithmetic   if  x  amp  1     0      printf  EVEN  n    else     printf  ODD  n      This is faster than using division or modulus

[c] How do I check if an integer is even or odd?

Examples related to c

Examples related to integer