Even or odd: Difference between revisions

Content added Content deleted

Inline

Revision as of 01:27, 15 November 2012

Test whether an integer is even or odd.

There is more than one way to solve this task:

Use the even and odd predicates, if the language provides them.
Check the least significant digit. With binary integers, i bitwise-and 1 equals 0 iff i is even, or equals 1 iff i is odd.
Divide i by 2. The remainder equals 0 iff i is even. The remainder equals +1 or -1 iff i is odd.
Use modular congruences:
- i ≡ 0 (mod 2) iff i is even.
- i ≡ 1 (mod 2) iff i is odd.

AutoHotkey

Bitwise ops are probably most efficient: <lang AHK>if ( int & 1 ){ ; do odd stuff }else{ ; do even stuff }</lang>

<lang ada>-- Ada has bitwise operators in package Interfaces, -- but they work with Interfaces.Unsigned_*** types only. -- Use rem or mod for Integer types, and let the compiler -- optimize it. declare

  N : Integer := 5;

begin

  if N rem 2 = 0 then
     Put_Line ("Even number");
  elseif N rem 2 /= 0 then
     Put_Line ("Odd number");
  else
     Put_Line ("Something went really wrong!");
  end if;

end;</lang>

AWK

<lang AWK>function isodd(x) { return (x%2)!=0; }

function iseven(x) { return (x%2)==0; }</lang>

BBC BASIC

Works with: BBC BASIC for Windows

Solutions using AND or MOD are restricted to 32-bit integers, so an alternative solution is given which works with a larger range of values. <lang bbcbasic>==BBC BASIC==

Works with: BBC BASIC for Windows

<lang bbcbasic> IF FNisodd%(14) PRINT "14 is odd" ELSE PRINT "14 is even"

     IF FNisodd%(15) PRINT "15 is odd" ELSE PRINT "15 is even"
     IF FNisodd#(9876543210#) PRINT "9876543210 is odd" ELSE PRINT "9876543210 is even"
     IF FNisodd#(9876543211#) PRINT "9876543211 is odd" ELSE PRINT "9876543211 is even"
     END
     
     REM Works for -2^31 <= n% < 2^31
     DEF FNisodd%(n%) = (n% AND 1) <> 0
     
     REM Works for -2^53 <= n# <= 2^53
     DEF FNisodd#(n#) = n# <> 2 * INT(n# / 2)</lang>

Output:

14 is even
15 is odd
9876543210 is even
9876543211 is odd

bc

There are no bitwise operations, so this solution compares a remainder with zero. Calculation of i % 2 only works when scale = 0. <lang bc>i = -3

/* Assumes that i is an integer. */ scale = 0 if (i % 2 == 0) "i is even " if (i % 2) "i is odd "</lang>

Bracmat

Not the simplest solution, but the cheapest if the number that must be tested has thousands of digits. <lang bracmat>( ( even

& (odd=.~(even$!arg)) & ( eventest

 =
   .   out
     $ (!arg is (even$!arg&|not) even)
 )

& ( oddtest

 =
   .   out
     $ (!arg is (odd$!arg&|not) odd)
 )

& eventest$5556 & oddtest$5556 & eventest$857234098750432987502398457089435 & oddtest$857234098750432987502398457089435 )</lang> Output:

5556 is even
5556 is not odd
857234098750432987502398457089435 is not even
857234098750432987502398457089435 is odd

Brainf***

Assumes that input characters are an ASCII representation of a valid integer. <lang bf>+ [>,+]<

>> +++++ [<<--[>+<[-]]>>-] <----->+< [> ++++++++++ ++++++++++ ++++++++++ ++++++++++ ++++++++++ ++++++++++ ++++++++++ ++++++++. ++++++++++ ++++++++++ +..[-]<[-]]>[> ++++++++++ ++++++++++ ++++++++++ ++++++++++ ++++++++++ ++++++++++ +++++++++. ++++++++++ ++++++++++ ++++++++++ ++++++++++ +++++++++.

.

+++++++++. [-]]</lang>

C

Test by bitwise and'ing 1, works for any builtin integer type as long as it's 2's compliment (it's always so nowadays): <lang c>if (x & 1) {

   /* x is odd */

} else {

   /* or not */

}</lang> If using long integer type from GMP (mpz_t), there are provided macros: <lang c>mpz_t x; ... if (mpz_even_p(x)) { /* x is even */ } if (mpz_odd_p(x)) { /* x is odd */ }</lang> The macros evaluate x more than once, so it should not be something with side effects.

C++

