Even or odd

Task

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.

0815

ABAP

<lang ABAP> cl_demo_output=>display(

 VALUE string_table(
   FOR i = -5 WHILE i < 6 (
     COND string(
       LET r = i MOD 2 IN
       WHEN r = 0 THEN |{ i } is even|
       ELSE |{ i } is odd|
     )
   )
 )

). </lang>

Output:

Table 
-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

<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>

Aime

<lang aime>if (x & 1) {

   # x is odd

} else {

   # x is even

}</lang>

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.win32

<lang algol68># Algol 68 has a standard operator: ODD which returns TRUE if its integer #

operand is odd and FALSE if it is even #
E.g.: #

INT n; print( ( "Enter an integer: " ) ); read( ( n ) ); print( ( whole( n, 0 ), " is ", IF ODD n THEN "odd" ELSE "even" FI, newline ) ) </lang>

ALGOL W

<lang algolw>begin

   % the Algol W standard procedure odd returns true if its integer  %
   % parameter is odd, false if it is even                           %
   for i := 1, 1702, 23, -26
   do begin
       write( i, " is ", if odd( i ) then "odd" else "even" )
   end for_i

end.</lang>

Output:

             1   is odd
          1702   is even
            23   is odd
           -26   is even

AntLang

APL

The easiest way is probably to use modulo. <lang apl> 2|28 0

     2|37

1</lang>

AppleScript

<lang AppleScript>set nList to {3, 2, 1, 0, -1, -2, -3} repeat with n in nList if (n / 2) = n / 2 as integer then log "Value " & n & " is even." else log "Value " & n & " is odd." end if end repeat</lang>

Output:

(*Value 3 is odd.*)
(*Value 2 is even.*)
(*Value 1 is odd.*)
(*Value 0 is even.*)
(*Value -1 is odd.*)
(*Value -2 is even.*)
(*Value -3 is odd.*)

Arendelle

( input , "Please enter a number: " )

{ @input % 2 = 0 ,

	"| @input | is even!"
,
	"| @input | is odd!"
}

AutoHotkey

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

AWK

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

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

BASIC

<lang basic>10 INPUT "ENTER A NUMBER: ";N 20 IF N/2 <> INT(N/2) THEN PRINT "THE NUMBER IS ODD":GOTO 40 30 PRINT "THE NUMBER IS EVEN" 40 END</lang>

Batch File

<lang dos> @echo off set /p i=Insert number:

bitwise and

set /a "test1=%i%&1"

divide last character by 2

set /a test2=%i:~-1%/2

modulo

set /a test3=%i% %% 2

set test pause>nul </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> 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>

Befunge

Outputs E if even, O if odd.

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. Output is input mod 2. <lang bf>,[>,----------] Read until newline ++< Get a 2 and move into position [->-[>+>>]> Do [+[-<+>]>+>>] divmod <<<<<] magic >[-]<++++++++ Clear and get an 8 [>++++++<-] to get a 48 >[>+<-]>. to get n % 2 to ASCII and print</lang>

If one need only determine rather than act on the parity of the input, the following is sufficient; it terminates either quickly or never. <lang bf>,[>,----------]<[--]</lang>

Burlesque

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 isOdd(int x) {

   return x % 2;

}

bool isEven(int x) {

   return !(x % 2);

}</lang>

A slightly more type-generic version, for C++11 and later. This should theoretically work for any type convertible to int:

<lang cpp> template < typename T > constexpr inline bool isEven( const T& v ) {

   return isEven( int( v ) );

}

template <> constexpr inline bool isEven< int >( const int& v ) {

   return (v & 1) == 0;

}

template < typename T > constexpr inline bool isOdd( const T& v ) {

   return !isEven(v);

} </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>

COBOL

<lang cobol> IF FUNCTION REM(Num, 2) = 0

          DISPLAY Num " is even."
      ELSE
          DISPLAY Num " is odd."
      END-IF</lang>

CoffeeScript

<lang coffeescript>isEven = (x) -> !(x%2)</lang>

ColdFusion

 She's even

 He's odd

</cfif> </lang>

Common Lisp

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

Component Pascal

BlackBox Component Builder <lang oberon2> MODULE EvenOdd; IMPORT StdLog,Args,Strings;

PROCEDURE BitwiseOdd(i: INTEGER): BOOLEAN; BEGIN RETURN 0 IN BITS(i) END BitwiseOdd;

PROCEDURE Odd(i: INTEGER): BOOLEAN; BEGIN RETURN (i MOD 2) # 0 END Odd;

PROCEDURE CongruenceOdd(i: INTEGER): BOOLEAN; BEGIN RETURN ((i -1) MOD 2) = 0 END CongruenceOdd;

