Even or odd: Difference between revisions

 

;Task:

 

=={{header|0815}}==

}:s:|=<:2:x~#:e:=/~%~<:20:~$=<:73:x<:69:~$~$~<:20:~$=^:o:<:65:

x<:76:=$=$~$<:6E:~$<:a:~$^:s:}:o:<:6F:x<:64:x~$~$$<:a:~$^:s:

 

=={{header|11l}}==

R i % 2 == 0

 

F is_odd(i)

 

=={{header|6502 Assembly}}==

.lf evenodd6502.lst

.cr 6502

;------------------------------------------------------

.en

=={{header|68000 Assembly}}==

 

===Non-Destructive===

BNE isOdd

 

===Destructive===

 

BNE isOdd

 

BCS isOdd

 

BCS isOdd

 

BCS isOdd

 

BCS isOdd

 

 

The instruction that's doing all the work here is <code>rar</code>, which is a bitwise right rotate

of the accumulator through the carry flag. That leaves the low bit in the carry flag, which will be

 

puts: equ 9h ; Syscall to print a string

;;; Check if number given on command line is even or odd

org 100h

lxi h,CMDLIN ; Find length of argument

add l ; Look up last character (digit)

mov l,a

jmp 5 ; So print 'even'

even: db 'Even$' ; Strings

 

{{out}}

=={{header|8086 Assembly}}==

===Non-Destructive===

jne isOdd

 

===Destructive===

jne isOdd

 

jc isOdd

 

jc isOdd

 

jc isOdd

 

jc isOdd

 

The <code>DIV</code> instruction can also work, but using <code>DIV</code> to divide by 2 is a waste of time, since the shift and rotate commands above do it faster.

=={{header|8th}}==

The 'mod' method also works, but the bit method is fastest.

dup 1 n:band 1 n:= ;

 

This could be shortened to:

: even? \ n -- f

1 n:band not ;

: odd? \ n -- f

even? not ;

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B and android arm 64 bits*/

 

/*******************************************/

sMessResultEven: .asciz " @ is even (pair) \n"

szCarriageReturn: .asciz "\n"

/*********************************/

/* UnInitialized data */

/*********************************/

.text

 

mov x0,#5

mov x0,#2021

bl testOddEven

mov x0, #0 //return code

mov x8, #EXIT //request to exit program

svc #0 //perform the system call

qAdrszCarriageReturn: .quad szCarriageReturn

qAdrsMessResultOdd: .quad sMessResultOdd

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{output}}

<pre>

2021 is odd (impair)

</pre>

=={{header|ABAP}}==

cl_demo_output=>display(

VALUE string_table(

)

).

 

{{out}}

 

=={{header|Action!}}==

IF (v&1)=0 THEN

Print(" even")

 

FOR i=-4 TO 4

PrintF("%I is",i)

OddByAnd(i)

PutE()

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Even_or_odd.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

-- but they work with Interfaces.Unsigned_*** types only.

-- Use rem or mod for Integer types, and let the compiler

Put_Line ("Something went really wrong!");

end if;

 

=={{header|Agda}}==

odd : ℕ → Bool

 

 

odd zero = false

 

=={{header|Aime}}==

# x is odd

} else {

# x is even

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# operand is odd and FALSE if it is even #

# E.g.: #

read( ( n ) );

print( ( whole( n, 0 ), " is ", IF ODD n THEN "odd" ELSE "even" FI, newline ) )

 

=={{header|ALGOL-M}}==

Because ALGOL-M lacks a built-in MOD operator or function and does not support bitwise operations on integers, the test is a bit cumbersome, but gets the job done.

BEGIN

 

WRITE(K," IS ", IF EVEN(K) = 1 THEN "EVEN" ELSE "ODD");

 

{{out}}

<pre>

 

An alternate (but mathematically equivalent) coding, demonstrating the use of a conditional test as part of an assignment statement:

% RETURN 1 IF EVEN, OTHERWISE 0 %

INTEGER FUNCTION EVEN(I);

EVEN := (IF I = 2 * (I / 2) THEN 1 ELSE 0);

END;

 

=={{header|ALGOL W}}==

% the Algol W standard procedure odd returns true if its integer %

% parameter is odd, false if it is even %

write( i, " is ", if odd( i ) then "odd" else "even" )

end for_i

{{out}}

<pre>

 

=={{header|AntLang}}==

 

=={{header|APL}}==

The easiest way is probably to use modulo.

0

2|37

 

So you can write a user-defined operator.

 

=={{header|AppleScript}}==

 

set evens to {}

end repeat

 

{{out}}

 

 

(deriving '''even''' from mod, and '''odd''' from even):

 

-- even :: Int -> Bool

-- mReturn :: First-class m => (a -> b) -> m (a -> b)

on mReturn(f)

if script is class of f then

f

end script

end if

{{Out}}

 

=={{header|Arendelle}}==

"| @input | is odd!"

}</pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI or android 32 bits */

 