Test using the modulo operator, or use the c example from above. <lang cpp>bool isEven(int Value){

 if((x % 2) == 0){
   return true;
 }
 return false;

} </lang>

C#

<lang csharp>namespace RosettaCode {

   using System;

   public static class EvenOrOdd
   {
       public static bool IsEvenBitwise(this int number)
       {
           return (number & 1) == 0;
       }

       public static bool IsOddBitwise(this int number)
       {
           return (number & 1) != 0;
       }

       public static bool IsEvenRemainder(this int number)
       {
           int remainder;
           Math.DivRem(number, 2, out remainder);
           return remainder == 0;
       }

       public static bool IsOddRemainder(this int number)
       {
           int remainder;
           Math.DivRem(number, 2, out remainder);
           return remainder != 0;
       }

       public static bool IsEvenModulo(this int number)
       {
           return (number % 2) == 0;
       }

       public static bool IsOddModulo(this int number)
       {
           return (number % 2) != 0;
       }
   }

}</lang>

Clojure

Standard predicates: <lang clojure>(if (even? some-var) (do-even-stuff)) (if (odd? some-var) (do-odd-stuff))</lang>

Common Lisp

Standard predicates: <lang lisp>(if (evenp some-var) (do-even-stuff)) (if (oddp some-other-var) (do-odd-stuff))</lang>

D

<lang d>import std.stdio, std.bigint;

void main() {

   foreach (i; -5 .. 6)
       writeln(i, " ", i & 1, " ", i % 2, " ", BigInt(i) % 2);

}</lang>

Output:

DWScript

Predicate: <lang delphi>var isOdd := Odd(i);</lang> Bitwise and: <lang delphi>var isOdd := (i and 1)<>0;</lang> Modulo: <lang delphi>var isOdd := (i mod 2)=1;</lang>

Euphoria

Using standard function <lang Euphoria> include std/math.e

for i = 1 to 10 do

       ? {i, is_even(i)}

end for </lang> Output

{1,0}
{2,1}
{3,0}
{4,1}
{5,0}
{6,1}
{7,0}
{8,1}
{9,0}
{10,1}

Factor

The math vocabulary provides even? and odd? predicates. This example runs at the listener, which already uses the math vocabulary.

( scratchpad ) 20 even? .
t
( scratchpad ) 35 even? .
f
( scratchpad ) 20 odd? .
f
( scratchpad ) 35 odd? .
t

Fish

This example assumes that the input command i returns an integer when one was inputted and that the user inputs a valid positive integer terminated by a newline. <lang Fish><v"Please enter a number:"a

>l0)?!vo     v          <                        v    o<

^ >i:a=?v>i:a=?v$a*+^>"The number is even."ar>l0=?!^>

            >      >2%0=?^"The number is odd."ar ^</lang>

The actual computation is the 2%0= part. The rest is either user interface or parsing input.

Forth

Go

<lang go>package main

import (

   "fmt"
   "math/big"

)

func main() {

   test(-2)
   test(-1)
   test(0)
   test(1)
   test(2)
   testBig("-222222222222222222222222222222222222")
   testBig("-1")
   testBig("0")
   testBig("1")
   testBig("222222222222222222222222222222222222")

}

func test(n int) {

   fmt.Printf("Testing integer %3d:  ", n)
   // & 1 is a good way to test
   if n&1 == 0 {
       fmt.Print("even ")
   } else {
       fmt.Print(" odd ")
   }
   // Careful when using %: negative n % 2 returns -1.  So, the code below
   // works, but can be broken by someone thinking they can reverse the
   // test by testing n % 2 == 1.  The valid reverse test is n % 2 != 0.
   if n%2 == 0 {
       fmt.Println("even")
   } else {
       fmt.Println(" odd")
   }

}

func testBig(s string) {

   b, _ := new(big.Int).SetString(s, 10)
   fmt.Printf("Testing big integer %v:  ", b)
   // the Bit function is the only sensible test for big ints.
   if b.Bit(0) == 0 {
       fmt.Println("even")
   } else {
       fmt.Println("odd")
   }

}</lang>

Output:

Testing integer  -2:  even even
Testing integer  -1:   odd  odd
Testing integer   0:  even even
Testing integer   1:   odd  odd
Testing integer   2:  even even
Testing big integer -222222222222222222222222222222222222:  even
Testing big integer -1:  odd
Testing big integer 0:  even
Testing big integer 1:  odd
Testing big integer 222222222222222222222222222222222222:  even

Groovy

Solution: <lang groovy>def isOdd = { int i -> (i & 1) as boolean } def isEven = {int i -> ! isOdd(i) }</lang> Test: <lang groovy>1.step(20, 2) { assert isOdd(it) }