PROCEDURE Do*; VAR p: Args.Params; i,done,x: INTEGER; BEGIN Args.Get(p); StdLog.String("Builtin function: ");StdLog.Ln;i := 0; WHILE i < p.argc DO Strings.StringToInt(p.args[i],x,done); StdLog.String(p.args[i] + " is:> "); IF ODD(x) THEN StdLog.String("odd") ELSE StdLog.String("even") END; StdLog.Ln;INC(i) END; StdLog.String("Bitwise: ");StdLog.Ln;i:= 0; WHILE i < p.argc DO Strings.StringToInt(p.args[i],x,done); StdLog.String(p.args[i] + " is:> "); IF BitwiseOdd(x) THEN StdLog.String("odd") ELSE StdLog.String("even") END; StdLog.Ln;INC(i) END; StdLog.String("Module: ");StdLog.Ln;i := 0; WHILE i < p.argc DO Strings.StringToInt(p.args[i],x,done); StdLog.String(p.args[i] + " is:> "); IF Odd(x) THEN StdLog.String("odd") ELSE StdLog.String("even") END; StdLog.Ln;INC(i) END; StdLog.String("Congruences: ");StdLog.Ln;i := 0; WHILE i < p.argc DO Strings.StringToInt(p.args[i],x,done); StdLog.String(p.args[i] + " is:> "); IF CongruenceOdd(x) THEN StdLog.String("odd") ELSE StdLog.String("even") END; StdLog.Ln;INC(i) END; END Do; </lang> Execute: ^Q EvenOdd.Do 10 11 0 57 34 -23 -42~

Output:

Builtin function: 
10  is:> even
11  is:> odd
0  is:> even
57  is:> odd
34  is:> even
-23  is:> odd
-42 is:> even
Bitwise: 
10  is:> even
11  is:> odd
0  is:> even
57  is:> odd
34  is:> even
-23  is:> odd
-42 is:> even
Module: 
10  is:> even
11  is:> odd
0  is:> even
57  is:> odd
34  is:> even
-23  is:> odd
-42 is:> even
Congruences: 
10  is:> even
11  is:> odd
0  is:> even
57  is:> odd
34  is:> even
-23  is:> odd
-42 is:> even

Crystal

<lang crystal>#Using bitwise shift

 def isEven_bShift(n)
   n == ((n >> 1) << 1)
 end
 def isOdd_bShift(n)
   n != ((n >> 1) << 1)
 end

Using modulo operator

 def isEven_mod(n)
   (n % 2) == 0
 end
 def isOdd_mod(n)
   (n % 2) != 0
 end

Using bitwise "and"

 def isEven_bAnd(n)
   (n & 1) ==  0
 end
 def isOdd_bAnd(n)
   (n & 1) != 0
 end

puts isEven_bShift(7) puts isOdd_bShift(7)

puts isEven_mod(12) puts isOdd_mod(12)

puts isEven_bAnd(21) puts isOdd_bAnd(21) </lang>

Output:

false
true
true
false
false
true

D

<lang d>void main() {

   import std.stdio, std.bigint;

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

}</lang>

Output:

DCL

<lang DCL>$! in DCL, for integers, the least significant bit determines the logical value, where 1 is true and 0 is false $ $ i = -5 $ loop1: $ if i then $ write sys$output i, " is odd" $ if .not. i then $ write sys$output i, " is even" $ i = i + 1 $ if i .le. 6 then $ goto loop1</lang>

Output:

$ @even_odd
-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
6 is even

Déjà Vu

<lang dejavu>even n:

   = 0 % n 2

odd:

   not even

!. odd 0 !. even 0 !. odd 7 !. even 7 </lang>

Output:

false
true
true
false

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>

Eiffel

<lang Eiffel>--bit testing if i.bit_and (1) = 0 then -- i is even end

--built-in bit testing (uses bit_and) if i.bit_test (0) then -- i is odd end

--integer remainder (modulo) if i \\ 2 = 0 then -- i is even end</lang>

Elixir

<lang elixir>defmodule RC do

 require Integer
 
 def even_or_odd(n) when Integer.is_even(n), do: "#{n} is even"
 def even_or_odd(n)                        , do: "#{n} is odd"
     # In second "def", the guard clauses of "is_odd(n)" is unnecessary.
 
 # Another definition way
 def even_or_odd2(n) do
   if Integer.is_even(n), do: "#{n} is even", else: "#{n} is odd"
 end

end

Enum.each(-2..3, fn n -> IO.puts RC.even_or_odd(n) end)</lang>

Output:

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

Other ways to test even-ness: <lang elixir>rem(n,2) == 0</lang>

Emacs Lisp

With evenp and oddp

<lang Emacs Lisp> (defun odd (n)

 (if (oddp n) (format "%d is odd\n" n)
   (format "%d is even\n" n)))

(defun even (n)

 (if (evenp n) (format "%d is even\n" n)
   (format "%d is odd\n" n)))

(progn

 (insert (even 3) )
 (insert (odd 2) )))

</lang>

With mod

<lang Emacs Lisp> (defun odd (n)

 (if (= 1 (mod n 2) ) (format "%d is odd\n" n)
   (format "%d is even\n" n)))

(defun even (n)

 (if (= 0 (mod n 2) ) (format "%d is even\n" n)
   (format "%d is odd\n" n)))