see at end of this program the instruction include */

/* for constantes see task include a file in arm assembly */

sMessResultEven: .asciz " @ is even (pair) \n"

szCarriageReturn: .asciz "\n"

/*********************************/

/* UnInitialized data */

/*********************************/

.text

 

mov r0,#5

mov r0,#2021

bl testOddEven

mov r0, #0 @ return code

mov r7, #EXIT @ request to exit program

svc #0 @ perform the system call

iAdrszCarriageReturn: .int szCarriageReturn

iAdrsMessResultOdd: .int sMessResultOdd

// r0 contains à number

testOddEven:

tst r0,#1 @ test bit 0 to one

beq 1f @ if result are all zéro, go to even

/***************************************************/

.include "../affichage.inc"

 

=={{header|ArnoldC}}==

I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n

GIVE THESE PEOPLE AIR

DO IT NOW showParity 6

DO IT NOW showParity -11

{{out}}

<pre>

 

=={{header|Arturo}}==

if? even? x -> print [pad to :string x 4 ": even"]

else -> print [pad to :string x 4 ": odd"]

{{out}}

<pre> -5 : odd

-4 : even

 

=={{header|Asymptote}}==

if (i % 2 == 0) {

write(string(i), " is even");

write(string(i), " is odd");

}

 

 

=={{header|AutoHotkey}}==

Bitwise ops are probably most efficient:

; do odd stuff

}else{

; do even stuff

 

=={{header|AWK}}==

}

 