50.step(-50, -2) { assert isEven(it) }</lang>

Haskell

even and odd functions are already included in the standard Prelude. <lang haskell>Prelude> even 5 False Prelude> even 42 True Prelude> odd 5 True Prelude> odd 42 False</lang>

Icon and Unicon

One way is to check the remainder: <lang unicon>procedure isEven(n)

   return n%2 = 0

end</lang>

J

Modulo: <lang j> 2 | 2 3 5 7 0 1 1 1

  2|2 3 5 7 + (2^89x)-1

1 0 0 0</lang> Remainder: <lang j> (= <.&.-:) 2 3 5 7 1 0 0 0

  (= <.&.-:) 2 3 5 7+(2^89x)-1

0 1 1 1</lang> Last bit in bit representation: <lang j> {:"1@#: 2 3 5 7 0 1 1 1

  {:"1@#: 2 3 5 7+(2^89x)-1

1 0 0 0</lang> Bitwise and: <lang j> 1 (17 b.) 2 3 5 7 0 1 1 1</lang> Note: as a general rule, the simplest expressions in J should be preferred over more complex approaches.

Java

Bitwise and: <lang java>public static boolean isEven(int i){

   return (i & 1) == 0;

}</lang> Modulo: <lang java>public static boolean isEven(int i){

   return (i % 2) == 0;

}</lang> Arbitrary precision bitwise: <lang java>public static boolean isEven(BigInteger i){

   return i.and(BigInteger.ONE).equals(BigInteger.ZERO);

}</lang> Arbitrary precision bit test (even works for negative numbers because of the way BigInteger represents the bits of numbers): <lang java>public static boolean isEven(BigInteger i){

   return !i.testBit(0);

}</lang> Arbitrary precision modulo: <lang java>public static boolean isEven(BigInteger i){

   return i.mod(BigInteger.valueOf(2)).equals(BigInteger.ZERO);

}</lang>

LabVIEW

Using bitwise And
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.

Liberty BASIC

<lang lb> n=12

if n mod 2 = 0 then print "even" else print "odd" </lang>

Mathematica

<lang Mathematica>EvenQ[8]</lang>

MATLAB / Octave

Bitwise And: <lang Matlab> isOdd = logical(bitand(N,1));

  isEven = ~logical(bitand(N,1)); </lang>

Remainder of division by two <lang Matlab> isOdd = logical(rem(N,2));

  isEven = ~logical(rem(N,2)); </lang>

Modulo: 2 <lang Matlab> isOdd = logical(mod(N,2));

  isEven = ~logical(mod(N,2)); </lang>

Maxima

<lang maxima>evenp(n); oddp(n);</lang>

Mercury

Mercury's 'int' module provides tests for even/odd, along with all the operators that would be otherwise used to implement them. <lang Mercury>even(N) % in a body, suceeeds iff N is even. odd(N). % in a body, succeeds iff N is odd.

% rolling our own:

- pred even(int::in) is semidet.

% It's an error to have all three in one module, mind; even/1 would fail to check as semidet. even(N) :- N mod 2 = 0. % using division that truncates towards -infinity even(N) :- N rem 2 = 0. % using division that truncates towards zero even(N) :- N /\ 1 = 0. % using bit-wise and.</lang>

Objeck

<lang objeck>a := Console->ReadString()->ToInt(); if(a % 2 = 0) {

 "even"->PrintLine();

} else {

 "odd"->PrintLine();

};</lang>

OCaml

Modulo: <lang ocaml>let is_even d =

 (d mod 2) = 0

let is_odd d =

 (d mod 2) <> 0</lang>

Bitwise and: <lang ocaml>let is_even d =

 (d land 1) = 0

let is_odd d =

 (d land 1) <> 0</lang>

PARI/GP

GP does not have a built-in predicate for testing parity, but it's easy to code: <lang parigp>odd(n)=n%2;</lang> Alternately: <lang parigp>odd(n)=bitand(n,1);</lang> PARI can use the same method as C for testing individual words. For multiprecision integers (t_INT), use mpodd. If the number is known to be nonzero, mod2 is (insignificantly) faster.

Pascal

Built-in boolean function odd: <lang pascal>isOdd := odd(someIntegerNumber);</lang> bitwise and: <lang pascal>function isOdd(Number: integer): boolean begin

 isOdd := boolean(Number and 1)

end;</lang> Dividing and multiplying by 2 and test on equality: <lang pascal>function isEven(Number: integer): boolean begin

 isEven := (Number = ((Number div 2) * 2))

end;</lang> Using built-in modulo <lang pascal>function isOdd(Number: integer): boolean begin

 isOdd := boolean(Number mod 2)

end;</lang>

Perl

<lang perl>for(0..10){

   print "$_ is ", qw(even odd)[$_ % 2],"\n";

}</lang> or <lang perl>print 6 % 2 ? 'odd' : 'even'; # prints even</lang>

Perl 6

Perl 6 doesn't have a built-in for this, but with subsets it's easy to define a predicate for it. <lang perl6>subset Even of Int where * %% 2; subset Odd of Int where * % 2;

say 1 ~~ Even; # false say 1 ~~ Odd; # true say 1.5 ~~ Odd # false ( 1.5 is not an Int )</lang>

PicoLisp

PicoLisp doesn't have a built-in predicate for that. Using 'bit?' is the easiest and most efficient. The bit test with 1 will return NIL if the number is even. <lang PicoLisp>: (bit? 1 3) -> 1 # Odd

(bit? 1 4)

-> NIL # Even</lang>

Pike

<lang Pike>> int i = 73; > (i&1); Result: 1 > i%2; Result: 1</lang>

PL/I

<lang PL/I>i = iand(i,1)</lang> The result is 1 when i is odd, and 0 when i is even.

PureBasic

<lang PureBasic>;use last bit method isOdd = i & 1 ;isOdd is non-zero if i is odd isEven = i & 1 ! 1 ;isEven is non-zero if i is even

use modular method

isOdd = i % 2 ;isOdd is non-zero if i is odd isEven = i % 2 ! 1 ;isEven is non-zero if i is even</lang>

Python

Python: Using the least-significant bit method

<lang python>>>> def is_odd(i): return bool(i & 1)

>>> def is_even(i): return not is_odd(i)

>>> [(j, is_odd(j)) for j in range(10)] [(0, False), (1, True), (2, False), (3, True), (4, False), (5, True), (6, False), (7, True), (8, False), (9, True)] >>> [(j, is_even(j)) for j in range(10)] [(0, True), (1, False), (2, True), (3, False), (4, True), (5, False), (6, True), (7, False), (8, True), (9, False)] >>> </lang>

Python: Using modular congruences

<lang python>>> def is_even(i):

       return (i % 2) == 0

>>> is_even(1) False >>> is_even(2) True >>></lang>

R

<lang R>is.even <- function(x) !is.odd(x)

is.odd <- function(x) intToBits(x)[1] == 1

or

is.odd <- function(x) x %% 2 == 1</lang>

Rascal

<lang rascal>public bool isEven(int n) = (n % 2) == 0; public bool isOdd(int n) = (n % 2) == 1;</lang> Or with block quotes: <lang rascal>public bool isEven(int n){return (n % 2) == 0;} public bool isOdd(int n){return (n % 2) == 1;}</lang>

REXX

<lang rexx>/*REXX program displays if an integer is even or odd. */ numeric digits 1000 /*handle most big 'uns from the CL*/ parse arg x _ . /*get arg(s) from the command line*/ if x== then call terr 'no input' if _\== | arg()\==1 then call terr 'too many arguments:' arg(1) if \datatype(x,'N') then call terr x "isn't numeric" if \datatype(x,'W') then call terr x "isn't an integer" y=abs(x)/1 /*just in case X is negative, */

                                     /*(modulus of neg # might be -1), */
                                     /*and normalize it (4.0 becomes 4)*/

/*══════════════════════════════════════════════════════════════════════*/

                   say center('test using modulo method',40,'─')

if y//2 then say x 'is odd'

        else say x 'is even'

say /*══════════════════════════════════════════════════════════════════════*/

                   say center('test rightmost digit for evenness',40,'─')

_=right(y,1) if pos(_,02468)==0 then say x 'is odd'

                   else say x 'is even'

say /*══════════════════════════════════════════════════════════════════════*/

                   say center('test rightmost digit for oddness',40,'─')

if pos(right(y,1),13579)==0 then say x 'is even'

                            else say x 'is odd'

say /*══════════════════════════════════════════════════════════════════════*/

                   say center('test rightmost bit',40,'─')
                            /*Note: some REXX's don't have a  D2B  bif.*/

if right(x2b(d2x(y)),1) then say x 'is odd'

                        else say x 'is even'

/*══════════════════════════════════════════════════════════════════════*/ exit /*stick a fork in it, we're done.*/

/*──────────────────────────────────TERR subroutine─────────────────────*/ terr: say; say '***error!***'; say; say arg(1); say; exit 13</lang> output when using the input of 0

─────────────modulo method──────────────
0 is even

───test rightmost digit for evenness────
0 is even

────test rightmost digit for oddness────
0 is even

───────────test rightmost bit───────────
0 is even

out0put when using the input of: 9876543210987654321098765432109876543210987654321

─────────────modulo method──────────────
9876543210987654321098765432109876543210987654321 is odd

───test rightmost digit for evenness────
9876543210987654321098765432109876543210987654321 is odd

────test rightmost digit for oddness────
9876543210987654321098765432109876543210987654321 is odd

───────────test rightmost bit───────────
9876543210987654321098765432109876543210987654321 is odd

output when using the input of 00067.00

────────test using modulo method────────
00067.00 is odd

───test rightmost digit for evenness────
00067.00 is odd

────test rightmost digit for oddness────
00067.00 is odd

───────────test rightmost bit───────────
00067.00 is odd

output when using the input of: -9411

─────────────modulo method──────────────
-9411 is odd

───test rightmost digit for evenness────
-9411 is odd

────test rightmost digit for oddness────
-9411 is odd

───────────test rightmost bit───────────
-9411 is odd

Ruby

Ruby 1.8.7 added Integer#even? and Integer#odd? as new methods.

Works with: Ruby version 1.8.7

<lang ruby>print "evens: " p -5.upto(5).select {|n| n.even?} print "odds: " p -5.upto(5).select {|n| n.odd?}</lang>

Output:

evens: [-4, -2, 0, 2, 4]
odds: [-5, -3, -1, 1, 3, 5]

Other ways to test even-ness: <lang ruby>n & 1 == 0 quotient, remainder = n.divmod(2); remainder == 0

The next way only works when n.to_f/2 is exact.
If Float is IEEE double, then -2**53 .. 2**53 must include n.

n.to_f/2 == n/2

You can use the bracket operator to access the i'th bit
of a Fixnum or Bignum (i = 0 means least significant bit)

n[0].zero?</lang>

Run BASIC

<lang runbasic>for i = 1 to 10

 if i and 1 then print i;" is odd" else print i;" is even"

next i</lang>

1 is odd
2 is even
3 is odd
4 is even
5 is odd
6 is even
7 is odd
8 is even
9 is odd
10 is even

Scala

<lang scala>def isEven( v:Int ) : Boolean = v % 2 == 0 def isOdd( v:Int ) : Boolean = v % 2 != 0</lang> Accept any numeric type as an argument: <lang scala>def isEven( v:Number ) : Boolean = v.longValue % 2 == 0 def isOdd( v:Number ) : Boolean = v.longValue % 2 != 0</lang>

Output:

isOdd( 81 )                     // Results in true
isEven( BigInt(378) )           // Results in true
isEven( 234.05003513013145 )    // Results in true

Scheme

even? and odd? functions are built-in (R⁴RS, R⁵RS, and R⁶RS): <lang scheme>> (even? 5)

f

> (even? 42)

t

> (odd? 5)

t

> (odd? 42)

f</lang>

Seed7

Test whether an integer or bigInteger is odd: <lang seed7>odd(aNumber)</lang> Test whether an integer or bigInteger is even: <lang seed7>not odd(aNumber)</lang>

SNUSP

<lang SNUSP> $====!/?\==even#

- -

odd==\?/

</lang>

Tcl

<lang tcl>package require Tcl 8.5

Bitwise test is the most efficient

proc tcl::mathfunc::isOdd x { expr {$x & 1} } proc tcl::mathfunc::isEven x { expr {!($x & 1)} }

puts " # O E" puts 24:[expr isOdd(24)],[expr isEven(24)] puts 49:[expr isOdd(49)],[expr isEven(49)]</lang>

Output:

 # O E
24:0,1
49:1,0

TUSCRIPT

<lang tuscript>$$ MODE TUSCRIPT LOOP n=-5,5 x=MOD(n,2) SELECT x CASE 0 PRINT n," is even" DEFAULT PRINT n," is odd" ENDSELECT ENDLOOP</lang>

Output:

-5 is odd
-4 is even
-3 is odd
-2 is even
-1 is odd
0 is even
1 is odd
2 is even
3 is odd
4 is even
5 is odd

XPL0

<lang XPL0>include c:\cxpl\codes; int I; [for I:= -4 to +3 do

       [IntOut(0, I);
       Text(0, if I&1 then " is odd   " else " is even  "); 
       Text(0, if rem(I/2)#0 then "odd" else "even");
       CrLf(0);
       ];

]</lang>

Output:

-4 is even  even
-3 is odd   odd
-2 is even  even
-1 is odd   odd
0 is even  even
1 is odd   odd
2 is even  even
3 is odd   odd