(progn

 (insert (even 3) )
 (insert (odd 2) ))

</lang> Output:

 
3 is odd
2 is even

Erlang

Using Division by 2 Method

<lang erlang>%% Implemented by Arjun Sunel -module(even_odd). -export([main/0]).

main()-> test(8).

test(N) -> if (N rem 2)==1 -> io:format("odd\n"); true -> io:format("even\n") end. </lang>

Using the least-significant bit method

<lang erlang> %% Implemented by Arjun Sunel -module(even_odd2). -export([main/0]).

main()-> test(10).

test(N) -> if (N band 1)==1 -> io:format("odd\n"); true -> io:format("even\n") end. </lang>

ERRE

<lang ERRE>PROGRAM ODD_EVEN

! works for -2^15 <= n% < 2^15

FUNCTION ISODD%(N%)

     ISODD%=(N% AND 1)<>0

END FUNCTION

! works for -2^38 <= n# <= 2^38 FUNCTION ISODD#(N#)

     ISODD#=N#<>2*INT(N#/2)

END FUNCTION

BEGIN

 IF ISODD%(14) THEN PRINT("14 is odd") ELSE PRINT("14 is even") END IF
 IF ISODD%(15) THEN PRINT("15 is odd") ELSE PRINT("15 is even") END IF
 IF ISODD#(9876543210) THEN PRINT("9876543210 is odd") ELSE PRINT("9876543210 is even") END IF
 IF ISODD#(9876543211) THEN PRINT("9876543211 is odd") ELSE PRINT("9876543211 is even") END IF

END PROGRAM </lang>

Output:

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

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}

Excel

Use the MOD function <lang Excel> =MOD(33;2) =MOD(18;2) </lang>

Output:

1
0

Use the ISEVEN function, returns TRUE or FALSE <lang Excel> =ISEVEN(33) =ISEVEN(18) </lang>

Output:

FALSE
TRUE

Use the ISODD function, returns TRUE or FALSE <lang Excel> =ISODD(33) =ISODD(18) </lang>

Output:

TRUE
FALSE

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

Fortran

Please find the compilation and example run in the comments at the beginning of the FORTRAN 2008 source. Separating the bit 0 parity module from the main program enables reuse of the even and odd functions. Even and odd, with scalar and vector interfaces demonstrate the generic function capability of FORTRAN 90. Threading, stdin, and all-intrinsics are vestigial and have no influence here other than to confuse you. <lang FORTRAN> !-*- mode: compilation; default-directory: "/tmp/" -*- !Compilation started at Tue May 21 20:22:56 ! !a=./f && make $a && OMP_NUM_THREADS=2 $a < unixdict.txt !gfortran -std=f2008 -Wall -ffree-form -fall-intrinsics f.f08 -o f ! n odd even !-6 F T !-5 T F !-4 F T !-3 T F !-2 F T !-1 T F ! 0 F T ! 1 T F ! 2 F T ! 3 T F ! 4 F T ! 5 T F ! 6 F T ! -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 n ! F T F T F T F T F T F T F odd ! T F T F T F T F T F T F T even ! !Compilation finished at Tue May 21 20:22:56

module bit0parity

 interface odd
   module procedure odd_scalar, odd_list
 end interface

 interface even
   module procedure even_scalar, even_list
 end interface

contains

 logical function odd_scalar(a)
   implicit none
   integer, intent(in) :: a
   odd_scalar = btest(a, 0)
 end function odd_scalar

 logical function even_scalar(a)
   implicit none
   integer, intent(in) :: a
   even_scalar = .not. odd_scalar(a)
 end function even_scalar

 function odd_list(a) result(rv)
   implicit none
   integer, dimension(:), intent(in) :: a
   logical, dimension(size(a)) :: rv
   rv = btest(a, 0)
 end function odd_list

 function even_list(a) result(rv)
   implicit none
   integer, dimension(:), intent(in) :: a
   logical, dimension(size(a)) :: rv
   rv = .not. odd_list(a)
 end function even_list

end module bit0parity

program oe

 use bit0parity
 implicit none
 integer :: i
 integer, dimension(13) :: j
 write(6,'(a2,2a8)') 'n', 'odd', 'even'
 write(6, '(i2,2l5)') (i, odd_scalar(i), even_scalar(i), i=-6,6)
 do i=-6, 6
   j(i+7) = i
 end do
 write(6, '((13i3),a8/(13l3),a8/(13l3),a8)') j, 'n', odd(j), 'odd', even(j), 'even'

end program oe </lang>

FreeBASIC

<lang freebasic>' FB 1.05.0 Win64

Dim n As Integer

Do

 Print "Enter an integer or 0 to finish : ";
 Input "", n
 If n = 0 Then
   Exit Do
 ElseIf n Mod 2 = 0 Then
   Print "Your number is even"
   Print
 Else
   Print "Your number is odd"
   Print
 End if

Loop

End</lang>

Futhark

F#