function iseven(x) {

 

OPTION MEMTYPE int

SPLIT ARGUMENT$ BY " " TO arg$ SIZE dim

n = IIF$(dim < 2, 0, VAL(arg$[1]))

{{out}}

<pre>prompt$ ./even-or-odd 42

41 is odd</pre>

 

 

 

 

Uses bitwise AND as suggested.

 

20 print "Enter an integer:";

30 input i%

40 eo$="even"

50 if (i% and 1)=1 then eo$="odd"

 

==={{header|GW-BASIC}}===

10 INPUT "Enter a number: ", N

 

==={{header|IS-BASIC}}===

110 INPUT PROMPT "Enter a number: ":X

120 IF ODD(X) THEN

140 ELSE

150 PRINT X;"is even."

 

==={{header|Minimal BASIC}}===

30 INPUT N

40 IF N/2 <> INT(N/2) THEN 70

60 GOTO 80

70 PRINT "The number is odd."

 

==={{header|QB64}}===

NB: Line numbers are not required in this language. Further, because of the Int variable type used for input, floating point values will not be accepted by the program. 0 is a problem, though, as it returns "Even" in the code below, even though it is not mathematically an even value. For code brevity, the 0 problem is not addressed. Finally, No Even or Odd predicates exist in this language.

 

'for user input terminated by pressing [ENTER].

'Binary integers example

'There is no global or constant "True" or "False".

Print "Odd" 'Prints "Odd" if the above tested "true".

Else 'This could have been also been "ElseIf Not (i% And 1)"

'or if the logical inverse of the input value AND 1 tested

'"true" (ElseIf).

Else

Print "Still Even"

 

==={{header|Tiny BASIC}}===

20 INPUT N

30 IF 2*(N/2) = N THEN GOTO 60

40 PRINT "It's odd."

50 END

 

=={{header|Batch File}}==

 

::bitwise and

 

set test

 

=={{header|bc}}==

There are no bitwise operations, so this solution compares a remainder with zero. Calculation of ''i % 2'' only works when ''scale = 0''.

 

/* Assumes that i is an integer. */

"

if (i % 2) "i is odd

 

=={{header|Beads}}==

 

calc main_init

loop across:[-10, -5, 10, 5] val:v

 

{{out}}

 

=={{header|Befunge}}==

 

Outputs E if even, O if odd.

 

=={{header|BQN}}==

odd ← 2⊸|

 

!0 ≡ odd 12

 

=={{header|Bracmat}}==

Not the simplest solution, but the cheapest if the number that must be tested has thousands of digits.

=

. @( !arg

& eventest$857234098750432987502398457089435

& oddtest$857234098750432987502398457089435

{{out}}

<pre>5556 is even

 

=={{header|Brainf***}}==

Output is input <tt>mod</tt> 2.

++< Get a 2 and move into position

[->-[>+>>]> Do

>[-]<++++++++ Clear and get an 8

[>++++++<-] to get a 48

 

the following is sufficient; it terminates either quickly or never.

 

=={{header|Burlesque}}==

 

=={{header|C}}==

Test by bitwise and'ing 1, works for any builtin integer type as long as it's 2's complement (it's always so nowadays):

/* x is odd */

} else {

/* or not */

If using long integer type from GMP (<code>mpz_t</code>), there are provided macros:

...

if (mpz_even_p(x)) { /* x is even */ }

The macros evaluate <code>x</code> more than once, so it should not be something with side effects.

 

=={{header|C sharp|C#}}==

{

using System;

}

}

 

=={{header|C++}}==

Test using the modulo operator, or use the C example from above.

{

return x % 2;

{

return !(x % 2);

 

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

 

constexpr inline bool isEven( const T& v )

{

}

 

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

{

}

 

constexpr inline bool isOdd( const T& v )

{

return !isEven(v);

}

 

=={{header|Clojure}}==

Standard predicates:

 

=={{header|COBOL}}==

DISPLAY Num " is even."

ELSE

DISPLAY Num " is odd."

 

=={{header|CoffeeScript}}==

 

=={{header|ColdFusion}}==

function f(numeric n) {

return n mod 2?"odd":"even"

}

 

=={{header|Common Lisp}}==

Standard predicates:

===Alternate solution===

I use [https://franz.com/downloads/clp/survey Allegro CL 10.1]

 

;; Project : Even or odd

 

(cond ((evenp nr) "even")

((oddp nr) "odd")))

(if (< n 1) (terpri))

(if (< n 9) (format t "~a" " "))

(write(+ n 1)) (format t "~a" ": ")

(format t "~a" (evenodd (+ n 1))) (terpri))

Output:

<pre>

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE EvenOdd;

IMPORT StdLog,Args,Strings;

WHILE i < p.argc DO

Strings.StringToInt(p.args[i],x,done);

IF ODD(x) THEN StdLog.String("odd") ELSE StdLog.String("even") END;

StdLog.Ln;INC(i)

WHILE i < p.argc DO

Strings.StringToInt(p.args[i],x,done);

IF BitwiseOdd(x) THEN StdLog.String("odd") ELSE StdLog.String("even") END;

StdLog.Ln;INC(i)

WHILE i < p.argc DO

Strings.StringToInt(p.args[i],x,done);

IF Odd(x) THEN StdLog.String("odd") ELSE StdLog.String("even") END;

StdLog.Ln;INC(i)

WHILE i < p.argc DO

Strings.StringToInt(p.args[i],x,done);

IF CongruenceOdd(x) THEN StdLog.String("odd") ELSE StdLog.String("even") END;

StdLog.Ln;INC(i)

END;

END Do;

Execute: ^Q EvenOdd.Do 10 11 0 57 34 -23 -42~<br/>

{{out}}

 

=={{header|Crystal}}==

def isEven_bShift(n)

n == ((n >> 1) << 1)

puts isEven_bAnd(21)

puts isOdd_bAnd(21)

{{out}}

<pre>false

 

=={{header|D}}==

import std.stdio, std.bigint;

 

foreach (immutable i; -5 .. 6)

writeln(i, " ", i & 1, " ", i % 2, " ", i.BigInt % 2);

{{out}}

<pre>-5 1 -1 -1

4 0 0 0

5 1 1 1</pre>

 

=={{header|DCL}}==

$

$ i = -5

$ if .not. i then $ write sys$output i, " is even"

$ i = i + 1

{{out}}

<pre>$ @even_odd

 

=={{header|Delphi}}==

program EvenOdd;

 

Readln;

end.

 

{{out}}

10 is even

</pre>

 

=={{header|Déjà Vu}}==

= 0 % n 2

 

!. odd 7

!. even 7

{{out}}

<pre>false

true

false</pre>

 

=={{header|EDSAC order code}}==

This implementation uses the <code>C</code> (logical AND multiplier register with memory) order. It will cause the machine to print an <tt>E</tt> if the number stored at address <i>θ</i>+15 is even, or an <tt>O</tt> if it is odd. As an example, we shall test the number 37 (<code>P18D</code> in EDSAC encoding).

===========

 

[ 15 ] P18D [ number to test: 37 ]

 

{{out}}

<pre>O</pre>

 

=={{header|Eiffel}}==

if i.bit_and (1) = 0 then

-- i is even

if i \\ 2 = 0 then

-- i is even

 

=={{header|Elixir}}==

import Integer

def even_or_odd(n) when 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

end

 

 

{{out}}

</pre>

Other ways to test even-ness:

 

=={{header|Emacs Lisp}}==

 

(defun even-or-odd-p (n)

 

(message "%d is %s" 3 (even-or-oddp 3))

 

{{out}}

3 is odd

2 is even

 

=={{header|Erlang}}==

===Using Division by 2 Method===

-module(even_odd).

-export([main/0]).

true ->

io:format("even\n")

===Using the least-significant bit method===

-module(even_odd2).

-export([main/0]).

true ->

io:format("even\n")

 

=={{header|ERRE}}==

 

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

IF ISODD#(9876543211) THEN PRINT("9876543211 is odd") ELSE PRINT("9876543211 is even") END IF

END PROGRAM

{{out}}

<pre>

=={{header|Euphoria}}==

Using standard function

include std/math.e

 

? {i, is_even(i)}

end for

{{out}}

<pre>

=={{header|Excel}}==

Use the MOD function

=MOD(33;2)

=MOD(18;2)

 

{{out}}

 

Use the ISEVEN function, returns TRUE or FALSE

=ISEVEN(33)

=ISEVEN(18)

 

{{out}}

 

Use the ISODD function, returns TRUE or FALSE

=ISODD(33)

=ISODD(18)

 

{{out}}

 

Bitwise and:

 

Modulo:

 

=={{header|Factor}}==

=={{header|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.

>l0)?!vo v < v o<

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

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

 

=={{header|Forth}}==

 

=={{header|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.

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Tue May 21 20:22:56

write(6, '((13i3),a8/(13l3),a8/(13l3),a8)') j, 'n', odd(j), 'odd', even(j), 'even'

end program oe

 

=={{header|Frink}}==

 

=={{header|Futhark}}==

{{incorrect|Futhark|Futhark's syntax has changed, so this example will not compile}}

 

fun main(x: int): bool = (x & 1) == 0

 

=={{header|Fōrmulæ}}==

 

 

 

 

 

 

 

 

 

 

=={{header|GAP}}==

 

=={{header|Genie}}==

Using bitwise AND of the zero-bit.

/*

Even or odd, in Genie

show_parity(2)

show_parity(-2)

 

{{out}}

 

=={{header|Go}}==

 

import (

fmt.Println("odd")

}

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

Test:

 

 

=={{header|Haskell}}==

<code>even</code> and <code>odd</code> functions are already included in the standard Prelude.

False

Prelude> even 42

True

Prelude> odd 42

 

Where '''even''' is derived from '''rem''', and '''odd''' is derived from even:

 

even, odd

 

main :: IO ()

{{Out}}

<pre>[True,False,True,False,True,False,True,False,True,False]</pre>

 

=={{header|Hoon}}==

?: =((mod n 2) 0)

"even"

 

=={{header|Icon}} and {{header|Unicon}}==

One way is to check the remainder:

return n%2 = 0

 

=={{header|J}}==

Modulo:

0 1 1 1

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

Remainder:

1 0 0 0

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

Last bit in bit representation:

0 1 1 1

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

Bitwise and:

Note: as a general rule, the simplest expressions in J should be preferred over more complex approaches.

 

=={{header|Java}}==

Bitwise and:

return (i & 1) == 0;

Modulo:

return (i % 2) == 0;

Arbitrary precision bitwise:

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

Arbitrary precision bit test (even works for negative numbers because of the way <code>BigInteger</code> represents the bits of numbers):

return !i.testBit(0);

Arbitrary precision modulo:

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

 

=={{header|JavaScript}}==

===ES5===

Bitwise:

return (i & 1) === 0;

}

Modulo:

return i % 2 === 0;

}

function isEven( i ) {

return !(i % 2);

 

===ES6===

Lambda:

 

or, avoiding type coercion:

'use strict';

 

 

return show([xs.filter(even), xs.filter(odd)]);

 

{{Out}}

<pre>[[-6,-4,-2,0,2,4,6],[-5,-3,-1,1,3,5]]</pre>

 

 

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:

 

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

"is_odd" could be similarly defined:

 

 

=={{header|Jsish}}==

Using bitwise and of low bit.

 

/* Even or Odd, in Jsish */

function isEven(n:number):boolean { return (n & 1) === 0; }

isEven(-13) ==> false

=!EXPECTEND!=

{{out}}

<pre>$ jsish --U isEven.jsi

=={{header|Julia}}==

Built-in functions:

 

=={{header|K}}==

The following implementation uses the modulo of

division by 2

oddp: {:[x!2;1;0]} /Returns 1 if arg. is odd

evenp: {~oddp[x]} /Returns 1 if arg. is even

evenp 32

1

 

 

=={{header|Klingphix}}==

dup print " " print 2 mod ( ["Odd"] ["Even"] ) if print nl

] for

 

{{out}}

<pre>-5 Odd

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

}

}

 

=={{header|Lambdatalk}}==

 

-> is_odd

 

{is_even 2}

-> true

 

=={{header|L++}}==

 

=={{header|LabVIEW}}==

 

=={{header|Lang5}}==

: odd? 2 % ;

1 even? . # 0

 

=={{header|Lasso}}==

#i % 2 ? return 'odd'

return 'even'

}

 

=={{header|LC3 Assembly}}==

Prints <tt>EVEN</tt> if the number stored in <tt>NUM</tt> is even, otherwise <tt>ODD</tt>.

 

LD R0,NUM

ODD .STRINGZ "ODD\n"

 

 

=={{header|Lingo}}==

return n mod 2 = 0

end

on odd (n)

return n mode 2 <> 0

 

=={{header|Little Man Computer}}==

 

LMC has no division instruction. To divide by 2 we could use repeated subtraction:

// Input number; output its residue mod 2

INP // read input into acc

k2 DAT 2 // constant 2

// end

The above program might need 500 subtractions before it found the result. To speed things up we could use something along the following lines.

// Input number; output its residue mod 2

INP // read input into accumulator

save_acc DAT

// end

Note: LMC, in its original form, does not support negative numbers. If the accumulator contains a number X, and a number Y > X is subtracted, then the negative flag is set and the value in the accumulator becomes undefined. So we can't assume that adding Y back to the accumulator will restore the value of X. If we want to use X again, we need to save it in RAM before doing the subtraction.

 

 

=={{header|LiveCode}}==

return (n bitand 1) = 1

end odd

function notEven n

return (n mod 2) = 1

 

=={{header|LLVM}}==

; LLVM does not provide a way to print values, so the alternative would be

; to just load the string into memory, and that would be boring.

}

 

{{out}}

<pre>0 is even

 

=={{header|Logo}}==

output equal? 0 modulo :num 2

 

=={{header|Logtalk}}==

:- object(even_odd).

 

 

:- end_object.

{{out}}

| ?- even_odd::test_mod(1).

odd

even

yes

 

=={{header|LOLCODE}}==

I HAS A integer

GIMMEH integer

VISIBLE "The integer is even."

OIC

 

=={{header|Lua}}==

 

if n % 2 == 0 then

print "The number is even"

if not (n % 2 == 0) then

print "The number is odd"

 

=={{header|M2000 Interpreter}}==

So Mod if a perfect choice, using it with Decimals (character @ indicate a Decimal type or literal).

Variable a take the type of input. There is no reason here to write it as def Odd(a as decimal)= binary.and(Abs(a), 1)=1

 

 

A function F(x) {} is same as

<pre >

Function F {

}

</pre >

The same hold for Def Odd(a)=binary.and(Abs(a), 1)=1

Interpreter execute this:

So here is the task. Show an overflow from a decimal, then change function.

 

Module CheckOdd {

Def Odd(a)= binary.and(Abs(a), 1)=1

Print Odd(-5), Odd(6), Odd(11)

def Odd(a)= Int(Abs(a)) mod 2 =1

Print Odd(21212121212122122122121@)

}

CheckOdd

 

=={{header|M4}}==

define(`odd', `ifelse(eval(`$1'%2),0,False,True)')

 

 

odd(5)

 

=={{header|Maple}}==

if x mod 2 = 0 then

print("Even"):

end if:

end proc:

<pre>"Odd"</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

Modulo: 2

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

-- Open the MAXScript Listener for input and output

userInt = getKBValue prompt:"Enter an integer and i will tell you if its Even or Odd : "

else if (Mod userInt 2) == 0 Then Print "Your number is even"

else Print "Your number is odd"

 

=={{header|Mercury}}==

Mercury's 'int' module provides tests for even/odd, along with all the operators that would be otherwise used to implement them.

odd(N). % in a body, succeeds iff N is odd.

 

even(N) :- N mod 2 = 0. % using division that truncates towards -infinity

even(N) :- N rem 2 = 0. % using division that truncates towards zero

 

=={{header|min}}==

{{works with|min|0.19.3}}

4 even?

5 odd?

{{out}}

<pre>

 

=={{header|MiniScript}}==

if i % 2 == 0 then print i + " is even" else print i + " is odd"

{{out}}

<pre>-4 is even

=={{header|MIPS Assembly}}==

This uses bitwise AND

.data

even_str: .asciiz "Even"

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

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

 

=={{header|МК-61/52}}==

 

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

 

=={{header|ML}}==

fun even( x: int ) = (x mod 2 = 0);

fun odd( x: int ) = (x mod 2 = 1);

==={{header|mLite}}===

| _ = false

;

 

| _ = false

 

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,ReadChar;

 

ReadChar

 

=={{header|Nanoquery}}==

if ((n % 2) = 1)

return false

println " is odd."

end

{{out}}

<pre>1 is odd.

 

=={{header|Neko}}==

 

if(number % 2 == 0) {

} else {

$print("Odd");

 

{{out}}

=={{header|NESL}}==

NESL provides <tt>evenp</tt> and <tt>oddp</tt> functions, but they wouldn't be hard to reimplement.

 

% test the function by applying it to the first ten positive integers: %

{{out}}

<pre>it = [F, T, F, T, F, T, F, T, F, T] : [bool]</pre>

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

else sv = 'Odd'

return sv.left(4)

{{out}}

<pre>

 

=={{header|Never}}==

func isOdd(n : int) -> int {

n % 2 == 1

n % 2 == 0

}

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

proc isOdd(i: int): bool = (i and 1) != 0

proc isEven(i: int): bool = (i and 1) == 0

 

echo isEven(1)

 

=={{header|Oberon-2}}==

{{works with|oo2c}}

MODULE EvenOrOdd;

S := SYSTEM,

Out;

BEGIN

x := 10;Out.Int(x,0);

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;

 

x := 12;Out.Int(x,0);

Out.Ln

END EvenOrOdd.

{{out}}

<pre>

 

=={{header|Objeck}}==

if(a % 2 = 0) {

"even"->PrintLine();

else {

"odd"->PrintLine();

 

=={{header|OCaml}}==

Modulo:

(d mod 2) = 0

 

let is_odd d =

Bitwise and:

(d land 1) = 0

 

let is_odd d =

 

An instructive view on functional programming and recursion:

| 0 -> true

| 1 -> false

 

(* and here we have the not function in if form *)

 

=={{header|Oforth}}==

 

 

=={{header|Ol}}==

Actually, 'even?' and 'odd?' functions are built-in. But,

 

; 1. Check the least significant bit.

(define (even? i)

(print (if (odd? 1234567898765432) "odd" "even")) ; ==> even

 

 

=={{header|OOC}}==

// Using the modulo operator

even: func (n: Int) -> Bool {

(n & 1) == 1

}

 

=={{header|PARI/GP}}==

GP does not have a built-in predicate for testing parity, but it's easy to code:

Alternately:

PARI can use the same method as [[#C|C]] for testing individual words. For multiprecision integers (t_INT), use <code>mpodd</code>. If the number is known to be nonzero, <code>mod2</code> is (insignificantly) faster.

 

=={{header|Pascal}}==

Built-in boolean function odd:

bitwise and:

begin

isOdd := boolean(Number and 1)

Dividing and multiplying by 2 and test on equality:

begin

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

Using built-in modulo

begin

isOdd := boolean(Number mod 2)

 

=={{header|Perl}}==

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

or

 

=={{header|Phix}}==

There are builtin routines odd() and even() which return true/false - note however they will round non-integer arguments to the nearest whole number, which might be confusing. The mpz_odd() and mpz_even() are similar, but without any way to pass them fractions. In fact odd() invokes and_bits(i,1)=1 and even() invokes and_bits(i,1)=0, so no difference there, and "i&&1" is just shorthand for and_bits(i,1). Lastly remainder(i,2) can also validly be used, however "true" for odd numbers is actually 1 for positive odd integers and -1 for negative odd integers, plus fractions are preserved, so "remainder(i,2)==0" is perhaps for some uses a more flexible and accurate "even"/"not even" test.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%2d: %5t %5t %3d %5d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">odd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">even</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">),</span><span style="color: #000000;">i</span><span style="color: #0000FF;">&&</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">remainder</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

dup print " " print 2 mod if "Odd" else "Even" endif print nl

 

=={{header|PHP}}==

// using bitwise and to check least significant digit

echo (2 & 1) ? 'odd' : 'even';

echo (3 % 2) ? 'odd' : 'even';

echo (4 % 2) ? 'odd' : 'even';

 

{{out}}

odd

even</pre>

 

=={{header|PicoLisp}}==

PicoLisp doesn't have a built-in predicate for that. Using '[http://software-lab.de/doc/refB.html#bit? bit?]' is the easiest and most efficient. The bit test with 1 will return NIL if the number is even.

-> 1 # Odd

 

: (bit? 1 4)

 

=={{header|Pike}}==

> (i&1);

Result: 1

> i%2;

 

=={{header|PL/I}}==

The result is 1 when i is odd, and 0 when i is even.

 

at all.

 

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

 

CALL EXIT;

{{out}}

<pre>0 IS EVEN

=={{header|Plain English}}==

The noodle comes with even and odd deciders.

Start up.

If 56 is even, write "56 is even!" to the console.

If 4 is odd, write "4 is odd!" to the console.

Wait for the escape key.

{{out}}

<pre>

===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].

$IsOdd = -not ( [bigint]$N ).IsEven

$IsEven = ( [bigint]$N ).IsEven

===Least significant digit===

$IsOdd = [boolean]( $N -band 1 )

$IsEven = [boolean]( $N -band 0 )

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

$IsOdd = $N % 2 -ne 0

$IsEven = $N % 2 -eq 0

 

=={{header|Processing}}==

boolean isEven(int i){

return i%2 == 0;

return i%2 == 1;

}

 

=={{header|Prolog}}==

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:

even(N) :-

(between(0, inf, N); integer(N) ),

0 is N mod 2.

===Least Significant Bit===

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

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

 

=={{header|Python}}==

===Python: Using the least-significant bit method===

 

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

>>> [(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)]

 

===Python: Using modular congruences===

return (i % 2) == 0

 

>>> is_even(2)

True

 

=={{header|Quackery}}==

 

{{out}}

In the Quackery shell (REPL):

See also [https://rosettacode.org/wiki/Mutual_recursion#Quackery Mutual recursion#Quackery] and [https://rosettacode.org/wiki/Anonymous_recursion#Quackery Anonymous recursion#Quackery].

 

[ 2drop true ] done

1 - this swap rot do ] ( x n --> b )

' [ dup 0 = iff

[ 2drop false ] done

1 - this swap rot do ] ( x n --> b )

unrot do ] is even ( n --> b )

 

[ i^ 5 - dup echo

even iff [ $ "even" ]

 

{{out}}

 

=={{header|R}}==

 

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

#or

 

=={{header|Racket}}==

With built in predicates:

(even? 5) ; -> false

(odd? 6) ; -> false

 

With modular arithmetic:

 

(define (my-odd? x)

 

=={{header|Raku}}==

(formerly Perl 6)

Raku doesn't have a built-in for this, but with subsets it's easy to define a predicate for it.

subset Odd of Int where * % 2;

 

say 1 ~~ Even; # false

say 1 ~~ Odd; # true

 

=={{header|Rascal}}==

Or with block quotes:

 

=={{header|Red}}==

date: 2021-10-24

red-version: 0.6.4

 

print even? 10 ;== true

 

=={{header|ReScript}}==

 

 

=={{header|REXX}}==

:::* by removing a superfluous leading &nbsp; '''+''' &nbsp; sign

:::* by removing superfluous leading zeroes

:::* by removing a trailing decimal point

:::* possible converting an exponentiated number

:::* possible rounding the number to the current ''digits''

 

<br>It requires a sparse stemmed array &nbsp; &nbsp; '''!.''' &nbsp; &nbsp; be defined in the program's prologue (or elsewhere).

 

<br>shown would be the simplest &nbsp; (in terms of coding the concisest/tightest/smallest code). &nbsp; The other test

<br>The last method shown is the fastest algorithm, albeit it might be a bit obtuse (without comments) to a

<br>novice reader of the REXX language &nbsp; (and it requires additional REXX statement baggage).

!.=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".*/

odd: return arg(1)//2 /*returns "oddness" of the argument. */

tell: say; say center('using the' arg(1), 79, "═"); return

'''output''' &nbsp; when using the input of: &nbsp; <tt> 0 </tt>

<pre>

 

=={{header|Ring}}==

size = 10

for i = 1 to size

else see "" + i + " is even" + nl ok

next

 

 

p -5.upto(5).select(&:even?)

print "odds: "

{{out}}

<pre>evens: [-4, -2, 0, 2, 4]

odds: [-5, -3, -1, 1, 3, 5]</pre>

Other ways to test even-ness:

quotient, remainder = n.divmod(2); remainder == 0

 

# You can use the bracket operator to access the i'th bit

# of a Fixnum or Bignum (i = 0 means least significant bit)

 

=={{header|Rust}}==

Checking the least significant digit:

 

Using modular congruences:

 

=={{header|Scala}}==

Accept any numeric type as an argument:

{{out}}

<pre>isOdd( 81 ) // Results in true

=={{header|Scheme}}==

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

#f

> (even? 42)

#t

> (odd? 42)

 

=={{header|Seed7}}==

Test whether an integer or bigInteger is odd:

Test whether an integer or bigInteger is even:

 

=={{header|SenseTalk}}==

set num to random of 100 -- start with a random number from 1 to 100

 

// check to see if the remainder is 0 when dividing by 2

if num rem 2 is 0 then put num & " is even (zero remainder)"

 

=={{header|SequenceL}}==

 

{{out}}

=={{header|SETL}}==

SETL provides built-in <tt>even</tt> and <tt>odd</tt> functions. This short program illustrates their use.

evens := {x in xs | even( x )};

odds := {x in xs | odd( x )};

print( evens );

{{out}}

<pre>{2 4 6 8 10}

 

Mutual Recursion:

0 -> true

X -> (odd? (- X 1)))

(define odd?

0 -> false

 

Modulo:

 

 

=={{header|Sidef}}==

Built-in methods:

say n.is_odd; # false

 

Checking the last significant digit:

 

Using modular congruences:

 

=={{header|Smalltalk}}==

Using the built in methods on Number class:

 

 

even is implemented as follows:

^((self digitAt: 1) bitAnd: 1) = 0

 

=={{header|SNOBOL4}}==

{{works with|Spitbol}}

{{Works with|SNOBOL4+}}

even even = (EQ(REMDR(n, 2), 0) 'even', 'odd') :(RETURN)

even_end

OUTPUT = "1 is " even(1)

OUTPUT = "2 is " even(2)

{{output}}<pre>-2 is even

-1 is odd

 

=={{header|SNUSP}}==

$====!/?\==even#

- -

#odd==\?/

 

=={{header|SPL}}==

? #.even(n), #.output(n," even")

? #.odd(n), #.output(n," odd")

{{out}}

<pre>

=={{header|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)".

create table ints(int integer);

insert into ints values (-1);

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

from

 

{{out}}

 

For larger positive or smaller negative values of <math>n</math>, 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.

00000000000000110000000000000000 1. Test

11110000000001100000000000000000 2. c to 15

00000000000001110000000000000000 12. Stop

10000000000000000000000000000000 13. 1

 

=={{header|Standard ML}}==

n mod 2 = 0;

 

n mod 2 <> 0;

 

type werd = Word.word;

 

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

 

 

=={{header|Stata}}==

function iseven(n) {

return(mod(n,2)==0)

return(mod(n,2)==1)

}

 

=={{header|Swift}}==

// Bitwise check

if (n & 1 != 0) {

return false

}

// Mod check

if (n % 2 != 0) {

}

return true

 

=={{header|Symsyn}}==

n : 23

 

else

'n is even' []

 

=={{header|Tcl}}==

 

# Bitwise test is the most efficient

puts " # O E"

puts 24:[expr isOdd(24)],[expr isEven(24)]

{{out}}

<pre>

</pre>

 

 

=={{header|TUSCRIPT}}==

LOOP n=-5,5

x=MOD(n,2)

PRINT n," is odd"

ENDSELECT

{{out}}

<pre>

 

=={{header|UNIX Shell}}==

 

=={{header|Ursa}}==

set input (in int console)

if (= (mod input 2) 1)

else

out "even" endl console

Output:

<pre>123

 

=={{header|உயிர்/Uyir}}==

எ இன் வகை எண்{$5} = 0;

படை வகை சரம்;

 

முதன்மை = 0;

 

=={{header|Verilog}}==

integer i;

initial begin

for (i = 1; i <= 10; i = i+1) begin

$finish ;

end

 

 

 

 

 

=={{header|WDTE}}==

let str => import 'strings';

 

-> s.map (@ s n => str.format '{} is {}.' n (evenOrOdd n))

-> s.map (io.writeln io.stdout)

 

=={{header|WebAssembly}}==

This solution tests the low bit of the given integer, which is always 0 for even numbers and 1 for odd numbers (including negative numbers).

 

;; function isOdd: returns 1 if its argument is odd, 0 if it is even.

(func $isOdd (param $n i32) (result i32)

)

(export "isOdd" (func $isOdd))

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var isEven1 = Fn.new { |i| i & 1 == 0 }

System.print("Method 1 : %(Fmt.v("s", -4, res1, 0, " ", ""))")

var res2 = tests.map { |t| isEven2.call(t) ? "even" : "odd" }.toList

 

{{out}}

 

=={{header|x86-64 Assembly}}==

evenOdd:

mov rax,1

and rax,rdi

ret

 

=={{header|XBS}}==

Typed XBS

evenOrOdd function

foreach(v of arr){

log(v+" is even? "+evenOrOdd(v))

{{out}}

<pre>

 

=={{header|xEec}}==

>100 p i# jz-1 o# t h#1 ms jz2003 p >0110 h#2 r ms t h#1 ms p

jz1002 h? jz2003 p jn0110 h#10 o$ p jn100 >2003 p p h#0 h#10

h$d h$d h$o h#32 h$s h$i h#32 jn0000 >1002 p p h#0 h#10

h$n h$e h$v h$e h#32 h$s h$i h#32 >0000 o$ p jn0000 jz100

 

=={{header|XLISP}}==

XLISP provides <tt>EVENP</tt> and <tt>ODDP</tt>, or, if you prefer, <tt>EVEN?</tt> and <tt>ODD?</tt>; if one wanted to reimplement them, it could be done like this (or in other ways).

(= (logand x 1) 0) )

 

(defun my-oddp (x)

 

=={{header|Xojo}}==

For num As Integer = 1 To 5

If num Mod 2 = 0 Then

End If

Next

 

{{Out}}

 

=={{header|XPL0}}==

int I;

[for I:= -4 to +3 do

[IntOut(0, I);

Text(0, if rem(I/2)#0 then "odd" else "even");

CrLf(0);

];

 

{{out}}

3 is odd odd

</pre>

 

=={{header|Z80 Assembly}}==

Z80 Assembly has a few ways of testing if a number is even or odd:

===RRC===

 

===AND===

<code>AND 1</code> will change the accumulator to 1 if its value was odd, and 0 if its value was even. If you want to selectively load a 0 or 1 into the accumulator based on whether a variable is odd or even, this is the best way to do so. Like the <code>RRC</code> method, this test is destructive, so if you need to preserve the original value of the accumulator after the test, use the method below instead.

 

===BIT===

This method is the slowest, but it doesn't change the value in the register being tested. It works on any 8 bit register, (HL), (IX+#), or (IY+#), making it the most versatile. Although I say it's the slowest, the difference is so small and the execution time so fast that you'd never notice anyway. The Z80 can perform all these tests faster than you can blink!

 

=={{header|zkl}}==

Ints have isEven and isOdd properties. pump, in this case, is the same as apply/map without aggregating a result.

{{out}}

4 is even

</pre>

{{out}}

<pre>L(False,True,False,True,False,True,False,True)</pre>

 

=={{header|Zoea}}==

program: even_or_odd

case: 1

input: 7

output: odd

 

=={{header|Zoea Visual}}==

 

=={{header|zonnon}}==

module Main;

var

s := set(x);writeln(x:3," is odd?",0 in s); (* check right bit *)

end Main.

{{Out}}

<pre>

11 is odd? true

</pre>