Bitwise and: <lang fsharp>let isEven x =

 x &&& 1 = 0</lang>

Modulo: <lang fsharp>let isEven x =

 x % 2 = 0</lang>

GAP

<lang gap>IsEvenInt(n); IsOddInt(n);</lang>

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>

JavaScript

Bitwise: <lang javascript>function isEven( i ) {

 return (i & 1) === 0;

} </lang> Modulo: <lang javascript>function isEven( i ) {

 return i % 2 === 0;

}

// Alternative function isEven( i ) {

 return !(i % 2);

}</lang> Lambda: <lang javascript>// EMCAScript 6 const isEven=x=>!(x%2)</lang>

jq

In practice, to test whether an integer, i, is even or odd in jq, one would typically use: i % 2

For example, if it were necessary to have a strictly boolean function that would test if its input is an even integer, one could define: <lang jq>def is_even: type == "number" and floor == 0 and . % 2 == 0;</lang>

The check that the floor is 0 is necessary as % is defined on floating point numbers.

"is_odd" could be similarly defined:

<lang jq>def is_odd: type == "number" and floor == 0 and . % 2 == 1;</lang>

Julia

Built-in functions: <lang julia>iseven(i), isodd(i)</lang>

L++

<lang lisp>(defn bool isEven (int x) (return (% x 2)))</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.

Lang5

<lang lang5>: even? 2 % not ;

odd? 2 % ;

1 even? . # 0 1 odd? . # 1</lang>

LC3 Assembly

Prints EVEN if the number stored in NUM is even, otherwise ODD. <lang lc3asm> .ORIG 0x3000

     LD         R0,NUM
     AND        R1,R0,1
     BRZ        EVEN

     LEA        R0,ODD
     BRNZP      DISP

EVEN LEA R0,EVN

DISP PUTS

     HALT

NUM .FILL 0x1C

EVN .STRINGZ "EVEN\n" ODD .STRINGZ "ODD\n"

     .END</lang>

Liberty BASIC

<lang lb>n=12

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

LiveCode

<lang LiveCode>function odd n

   return (n bitand 1) = 1

end odd

function notEven n

   return (n mod 2) = 1

end notEven</lang>

Lasso

<lang Lasso>define isoddoreven(i::integer) => { #i % 2 ? return 'odd' return 'even' } isoddoreven(12)</lang>

Logo

<lang logo>to even? :num

   output equal? 0 modulo :num 2

end</lang>

Logtalk

- object(even_odd).

   :- public(test_mod/1).
   test_mod(I) :-
       (   I mod 2 =:= 0 ->
           write(even), nl
       ;   write(odd), nl
       ).

   :- public(test_bit/1).
   test_bit(I) :-
       (   I /\ 1 =:= 1 ->
           write(odd), nl
       ;   write(even), nl
       ).

- end_object.

</lang>

Output:

<lang text> | ?- even_odd::test_mod(1). odd yes

| ?- even_odd::test_mod(2). even yes

| ?- even_odd::test_bit(1). odd yes

| ?- even_odd::test_bit(2). even yes </lang>

Lua

<lang lua>-- test for even number if n % 2 == 0 then

 print "The number is even"

end

-- test for odd number if not (n % 2 == 0) then

 print "The number is odd"

end</lang>

M4

<lang M4>define(`even', `ifelse(eval(`$1'%2),0,True,False)') define(`odd', `ifelse(eval(`$1'%2),0,False,True)')

even(13) even(8)

odd(5) odd(0)</lang>

Maple

<lang Maple>EvenOrOdd := proc( x::integer )

  if x mod 2 = 0 then
     print("Even"):
  else
     print("Odd"):
  end if:

end proc: EvenOrOdd(9);</lang>

"Odd"

Mathematica / Wolfram Language

<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>

MIPS Assembly

This uses bitwise AND <lang mips> .data even_str: .asciiz "Even" odd_str: .asciiz "Odd"

.text #set syscall to get integer from user li $v0,5 syscall

#perform bitwise AND and store in $a0 and $a0,$v0,1

#set syscall to print dytomh li $v0,4

#jump to odd if the result of the AND operation beq $a0,1,odd even: #load even_str message, and print la $a0,even_str syscall

#exit program li $v0,10 syscall

odd: #load odd_str message, and print la $a0,odd_str syscall

#exit program li $v0,10 syscall </lang>

МК-61/52

Result: "0" - number is even; "1" - number is odd.

ML

mLite

<lang ocaml>fun odd (x rem 2 = 1) = true | _ = false

fun even (x rem 2 = 0) = true | _ = false

</lang>

Neko

<lang neko>var number = 6;

if(number % 2 == 0) { $print("Even"); } else { $print("Odd"); }</lang>

Output:

Even

NESL

NESL provides evenp and oddp functions, but they wouldn't be hard to reimplement. <lang nesl>function even(n) = mod(n, 2) == 0;

% test the function by applying it to the first ten positive integers: % {even(n) : n in [1:11]};</lang>

Output:

it = [F, T, F, T, F, T, F, T, F, T] : [bool]

NetRexx

<lang NetRexx>/* NetRexx */ options replace format comments java crossref symbols nobinary

say 'Val'.right(5)': mod - ver - pos - bits' say '---'.right(5)': ---- + ---- + ---- + ----' loop nn = -15 to 15 by 3

 say nn.right(5)':' eo(isEven(nn)) '-' eo(isEven(nn, 'v')) '-' eo(isEven(nn, 'p')) '-' eo(isEven(nn, 'b'))
 end nn

return

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- Overloaded method. Default is to use the remainder specialization below method isEven(anInt, meth = 'R') public static returns boolean

 select case meth.upper().left(1)
   when 'R' then eo = isEvenRemainder(anInt)
   when 'V' then eo = isEvenVerify(anInt)
   when 'P' then eo = isEvenPos(anInt)
   when 'B' then eo = isEvenBits(anInt)
   otherwise     eo = isEvenRemainder(anInt) -- default
   end
 return eo

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method isEvenRemainder(anInt) public static returns boolean

 return anInt // 2 == 0

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method isEvenVerify(anInt) public static returns boolean

 return anInt.right(1).verify('02468') == 0

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method isEvenPos(anInt) public static returns boolean

 return '13579'.pos(anInt.right(1)) == 0

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method isEvenBits(anInt) public static returns boolean

 return \(anInt.d2x(1).x2b().right(1))

-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ method eo(state = boolean) public static

 if state then sv = 'Even'
          else sv = 'Odd'
 return sv.left(4)

</lang>

Output:

  Val: mod  - ver  - pos  - bits
  ---: ---- + ---- + ---- + ----
  -15: Odd  - Odd  - Odd  - Odd 
  -12: Even - Even - Even - Even
   -9: Odd  - Odd  - Odd  - Odd 
   -6: Even - Even - Even - Even
   -3: Odd  - Odd  - Odd  - Odd 
    0: Even - Even - Even - Even
    3: Odd  - Odd  - Odd  - Odd 
    6: Even - Even - Even - Even
    9: Odd  - Odd  - Odd  - Odd 
   12: Even - Even - Even - Even
   15: Odd  - Odd  - Odd  - Odd

NewLISP

Nim

<lang nim># Least signficant bit: proc isOdd(i: int): bool = (i and 1) != 0 proc isEven(i: int): bool = (i and 1) == 0

Modulo:

proc isOdd2(i: int): bool = (i mod 2) != 0 proc isEven2(i: int): bool = (i mod 2) == 0

Bit Shifting:

proc isOdd3(n: int): bool = n != ((n shr 1) shl 1) proc isEven3(n: int): bool = n == ((n shr 1) shl 1)

echo isEven(1) echo isOdd2(5)</lang>

Oberon-2

Works with: oo2c

<lang oberon2> MODULE EvenOrOdd; IMPORT

 S := SYSTEM,
 Out;

VAR

 x: INTEGER;
 s: SET;

BEGIN

 x := 10;Out.Int(x,0);
 IF ODD(x) THEN Out.String(" odd") ELSE Out.String(" even") END; 
 Out.Ln;

 x := 11;s := S.VAL(SET,LONG(x));Out.Int(x,0);
 IF 0 IN s THEN Out.String(" odd") ELSE Out.String(" even") END;
 Out.Ln;

 x := 12;Out.Int(x,0);
 IF x MOD 2 # 0 THEN Out.String(" odd") ELSE Out.String(" even") END;
 Out.Ln

END EvenOrOdd. </lang>

Output:

10 even
11 odd
12 even

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>

An instructive view on functional programming and recursion: <lang ocaml>(* hmm, only valid for N0 *) let rec myeven = function

 | 0 -> true
 | 1 -> false
 | n -> myeven (n - 2)

(* and here we have the not function in if form *) let myodd n = if myeven n then false else true</lang>

Oforth

<lang Oforth>12 isEven 12 isOdd</lang>

OOC

<lang ooc> // Using the modulo operator even: func (n: Int) -> Bool {

 (n % 2) == 0

}

// Using bitwise and odd: func (n: Int) -> Bool {

 (n & 1) == 1

} </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>

Phix

and_bits(i,1) returns 1(true) for odd integers and 0(false) for even integers. remainder(i,2) could also validly be used, however "true" for odd numbers is actually 1 for positive odd integers and -1 for negative odd integers. <lang Phix>for i = -5 to 5 do

   ? {i, and_bits(i,1), remainder(i,2)}

end for</lang>

Output:

{-5,1,-1}
{-4,0,0}
{-3,1,-1}
{-2,0,0}
{-1,1,-1}
{0,0,0}
{1,1,1}
{2,0,0}
{3,1,1}
{4,0,0}
{5,1,1}

PHP

<lang php> // using bitwise and to check least significant digit echo (2 & 1) ? 'odd' : 'even'; echo (3 & 1) ? 'odd' : 'even';

// using modulo echo (3 % 2) ? 'odd' : 'even'; echo (4 % 2) ? 'odd' : 'even'; </lang>

Output:

even
odd
odd
even

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.

PowerShell

Works with: PowerShell version 2

Predicate

A predicate can be used with BigInteger objects. Even/odd predicates to not exist for basic value types. Type accelerator [bigint] can be used in place of [System.Numerics.BigInteger]. <lang PowerShell> $IsOdd = -not ( [bigint]$N ).IsEven $IsEven = ( [bigint]$N ).IsEven </lang>

Least significant digit

<lang PowerShell> $IsOdd = [boolean]( $N -band 1 ) $IsEven = [boolean]( $N -band 0 ) </lang>

Remainder

Despite being known as a modulus operator, the % operator in PowerShell actually returns a remainder. As such, when testing negative numbers it returns the true modulus result minus M. In this specific case, it returns -1 for odd negative numbers. Thus we test for not zero for odd numbers. <lang PowerShell> $IsOdd = $N % 2 -ne 0 $IsEven = $N % 2 -eq 0 </lang>

Prolog

Prolog does not provide special even or odd predicates as one can simply write "0 is N mod 2" to test whether the integer N is even. To illustrate, here is a predicate that can be used both to test whether an integer is even and to generate the non-negative even numbers: <lang prolog>

 even(N) :-
    (between(0, inf, N); integer(N) ),
    0 is N mod 2.

</lang>

Least Significant Bit

If N is a positive integer, then lsb(N) is the offset of its least significant bit, so we could write: <lang prolog>

 odd(N) :- N = 0 -> false; 0 is lsb(abs(N)).

</lang>

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>

Racket

With built in predicates: <lang Racket>(even? 6) ; -> true (even? 5) ; -> false (odd? 6) ; -> false (odd? 5) ; -> true </lang>

With modular arithmetic: <lang Racket>(define (my-even? x)

 (= (modulo x 2) 0))

(define (my-odd? x)

 (= (modulo 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

Programming note: division by 1 (one) in REXX is a way to normalize a number:

by removing a superfluous leading + sign
by removing superfluous leading zeroes
by removing superfluous trailing zeroes
by removing a trailing decimal point
possible converting an exponentiated number
possible rounding the number to the current digits

Programming note: the last method is the fastest method in REXX to determine oddness/evenness.
It requires a sparse stemmed array !. be defined in the program's prologue (or elsewhere).
This method gets its speed from not using any BIF and not performing any (remainder) division.

Some notes on programming styles: If (execution) speed isn't an issue, then the 1^st test method
shown would be the simplest (in terms of coding the concisest/tightest/smallest code). The other test
methods differ mostly in programming techniques, mostly depending on the REXX programmer's style.
The last method shown is the fastest algorithm, albeit it might be a bit obtuse (without comments) to a
novice reader of the REXX language (and it requires additional REXX statement baggage). <lang rexx>/*REXX program tests and displays if an integer is even or odd using different styles.*/ !.=0; do j=0 by 2 to 8; !.j=1; end /*assign 0,2,4,6,8 to a "true" value.*/

                                                /* [↑]  assigns even digits to  "true".*/

numeric digits 1000 /*handle most huge numbers from the CL.*/ parse arg x _ . /*get an argument from the command line*/ if x== then call terr "no integer input (argument)." if _\== | arg()\==1 then call terr "too many arguments: " _ arg(2) if \datatype(x, 'N') then call terr "argument isn't numeric: " x if \datatype(x, 'W') then call terr "argument isn't an integer: " x y=abs(x)/1 /*in case X is negative or malformed,*/

                                                /* [↑]  remainder of neg # might be -1.*/
                                                /*malformed #s: 007  9.0  4.8e1  .21e2 */

call tell 'remainder method (oddness)' if y//2 then say x 'is odd'

        else say  x  'is even'
                                                /* [↑]  uses division to get remainder.*/

call tell 'rightmost digit using BIF (not evenness)' _=right(y, 1) if pos(_, 86420)==0 then say x 'is odd'

                    else say x 'is even'
                                                /* [↑]  uses 2 BIF (built─in functions)*/

call tell 'rightmost digit using BIF (evenness)' _=right(y, 1) if pos(_, 86420)\==0 then say x 'is even'

                     else say x 'is odd'
                                                /* [↑]  uses 2 BIF (built─in functions)*/

call tell 'even rightmost digit using array (evenness)' _=right(y, 1) if !._ then say x 'is even'

       else say x 'is odd'
                                                /* [↑]  uses a BIF (built─in function).*/

call tell 'remainder of division via function invoke (evenness)' if even(y) then say x 'is even'

           else say x 'is odd'
                                                /* [↑]  uses (even) function invocation*/

call tell 'remainder of division via function invoke (oddness)' if odd(y) then say x 'is odd'

          else say x 'is even'
                                                /* [↑]  uses (odd)  function invocation*/

call tell 'rightmost digit using BIF (not oddness)' _=right(y, 1) if pos(_, 13579)==0 then say x 'is even'

                    else say x 'is odd'
                                                /* [↑]  uses 2 BIF (built─in functions)*/

call tell 'rightmost (binary) bit (oddness)' if right(x2b(d2x(y)), 1) then say x 'is odd'

                         else say x 'is even'
                                                /* [↑]  requires extra numeric digits. */

call tell 'parse statement using BIF (not oddness)' parse var y -1 _ /*obtain last decimal digit of the Y #.*/ if pos(_, 02468)==0 then say x 'is odd'

                    else say x 'is even'
                                                /* [↑]  uses a BIF (built─in function).*/

call tell 'parse statement using array (evenness)' parse var y -1 _ /*obtain last decimal digit of the Y #.*/ if !._ then say x 'is even'

       else say  x  'is odd'
                                                /* [↑]  this is the fastest algorithm. */

exit /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ even: return \( arg(1)//2 ) /*returns "evenness" of arg, version 1.*/ even: return arg(1)//2==0 /* " " " " " 2.*/ even: parse arg -1 _; return !._ /* " " " " " 3.*/

                                                /*last version shown is the fastest.   */

odd: return arg(1)//2 /*returns "oddness" of the argument. */ tell: say; say center('using the' arg(1), 79, "═"); return terr: say; say '***error***'; say; say arg(1); say; exit 13</lang> output when using the input of: 0

═════════════════════using the remainder method (oddness)══════════════════════
0 is even

══════════════using the rightmost digit using BIF (not evenness)═══════════════
0 is even

════════════════using the rightmost digit using BIF (evenness)═════════════════
0 is even

═════════════using the even rightmost digit using array (evenness)═════════════
0 is even

════════using the remainder of division via function invoke (evenness)═════════
0 is even

═════════using the remainder of division via function invoke (oddness)═════════
0 is even

═══════════════using the rightmost digit using BIF (not oddness)═══════════════
0 is even

══════════════════using the rightmost (binary) bit (oddness)═══════════════════
0 is even

═══════════════using the parse statement using BIF (not oddness)═══════════════
0 is even

═══════════════using the parse statement using array (evenness)════════════════
0 is even

output when using the input of: 9876543210987654321098765432109876543210987654321

═════════════════════using the remainder method (oddness)══════════════════════
9876543210987654321098765432109876543210987654321 is odd

   (rest of the output was elided.)

output when using the input of: .6821e4

═════════════════════using the remainder method (oddness)══════════════════════
.8621e4 is odd

   (rest of the output was elided.)

output when using the input of: -9411

═════════════════════using the remainder method (oddness)══════════════════════
-9411 is odd

   (rest of the output was elided.)

Ring

<lang ring> size = 10 for i = 1 to size

   if i % 2 = 1 see "" + i + " is odd" + nl
   else see "" + i + " is even" + nl ok

next </lang>

Ruby

<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

Rust

Checking the last significant digit: <lang rust>let is_odd = |x: i32| x & 1 == 1; let is_even = |x: i32| x & 1 == 0;</lang>

Using modular congruences: <lang rust>let is_odd = |x: i32| x % 2 != 0; let is_even = |x: i32| x % 2 == 0;</lang>

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>

Sidef

Built-in methods: <lang ruby>var n = 42; say n.is_odd; # false say n.is_even; # true</lang>

Checking the last significant digit: <lang ruby>func is_odd(n) { n&1 == 1 }; func is_even(n) { n&1 == 0 };</lang>

Using modular congruences: <lang ruby>func is_odd(n) { n%2 == 1 }; func is_even(n) { n%2 == 0 };</lang>

SequenceL

Output:

cmd:>even(1 ... 10)
[false,true,false,true,false,true,false,true,false,true]
cmd:>odd(1 ... 10)
[true,false,true,false,true,false,true,false,true,false]

Smalltalk

Using the built in methods on Number class:

even is implemented as follows: <lang smalltalk>Number>>even ^((self digitAt: 1) bitAnd: 1) = 0 </lang>

SNOBOL4

Works with: Macro SNOBOL4 in C

Works with: Spitbol

Works with: SNOBOL4+

<lang SNOBOL4> DEFINE('even(n)') :(even_end) even even = (EQ(REMDR(n, 2), 0) 'even', 'odd') :(RETURN) even_end

     OUTPUT = "-2 is " even(-2)
     OUTPUT = "-1 is " even(-1)
     OUTPUT = "0 is " even(0)
     OUTPUT = "1 is " even(1)
     OUTPUT = "2 is " even(2)

END</lang>

Output:

-2 is even

-1 is odd 0 is even 1 is odd 2 is even

SNUSP

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

- -

odd==\?/

</lang>

SQL

Database vendors can't agree on how to get a remainder. This should work for many, including Oracle. For others, including MS SQL Server, try "int % 2" instead of "mod(int, 2)". <lang sql>-- Setup a table with some integers create table ints(int integer); insert into ints values (-1); insert into ints values (0); insert into ints values (1); insert into ints values (2);

-- Are they even or odd? select

 int,
 case mod(int, 2) when 0 then 'Even' else 'Odd' end

from

 ints;</lang>

Output:

       INT CASE
---------- ----
        -1 Odd
         0 Even
         1 Odd
         2 Even

SSEM

The SSEM doesn't provide AND, but for once the instruction set does allow the problem to be solved quite elegantly (albeit extravagantly slowly). Load the value of $n$ into storage address 15. The first three instructions test whether $n$ is positive, and replace it with its negation if it isn't. We then loop, subtracting 2 each time and testing whether we have got down either to 0 or to 1. When we have, the computer will halt with the accumulator storing 0 if $n$ was even or 1 if it was odd.

Note that the constant 2, stored at address 14, does double service: it is the operand for the Sub. instruction at address 6 and also the jump target returning to the top of the main loop (which is at address 2 + 1 = 3).

For larger positive or smaller negative values of $n$ , you should be ready with something else to do while the machine is working: a test run took several minutes to confirm that 32,769 was odd. <lang ssem>11110000000000100000000000000000 0. -15 to c 00000000000000110000000000000000 1. Test 11110000000001100000000000000000 2. c to 15 11110000000000100000000000000000 3. -15 to c 00001000000001100000000000000000 4. c to 16 00001000000000100000000000000000 5. -16 to c 01110000000000010000000000000000 6. Sub. 14 11110000000001100000000000000000 7. c to 15 10110000000000010000000000000000 8. Sub. 13 00000000000000110000000000000000 9. Test 01110000000000000000000000000000 10. 14 to CI 11110000000000100000000000000000 11. -15 to c 00000000000001110000000000000000 12. Stop 10000000000000000000000000000000 13. 1 01000000000000000000000000000000 14. 2</lang>

Standard ML

<lang sml>fun even n =

 n mod 2 = 0;

fun odd n =

 n mod 2 <> 0;

(* bitwise and *)

type werd = Word.word;

fun evenbitw(w: werd) =

 Word.andb(w, 0w2) = 0w0;

fun oddbitw(w: werd) =

 Word.andb(w, 0w2) <> 0w0;</lang>

Swift

<lang Swift>func isEven(n:Int) -> Bool {

   // Bitwise check
   if (n & 1 != 0) {
       return false
   }
   
   // Mod check
   if (n % 2 != 0) {
       return false
   }
   return true

}</lang>

Symsyn

<lang symsyn> n : 23

if n bit 0
   'n is odd' []
else
   'n is even' []

</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

TI-83 BASIC

TI-83 BASIC does not have a modulus operator. <lang ti83b> If fPart(.5Ans Then Disp "ODD Else Disp "EVEN End </lang>

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

Ursa

<lang ursa>decl int input set input (in int console) if (= (mod input 2) 1)

       out "odd" endl console

else

       out "even" endl console

end if</lang> Output:

123
odd

உயிர்/Uyir

<lang உயிர்/Uyir>முதன்மை என்பதின் வகை எண் பணி {{

       எ இன் வகை எண்{$5} = 0;
       படை வகை சரம்;

       "எண்ணைக் கொடுங்கள்? ") ஐ திரை.இடு;

       எ = எண்{$5} ஐ விசை.எடு;

       ஒருக்கால் (எ.இருமம்(0) == 1) ஆகில் {
               படை = "ஒற்றை";
       } இல்லையேல் {
               படை = "இரட்டை ";
       }

       {எ, " ஒரு ", படை, "ப்படை எண் ஆகும்"} என்பதை திரை.இடு;

       முதன்மை  = 0;

}};</lang>

VBScript

<lang vb> Function odd_or_even(n) If n Mod 2 = 0 Then odd_or_even = "Even" Else odd_or_even = "Odd" End If End Function

WScript.StdOut.Write "Please enter a number: " n = WScript.StdIn.ReadLine WScript.StdOut.Write n & " is " & odd_or_even(CInt(n)) WScript.StdOut.WriteLine </lang>

Output:

C:\>cscript /nologo odd_or_even.vbs
Please enter a number: 6
6 is Even

C:\>cscript /nologo odd_or_even.vbs
Please enter a number: 9
9 is Odd

C:\>cscript /nologo odd_or_even.vbs
Please enter a number: -1
-1 is Odd

xEec

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

zkl

<lang zkl>[-3..4].pump(fcn(n){ println(n," is ",n.isEven and "even" or "odd") })</lang> Ints have isEven and isOdd properties. pump, in this case, is the same as apply/map without aggregating a result.

Output:

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

<lang zkl>[-3..4].apply("isEven").println();</lang>

Output:

L(False,True,False,True,False,True,False,True)

ZX Spectrum Basic

<lang zxbasic>10 FOR n=-3 TO 4: GO SUB 30: NEXT n 20 STOP 30 LET odd=FN m(n,2) 40 PRINT n;" is ";("Even" AND odd=0)+("Odd" AND odd=1) 50 RETURN 60 DEF FN m(a,b)=a-INT (a/b)*b</lang>