Even or odd: Difference between revisions
Add Seed7 example |
→Nu: add |
||
(340 intermediate revisions by more than 100 users not shown) | |||
Line 1: | Line 1: | ||
{{task}} |
{{task}} [[Category:Simple]] |
||
;Task: |
|||
Test whether an integer is even or odd. |
Test whether an integer is even or odd. |
||
Line 10: | Line 12: | ||
** ''i'' ≡ 0 (mod 2) iff ''i'' is even. |
** ''i'' ≡ 0 (mod 2) iff ''i'' is even. |
||
** ''i'' ≡ 1 (mod 2) iff ''i'' is odd. |
** ''i'' ≡ 1 (mod 2) iff ''i'' is odd. |
||
<br><br> |
|||
=={{header| |
=={{header|0815}}== |
||
<syntaxhighlight lang="0815"> |
|||
Bitwise ops are probably most efficient: |
|||
}:s:|=<:2:x~#:e:=/~%~<:20:~$=<:73:x<:69:~$~$~<:20:~$=^:o:<:65: |
|||
<lang AHK>if ( int & 1 ){ |
|||
x<:76:=$=$~$<:6E:~$<:a:~$^:s:}:o:<:6F:x<:64:x~$~$$<:a:~$^:s: |
|||
; do odd stuff |
|||
</syntaxhighlight> |
|||
}else{ |
|||
; do even stuff |
|||
=={{header|11l}}== |
|||
}</lang> |
|||
<syntaxhighlight lang="11l">F is_even(i) |
|||
R i % 2 == 0 |
|||
F is_odd(i) |
|||
R i % 2 == 1</syntaxhighlight> |
|||
=={{header|6502 Assembly}}== |
|||
<syntaxhighlight lang="6502 assembly"> |
|||
.lf evenodd6502.lst |
|||
.cr 6502 |
|||
.tf evenodd6502.obj,ap1 |
|||
;------------------------------------------------------ |
|||
; Even or Odd for the 6502 by barrym95838 2014.12.10 |
|||
; Thanks to sbprojects.com for a very nice assembler! |
|||
; The target for this assembly is an Apple II with |
|||
; mixed-case output capabilities. Apple IIs like to |
|||
; work in '+128' ascii, and this version is tailored |
|||
; to that preference. |
|||
; Tested and verified on AppleWin 1.20.0.0 |
|||
;------------------------------------------------------ |
|||
; Constant Section |
|||
; |
|||
CharIn = $fd0c ;Specific to the Apple II |
|||
CharOut = $fded ;Specific to the Apple II |
|||
;------------------------------------------------------ |
|||
; The main program |
|||
; |
|||
main ldy #sIntro-sbase |
|||
jsr puts ;Print Intro |
|||
loop jsr CharIn ;Get a char from stdin |
|||
cmp #$83 ;Ctrl-C? |
|||
beq done ; yes: end program |
|||
jsr CharOut ;Echo char |
|||
ldy #sOdd-sbase ;Pre-load odd string |
|||
lsr ;LSB of char to carry flag |
|||
bcs isodd |
|||
ldy #sEven-sbase |
|||
isodd jsr puts ;Print appropriate response |
|||
beq loop ;Always taken |
|||
; Output NUL-terminated string @ offset Y |
|||
; |
|||
puts lda sbase,y ;Get string char |
|||
beq done ;Done if NUL |
|||
jsr CharOut ;Output the char |
|||
iny ;Point to next char |
|||
bne puts ;Loop up to 255 times |
|||
done rts ;Return to caller |
|||
;------------------------------------------------------ |
|||
; String Constants (in '+128' ascii, Apple II style) |
|||
; |
|||
sbase: ;String base address |
|||
sIntro .az -"Hit any key (Ctrl-C to quit):",-#13 |
|||
sEven .az -" is even.",-#13 |
|||
sOdd .az -" is odd.",-#13 |
|||
;------------------------------------------------------ |
|||
.en |
|||
</syntaxhighlight> |
|||
=={{header|68000 Assembly}}== |
|||
===Non-Destructive=== |
|||
<syntaxhighlight lang="68000devpac">BTST D0,#1 |
|||
BNE isOdd |
|||
;else, is even.</syntaxhighlight> |
|||
===Destructive=== |
|||
<syntaxhighlight lang="68000devpac">AND.B D0,#1 |
|||
BNE isOdd |
|||
;else, is even.</syntaxhighlight> |
|||
<syntaxhighlight lang="68000devpac">ROR.B D0,#1 |
|||
BCS isOdd |
|||
;else, is even.</syntaxhighlight> |
|||
<syntaxhighlight lang="68000devpac">ROXR.B D0,#1 |
|||
BCS isOdd |
|||
;else, is even.</syntaxhighlight> |
|||
<syntaxhighlight lang="68000devpac">LSR.B D0,#1 |
|||
BCS isOdd |
|||
;else, is even.</syntaxhighlight> |
|||
<syntaxhighlight lang="68000devpac">ASR.B D0,#1 |
|||
BCS isOdd |
|||
;else, is even.</syntaxhighlight> |
|||
You can also use <code>BCLR</code>,<code>BSET</code>, and <code>BCHG</code> in the same way you use <code>BTST</code>, as all of them copy the affected bit to the zero flag. <code>BCLR</code>,<code>BSET</code>, and <code>BCHG</code> will change the value of that bit after the test, so keep that in mind. |
|||
=={{header|8080 Assembly}}== |
|||
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 |
|||
set if odd and clear if even. |
|||
<syntaxhighlight lang="8080asm">CMDLIN: equ 80h ; Location of CP/M command line argument |
|||
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 |
|||
mov a,m |
|||
add l ; Look up last character (digit) |
|||
mov l,a |
|||
mov a,m ; Retrieve low digit |
|||
rar ; Rotate low bit into carry flag |
|||
mvi c,puts ; Prepare to print string |
|||
lxi d,odd ; If carry is set, then the number is odd |
|||
jc 5 ; So print 'odd' |
|||
lxi d,even ; Otherwise, the number is even |
|||
jmp 5 ; So print 'even' |
|||
even: db 'Even$' ; Strings |
|||
odd: db 'Odd$'</syntaxhighlight> |
|||
{{out}} |
|||
<pre>A>evenodd 0 |
|||
Even |
|||
A>evenodd 1 |
|||
Odd |
|||
A>evenodd 2 |
|||
Even |
|||
A>evenodd 3141592653 |
|||
Odd |
|||
A></pre> |
|||
=={{header|8086 Assembly}}== |
|||
===Non-Destructive=== |
|||
<syntaxhighlight lang="asm">test ax,1 |
|||
jne isOdd |
|||
;else, is even</syntaxhighlight> |
|||
===Destructive=== |
|||
<syntaxhighlight lang="asm">and ax,1 |
|||
jne isOdd |
|||
;else, is even</syntaxhighlight> |
|||
<syntaxhighlight lang="asm">ror ax,1 |
|||
jc isOdd |
|||
;else, is even</syntaxhighlight> |
|||
<syntaxhighlight lang="asm">rcr ax,1 |
|||
jc isOdd |
|||
;else, is even</syntaxhighlight> |
|||
<syntaxhighlight lang="asm">sar ax,1 |
|||
jc isOdd |
|||
;else, is even</syntaxhighlight> |
|||
<syntaxhighlight lang="asm">shr ax,1 |
|||
jc isOdd |
|||
;else, is even</syntaxhighlight> |
|||
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. |
|||
<syntaxhighlight lang="forth">: odd? \ n -- boolean |
|||
dup 1 n:band 1 n:= ; |
|||
: even? \ n -- boolean |
|||
odd? not ;</syntaxhighlight> |
|||
This could be shortened to: |
|||
<syntaxhighlight lang="forth"> |
|||
: even? \ n -- f |
|||
1 n:band not ; |
|||
: odd? \ n -- f |
|||
even? not ; |
|||
</syntaxhighlight> |
|||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
|||
<syntaxhighlight lang="aarch64 assembly"> |
|||
/* ARM assembly AARCH64 Raspberry PI 3B and android arm 64 bits*/ |
|||
/* program oddEven64.s */ |
|||
/*******************************************/ |
|||
/* Constantes file */ |
|||
/*******************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly*/ |
|||
.include "../includeConstantesARM64.inc" |
|||
/*********************************/ |
|||
/* Initialized data */ |
|||
/*********************************/ |
|||
.data |
|||
sMessResultOdd: .asciz " @ is odd (impair) \n" |
|||
sMessResultEven: .asciz " @ is even (pair) \n" |
|||
szCarriageReturn: .asciz "\n" |
|||
/*********************************/ |
|||
/* UnInitialized data */ |
|||
/*********************************/ |
|||
.bss |
|||
sZoneConv: .skip 24 |
|||
/*********************************/ |
|||
/* code section */ |
|||
/*********************************/ |
|||
.text |
|||
.global main |
|||
main: //entry of program |
|||
mov x0,#5 |
|||
bl testOddEven |
|||
mov x0,#12 |
|||
bl testOddEven |
|||
mov x0,#2021 |
|||
bl testOddEven |
|||
100: //standard end of the program |
|||
mov x0, #0 //return code |
|||
mov x8, #EXIT //request to exit program |
|||
svc #0 //perform the system call |
|||
qAdrszCarriageReturn: .quad szCarriageReturn |
|||
qAdrsMessResultOdd: .quad sMessResultOdd |
|||
qAdrsMessResultEven: .quad sMessResultEven |
|||
qAdrsZoneConv: .quad sZoneConv |
|||
/***************************************************/ |
|||
/* test if number is odd or even */ |
|||
/***************************************************/ |
|||
// x0 contains à number |
|||
testOddEven: |
|||
stp x1,lr,[sp,-16]! // save registres |
|||
tst x0,#1 //test bit 0 to one |
|||
beq 1f //if result are all zéro, go to even |
|||
ldr x1,qAdrsZoneConv //else display odd message |
|||
bl conversion10 //call decimal conversion |
|||
ldr x0,qAdrsMessResultOdd |
|||
ldr x1,qAdrsZoneConv //insert value conversion in message |
|||
bl strInsertAtCharInc |
|||
bl affichageMess |
|||
b 100f |
|||
1: |
|||
ldr x1,qAdrsZoneConv |
|||
bl conversion10 //call decimal conversion |
|||
ldr x0,qAdrsMessResultEven |
|||
ldr x1,qAdrsZoneConv //insert conversion in message |
|||
bl strInsertAtCharInc |
|||
bl affichageMess |
|||
100: |
|||
ldp x1,lr,[sp],16 // restaur des 2 registres |
|||
ret |
|||
/********************************************************/ |
|||
/* File Include fonctions */ |
|||
/********************************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly */ |
|||
.include "../includeARM64.inc" |
|||
</syntaxhighlight> |
|||
{{output}} |
|||
<pre> |
|||
5 is odd (impair) |
|||
12 is even (pair) |
|||
2021 is odd (impair) |
|||
</pre> |
|||
=={{header|ABAP}}== |
|||
<syntaxhighlight 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| |
|||
) |
|||
) |
|||
) |
|||
). |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
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 |
|||
</pre> |
|||
=={{header|Action!}}== |
|||
<syntaxhighlight lang="action!">PROC OddByAnd(INT v) |
|||
IF (v&1)=0 THEN |
|||
Print(" even") |
|||
ELSE |
|||
Print(" odd ") |
|||
FI |
|||
RETURN |
|||
PROC OddByMod(INT v) |
|||
;MOD doesn't work properly for negative numbers in Action! |
|||
IF v<0 THEN |
|||
v=-v |
|||
FI |
|||
IF v MOD 2=0 THEN |
|||
Print(" even") |
|||
ELSE |
|||
Print(" odd ") |
|||
FI |
|||
RETURN |
|||
PROC OddByDiv(INT v) |
|||
INT d |
|||
d=(v/2)*2 |
|||
IF v=d THEN |
|||
Print(" even") |
|||
ELSE |
|||
Print(" odd ") |
|||
FI |
|||
RETURN |
|||
PROC Main() |
|||
INT i |
|||
FOR i=-4 TO 4 |
|||
DO |
|||
PrintF("%I is",i) |
|||
OddByAnd(i) |
|||
OddByMod(i) |
|||
OddByDiv(i) |
|||
PutE() |
|||
OD |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Even_or_odd.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
-4 is even even even |
|||
-3 is odd odd odd |
|||
-2 is even even even |
|||
-1 is odd odd odd |
|||
0 is even even even |
|||
1 is odd odd odd |
|||
2 is even even even |
|||
3 is odd odd odd |
|||
4 is even even even |
|||
</pre> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada">-- Ada has bitwise operators in package Interfaces, |
||
-- but they work with Interfaces.Unsigned_*** types only. |
-- but they work with Interfaces.Unsigned_*** types only. |
||
-- Use rem or mod for Integer types, and let the compiler |
-- Use rem or mod for Integer types, and let the compiler |
||
Line 34: | Line 379: | ||
Put_Line ("Something went really wrong!"); |
Put_Line ("Something went really wrong!"); |
||
end if; |
end if; |
||
end;</ |
end;</syntaxhighlight> |
||
=={{header|Agda}}== |
|||
<syntaxhighlight lang="agda"> |
|||
module EvenOrOdd where |
|||
open import Data.Bool using (Bool; false; true) |
|||
open import Data.Nat using (ℕ; zero; suc) |
|||
even : ℕ → Bool |
|||
odd : ℕ → Bool |
|||
even zero = true |
|||
even (suc n) = odd n |
|||
odd zero = false |
|||
odd (suc n) = even n |
|||
</syntaxhighlight> |
|||
=={{header|Aime}}== |
|||
<syntaxhighlight lang="aime">if (x & 1) { |
|||
# x is odd |
|||
} else { |
|||
# x is even |
|||
}</syntaxhighlight> |
|||
=={{header|ALGOL 68}}== |
|||
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}} |
|||
<syntaxhighlight 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 ) ) |
|||
</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="algol"> |
|||
BEGIN |
|||
% RETURN 1 IF EVEN, OTHERWISE 0 % |
|||
INTEGER FUNCTION EVEN(I); |
|||
INTEGER I; |
|||
BEGIN |
|||
EVEN := 1 - (I - 2 * (I / 2)); |
|||
END; |
|||
% TEST THE ROUTINE % |
|||
INTEGER K; |
|||
FOR K := 1 STEP 3 UNTIL 10 DO |
|||
WRITE(K," IS ", IF EVEN(K) = 1 THEN "EVEN" ELSE "ODD"); |
|||
END</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 IS ODD |
|||
4 IS EVEN |
|||
7 IS ODD |
|||
10 IS EVEN</pre> |
|||
An alternate (but mathematically equivalent) coding, demonstrating the use of a conditional test as part of an assignment statement: |
|||
<syntaxhighlight lang="algol"> |
|||
% RETURN 1 IF EVEN, OTHERWISE 0 % |
|||
INTEGER FUNCTION EVEN(I); |
|||
INTEGER I; |
|||
BEGIN |
|||
EVEN := (IF I = 2 * (I / 2) THEN 1 ELSE 0); |
|||
END; |
|||
</syntaxhighlight> |
|||
=={{header|ALGOL W}}== |
|||
<syntaxhighlight 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.</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 is odd |
|||
1702 is even |
|||
23 is odd |
|||
-26 is even |
|||
</pre> |
|||
=={{header|AntLang}}== |
|||
<syntaxhighlight lang="antlang">odd: {x mod 2} |
|||
even: {1 - x mod 2}</syntaxhighlight> |
|||
=={{header|APL}}== |
|||
The easiest way is probably to use modulo. |
|||
<syntaxhighlight lang="apl"> 2|28 |
|||
0 |
|||
2|37 |
|||
1</syntaxhighlight> |
|||
So you can write a user-defined operator. |
|||
odd ← 2∘| |
|||
=={{header|AppleScript}}== |
|||
<syntaxhighlight lang="applescript">set L to {3, 2, 1, 0, -1, -2, -3} |
|||
set evens to {} |
|||
set odds to {} |
|||
repeat with x in L |
|||
if (x mod 2 = 0) then |
|||
set the end of evens to x's contents |
|||
else |
|||
set the end of odds to x's contents |
|||
end if |
|||
end repeat |
|||
return {even:evens, odd:odds}</syntaxhighlight> |
|||
{{out}} |
|||
<syntaxhighlight lang="applescript">{even:{2, 0, -2}, odd:{3, 1, -1, -3}}</syntaxhighlight> |
|||
Or, packaging reusable functions that can serve as arguments to '''filter''', '''partition''' etc |
|||
(deriving '''even''' from mod, and '''odd''' from even): |
|||
<syntaxhighlight lang="applescript">----------------------- EVEN OR ODD ------------------------ |
|||
-- even :: Int -> Bool |
|||
on even(n) |
|||
0 = n mod 2 |
|||
end even |
|||
-- odd :: Int -> Bool |
|||
on odd(n) |
|||
not even(n) |
|||
end odd |
|||
--------------------------- TEST --------------------------- |
|||
on run |
|||
partition(odd, enumFromTo(-6, 6)) |
|||
--> {{-5, -3, -1, 1, 3, 5}, {-6, -4, -2, 0, 2, 4, 6}} |
|||
end run |
|||
-------------------- GENERICS FOR TEST --------------------- |
|||
-- enumFromTo :: Int -> Int -> [Int] |
|||
on enumFromTo(m, n) |
|||
if m ≤ n then |
|||
set lst to {} |
|||
repeat with i from m to n |
|||
set end of lst to i |
|||
end repeat |
|||
lst |
|||
else |
|||
{} |
|||
end if |
|||
end enumFromTo |
|||
-- partition :: (a -> Bool) -> [a] -> ([a], [a]) |
|||
on partition(p, xs) |
|||
tell mReturn(p) |
|||
set {ys, zs} to {{}, {}} |
|||
repeat with x in xs |
|||
set v to contents of x |
|||
if |λ|(v) then |
|||
set end of ys to v |
|||
else |
|||
set end of zs to v |
|||
end if |
|||
end repeat |
|||
end tell |
|||
{ys, zs} |
|||
end partition |
|||
-- mReturn :: First-class m => (a -> b) -> m (a -> b) |
|||
on mReturn(f) |
|||
-- 2nd class handler function lifted into 1st class script wrapper. |
|||
if script is class of f then |
|||
f |
|||
else |
|||
script |
|||
property |λ| : f |
|||
end script |
|||
end if |
|||
end mReturn</syntaxhighlight> |
|||
{{Out}} |
|||
<syntaxhighlight lang="applescript">{{-5, -3, -1, 1, 3, 5}, {-6, -4, -2, 0, 2, 4, 6}}</syntaxhighlight> |
|||
=={{header|Arendelle}}== |
|||
<pre>( input , "Please enter a number: " ) |
|||
{ @input % 2 = 0 , |
|||
"| @input | is even!" |
|||
, |
|||
"| @input | is odd!" |
|||
}</pre> |
|||
=={{header|ARM Assembly}}== |
|||
{{works with|as|Raspberry Pi}} |
|||
<syntaxhighlight lang="arm assembly"> |
|||
/* ARM assembly Raspberry PI or android 32 bits */ |
|||
/* program oddEven.s */ |
|||
/* REMARK 1 : this program use routines in a include file |
|||
see task Include a file language arm assembly |
|||
for the routine affichageMess conversion10 |
|||
see at end of this program the instruction include */ |
|||
/* for constantes see task include a file in arm assembly */ |
|||
/************************************/ |
|||
/* Constantes */ |
|||
/************************************/ |
|||
.include "../constantes.inc" |
|||
/*********************************/ |
|||
/* Initialized data */ |
|||
/*********************************/ |
|||
.data |
|||
sMessResultOdd: .asciz " @ is odd (impair) \n" |
|||
sMessResultEven: .asciz " @ is even (pair) \n" |
|||
szCarriageReturn: .asciz "\n" |
|||
/*********************************/ |
|||
/* UnInitialized data */ |
|||
/*********************************/ |
|||
.bss |
|||
sZoneConv: .skip 24 |
|||
/*********************************/ |
|||
/* code section */ |
|||
/*********************************/ |
|||
.text |
|||
.global main |
|||
main: @ entry of program |
|||
mov r0,#5 |
|||
bl testOddEven |
|||
mov r0,#12 |
|||
bl testOddEven |
|||
mov r0,#2021 |
|||
bl testOddEven |
|||
100: @ standard end of the program |
|||
mov r0, #0 @ return code |
|||
mov r7, #EXIT @ request to exit program |
|||
svc #0 @ perform the system call |
|||
iAdrszCarriageReturn: .int szCarriageReturn |
|||
iAdrsMessResultOdd: .int sMessResultOdd |
|||
iAdrsMessResultEven: .int sMessResultEven |
|||
iAdrsZoneConv: .int sZoneConv |
|||
/***************************************************/ |
|||
/* test if number is odd or even */ |
|||
/***************************************************/ |
|||
// r0 contains à number |
|||
testOddEven: |
|||
push {r2-r8,lr} @ save registers |
|||
tst r0,#1 @ test bit 0 to one |
|||
beq 1f @ if result are all zéro, go to even |
|||
ldr r1,iAdrsZoneConv @ else display odd message |
|||
bl conversion10 @ call decimal conversion |
|||
ldr r0,iAdrsMessResultOdd |
|||
ldr r1,iAdrsZoneConv @ insert value conversion in message |
|||
bl strInsertAtCharInc |
|||
bl affichageMess |
|||
b 100f |
|||
1: |
|||
ldr r1,iAdrsZoneConv |
|||
bl conversion10 @ call decimal conversion |
|||
ldr r0,iAdrsMessResultEven |
|||
ldr r1,iAdrsZoneConv @ insert conversion in message |
|||
bl strInsertAtCharInc |
|||
bl affichageMess |
|||
100: |
|||
pop {r2-r8,lr} @ restaur registers |
|||
bx lr @ return |
|||
/***************************************************/ |
|||
/* ROUTINES INCLUDE */ |
|||
/***************************************************/ |
|||
.include "../affichage.inc" |
|||
</syntaxhighlight> |
|||
=={{header|ArnoldC}}== |
|||
<syntaxhighlight lang="arnoldc">LISTEN TO ME VERY CAREFULLY isOdd |
|||
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n |
|||
GIVE THESE PEOPLE AIR |
|||
HEY CHRISTMAS TREE result |
|||
YOU SET US UP @I LIED |
|||
GET TO THE CHOPPER result |
|||
HERE IS MY INVITATION n |
|||
I LET HIM GO 2 |
|||
ENOUGH TALK |
|||
I'LL BE BACK result |
|||
HASTA LA VISTA, BABY |
|||
LISTEN TO ME VERY CAREFULLY showParity |
|||
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n |
|||
TALK TO THE HAND n |
|||
HEY CHRISTMAS TREE parity |
|||
YOU SET US UP @I LIED |
|||
GET YOUR A** TO MARS parity |
|||
DO IT NOW isOdd n |
|||
BECAUSE I'M GOING TO SAY PLEASE parity |
|||
TALK TO THE HAND "odd" |
|||
BULLS*** |
|||
TALK TO THE HAND "even" |
|||
YOU HAVE NO RESPECT FOR LOGIC |
|||
TALK TO THE HAND "" |
|||
HASTA LA VISTA, BABY |
|||
IT'S SHOWTIME |
|||
DO IT NOW showParity 5 |
|||
DO IT NOW showParity 6 |
|||
DO IT NOW showParity -11 |
|||
YOU HAVE BEEN TERMINATED</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
5 |
|||
odd |
|||
6 |
|||
even |
|||
-11 |
|||
odd |
|||
</pre> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">loop (neg 5)..5 [x][ |
|||
if? even? x -> print [pad to :string x 4 ": even"] |
|||
else -> print [pad to :string x 4 ": odd"] |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> -5 : odd |
|||
-4 : even |
|||
-3 : odd |
|||
-2 : even |
|||
-1 : odd |
|||
0 : even |
|||
1 : odd |
|||
2 : even |
|||
3 : odd |
|||
4 : even |
|||
5 : odd</pre> |
|||
=={{header|Asymptote}}== |
|||
<syntaxhighlight lang="asymptote">for (int i = 1; i <= 10; ++i) { |
|||
if (i % 2 == 0) { |
|||
write(string(i), " is even"); |
|||
} else { |
|||
write(string(i), " is odd"); |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|AutoHotkey}}== |
|||
Bitwise ops are probably most efficient: |
|||
<syntaxhighlight lang="ahk">if ( int & 1 ){ |
|||
; do odd stuff |
|||
}else{ |
|||
; do even stuff |
|||
}</syntaxhighlight> |
|||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
< |
<syntaxhighlight lang="awk">function isodd(x) { |
||
return |
return x % 2 != 0 |
||
} |
} |
||
function iseven(x) { |
function iseven(x) { |
||
return |
return x % 2 == 0 |
||
}</ |
}</syntaxhighlight> |
||
=={{header|BASIC}}== |
|||
==={{header|Applesoft BASIC}}=== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
{{works with|Commodore BASIC|2.0}} |
|||
==={{header|BaCon}}=== |
|||
<syntaxhighlight lang="freebasic">' Even or odd |
|||
OPTION MEMTYPE int |
|||
SPLIT ARGUMENT$ BY " " TO arg$ SIZE dim |
|||
n = IIF$(dim < 2, 0, VAL(arg$[1])) |
|||
PRINT n, " is ", IIF$(EVEN(n), "even", "odd")</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ ./even-or-odd 42 |
|||
42 is even |
|||
prompt$ ./even-or-odd 41 |
|||
41 is odd</pre> |
|||
==={{header|BASIC256}}=== |
|||
{{works with|True BASIC}} |
|||
<syntaxhighlight lang="basic256">for i = 1 to 10 |
|||
if (i mod 2) then print i;" is odd" else print i;" is even" |
|||
next i |
|||
end</syntaxhighlight> |
|||
=={{header|BBC BASIC}}== |
==={{header|BBC BASIC}}=== |
||
{{works with|BBC BASIC for Windows}} |
{{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. |
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. |
||
<syntaxhighlight lang="bbcbasic"> IF FNisodd%(14) PRINT "14 is odd" ELSE PRINT "14 is even" |
|||
<lang bbcbasic>=={{header|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%(15) PRINT "15 is odd" ELSE PRINT "15 is even" |
||
IF FNisodd#(9876543210#) PRINT "9876543210 is odd" ELSE PRINT "9876543210 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" |
IF FNisodd#(9876543211#) PRINT "9876543211 is odd" ELSE PRINT "9876543211 is even" |
||
END |
END |
||
REM Works for -2^31 <= n% < 2^31 |
REM Works for -2^31 <= n% < 2^31 |
||
DEF FNisodd%(n%) = (n% AND 1) <> 0 |
DEF FNisodd%(n%) = (n% AND 1) <> 0 |
||
REM Works for -2^53 <= n# <= 2^53 |
REM Works for -2^53 <= n# <= 2^53 |
||
DEF FNisodd#(n#) = n# <> 2 * INT(n# / 2)</ |
DEF FNisodd#(n#) = n# <> 2 * INT(n# / 2)</syntaxhighlight> |
||
{{out}} |
|||
'''Output:''' |
|||
<pre> |
<pre> |
||
14 is even |
14 is even |
||
Line 68: | Line 806: | ||
9876543211 is odd |
9876543211 is odd |
||
</pre> |
</pre> |
||
==={{header|Chipmunk Basic}}=== |
|||
{{works with|Chipmunk Basic|3.6.4}} |
|||
Uses bitwise AND as suggested. |
|||
<syntaxhighlight lang="qbasic">10 cls |
|||
20 for n = 1 to 10 |
|||
30 print n; |
|||
40 if (n and 1) = 1 then print "is odd" else print "is even" |
|||
50 next n |
|||
60 end</syntaxhighlight> |
|||
==={{header|Commodore BASIC}}=== |
|||
Uses bitwise AND as suggested. |
|||
<syntaxhighlight lang="gwbasic">10 rem determine if integer is even or odd |
|||
20 print "Enter an integer:"; |
|||
30 input i% |
|||
35 print |
|||
40 eo$="even" |
|||
50 if (i% and 1)=1 then eo$="odd" |
|||
60 print "The number ";i%;"is ";eo$;"."</syntaxhighlight> |
|||
==={{header|FreeBASIC}}=== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
==={{header|Gambas}}=== |
|||
<syntaxhighlight lang="gambas">Public Sub Form_Open() |
|||
Dim sAnswer, sMessage As String |
|||
sAnswer = InputBox("Input an integer", "Odd or even") |
|||
If IsInteger(sAnswer) Then |
|||
If Odd(Val(sAnswer)) Then sMessage = "' is an odd number" |
|||
If Even(Val(sAnswer)) Then sMessage = "' is an even number" |
|||
Else |
|||
sMessage = "' does not compute!!" |
|||
Endif |
|||
Print "'" & sAnswer & sMessage |
|||
End</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
'25' is an odd number |
|||
'100' is an even number |
|||
'Fred' does not compute!! |
|||
</pre> |
|||
==={{header|GW-BASIC}}=== |
|||
<syntaxhighlight lang="gwbasic"> |
|||
10 INPUT "Enter a number: ", N |
|||
20 IF N MOD 2 = 1 THEN PRINT "It is odd." ELSE PRINT "It is even."</syntaxhighlight> |
|||
==={{header|IS-BASIC}}=== |
|||
<syntaxhighlight lang="is-basic">100 DEF ODD(X)=MOD(X,2) |
|||
110 INPUT PROMPT "Enter a number: ":X |
|||
120 IF ODD(X) THEN |
|||
130 PRINT X;"is odd." |
|||
140 ELSE |
|||
150 PRINT X;"is even." |
|||
160 END IF</syntaxhighlight> |
|||
==={{header|Liberty BASIC}}=== |
|||
{{works with|Just BASIC}} |
|||
<syntaxhighlight lang="lb">n=12 |
|||
if n mod 2 = 0 then print "even" else print "odd"</syntaxhighlight> |
|||
==={{header|Minimal BASIC}}=== |
|||
{{works with|IS-BASIC}} |
|||
<syntaxhighlight lang="gwbasic">10 REM Even or odd |
|||
20 PRINT "Enter an integer number"; |
|||
30 INPUT N |
|||
40 IF N/2 <> INT(N/2) THEN 70 |
|||
50 PRINT "The number is even." |
|||
60 GOTO 80 |
|||
70 PRINT "The number is odd." |
|||
80 END</syntaxhighlight> |
|||
==={{header|MSX Basic}}=== |
|||
Uses bitwise AND as suggested. |
|||
<syntaxhighlight lang="qbasic">10 CLS |
|||
20 FOR N = -5 TO 5 |
|||
30 PRINT N; |
|||
40 IF (N AND 1) = 1 THEN PRINT "is odd" ELSE PRINT "is even" |
|||
50 NEXT N |
|||
60 END</syntaxhighlight> |
|||
==={{header|PureBasic}}=== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
==={{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. |
|||
<syntaxhighlight lang="qb64">'This is a comment line. It also could have been preceded with "Rem" |
|||
Dim i% 'This line is not necessary, but % strict casts |
|||
'as an Int (2 bytes). "As Int" could have been used instead. |
|||
Input "#? ", i% 'Prints "#? " as a prompt and waits |
|||
'for user input terminated by pressing [ENTER]. |
|||
'Binary integers example |
|||
If i% And 1 Then 'Test whether the input value AND 1 is 0 (false) or 1 (true). |
|||
'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)" |
|||
Print "Even" 'Prints "Even in all other cases (Else) |
|||
'or if the logical inverse of the input value AND 1 tested |
|||
'"true" (ElseIf). |
|||
End If |
|||
'Modular congruence example |
|||
If i% Mod 2 Then |
|||
Print "Still Odd" |
|||
Else |
|||
Print "Still Even" |
|||
End If</syntaxhighlight> |
|||
==={{header|QBasic}}=== |
|||
{{works with|QBasic|1.1}} |
|||
{{works with|QuickBasic|4.5}} |
|||
{{works with|Run BASIC}} |
|||
<syntaxhighlight lang="qbasic">FOR i = 1 TO 10 |
|||
IF i AND 1 THEN PRINT i; " is odd" ELSE PRINT i; " is even" |
|||
NEXT i</syntaxhighlight> |
|||
==={{header|Quite BASIC}}=== |
|||
<syntaxhighlight lang="qbasic">10 CLS |
|||
20 FOR n = -5 TO 5 |
|||
30 PRINT n; |
|||
40 IF n % 2 <> 0 THEN PRINT " is odd" ELSE PRINT " is even" |
|||
50 NEXT n |
|||
60 END</syntaxhighlight> |
|||
==={{header|Run BASIC}}=== |
|||
{{works with|QBasic}} |
|||
<syntaxhighlight lang="runbasic">for i = 1 to 10 |
|||
if i and 1 then print i;" is odd" else print i;" is even" |
|||
next i</syntaxhighlight> |
|||
<pre>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</pre> |
|||
==={{header|S-BASIC}}=== |
|||
S-BASIC lacks a MOD operator but supports bitwise operations on integer variables, so that is the approach taken. |
|||
<syntaxhighlight lang="basic"> |
|||
rem - return true (-1) if even, otherwise false (0) |
|||
function even(i = integer) = integer |
|||
var one = integer rem - both operands must be variables |
|||
one = 1 |
|||
end = ((i and one) = 0) |
|||
rem - exercise the function |
|||
var i = integer |
|||
for i = 1 to 10 step 3 |
|||
print i; " is "; |
|||
if even(i) then |
|||
print "even" |
|||
else |
|||
print "odd" |
|||
next |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre> 1 is odd |
|||
4 is even |
|||
7 is odd |
|||
10 is even</pre> |
|||
==={{header|SmallBASIC}}=== |
|||
<syntaxhighlight lang="qbasic"> |
|||
FOR i = 1 to 10 |
|||
IF(i % 2 == 0) |
|||
PRINT i; " is even" |
|||
ELSE |
|||
PRINT i; " is odd" |
|||
ENDIF |
|||
NEXT |
|||
</syntaxhighlight> |
|||
==={{header|TI-83 BASIC}}=== |
|||
TI-83 BASIC does not have a modulus operator. |
|||
<syntaxhighlight lang="ti83b">If fPart(.5Ans |
|||
Then |
|||
Disp "ODD |
|||
Else |
|||
Disp "EVEN |
|||
End</syntaxhighlight> |
|||
==={{header|Tiny BASIC}}=== |
|||
{{works with|TinyBasic}} |
|||
<syntaxhighlight lang="basic">10 PRINT "Enter a number:" |
|||
20 INPUT N |
|||
30 IF 2*(N/2) = N THEN GOTO 60 |
|||
40 PRINT "It's odd." |
|||
50 END |
|||
60 PRINT "It's even." |
|||
70 END</syntaxhighlight> |
|||
==={{header|True BASIC}}=== |
|||
{{works with|BASIC256}} |
|||
<syntaxhighlight lang="qbasic">FOR i = 1 to 10 |
|||
IF MOD(i, 2) = 0 THEN PRINT i; " is odd" ELSE PRINT i; " is even" |
|||
NEXT i |
|||
END</syntaxhighlight> |
|||
==={{header|VBA}}=== |
|||
<pre>4 ways = 4 Functions : |
|||
IsEven ==> Use the even and odd predicates |
|||
IsEven2 ==> Check the least significant digit. With binary integers, i bitwise-and 1 equals 0 iff i is even |
|||
IsEven3 ==> Divide i by 2. The remainder equals 0 if i is even. |
|||
IsEven4 ==> Use modular congruences</pre> |
|||
<syntaxhighlight lang="vb">Option Explicit |
|||
Sub Main_Even_Odd() |
|||
Dim i As Long |
|||
For i = -50 To 48 Step 7 |
|||
Debug.Print i & " : IsEven ==> " & IIf(IsEven(i), "is even", "is odd") _ |
|||
& " " & Chr(124) & " IsEven2 ==> " & IIf(IsEven2(i), "is even", "is odd") _ |
|||
& " " & Chr(124) & " IsEven3 ==> " & IIf(IsEven3(i), "is even", "is odd") _ |
|||
& " " & Chr(124) & " IsEven4 ==> " & IIf(IsEven4(i), "is even", "is odd") |
|||
Next |
|||
End Sub |
|||
Function IsEven(Number As Long) As Boolean |
|||
'Use the even and odd predicates |
|||
IsEven = (WorksheetFunction.Even(Number) = Number) |
|||
End Function |
|||
Function IsEven2(Number As Long) As Boolean |
|||
'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. |
|||
Dim lngTemp As Long |
|||
lngTemp = CLng(Right(CStr(Number), 1)) |
|||
If (lngTemp And 1) = 0 Then IsEven2 = True |
|||
End Function |
|||
Function IsEven3(Number As Long) As Boolean |
|||
'Divide i by 2. |
|||
'The remainder equals 0 if i is even. |
|||
Dim sngTemp As Single |
|||
sngTemp = Number / 2 |
|||
IsEven3 = ((Int(sngTemp) - sngTemp) = 0) |
|||
End Function |
|||
Function IsEven4(Number As Long) As Boolean |
|||
'Use modular congruences |
|||
IsEven4 = (Number Mod 2 = 0) |
|||
End Function</syntaxhighlight> |
|||
{{out}} |
|||
<pre>-50 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even |
|||
-43 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd |
|||
-36 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even |
|||
-29 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd |
|||
-22 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even |
|||
-15 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd |
|||
-8 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even |
|||
-1 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd |
|||
6 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even |
|||
13 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd |
|||
20 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even |
|||
27 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd |
|||
34 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even |
|||
41 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd |
|||
48 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even</pre> |
|||
==={{header|VBScript}}=== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>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</pre> |
|||
==={{header|Visual Basic .NET}}=== |
|||
{{trans|FreeBASIC}} |
|||
<syntaxhighlight lang="vbnet">Module Module1 |
|||
Sub Main() |
|||
Dim str As String |
|||
Dim num As Integer |
|||
While True |
|||
Console.Write("Enter an integer or 0 to finish: ") |
|||
str = Console.ReadLine() |
|||
If Integer.TryParse(str, num) Then |
|||
If num = 0 Then |
|||
Exit While |
|||
End If |
|||
If num Mod 2 = 0 Then |
|||
Console.WriteLine("Even") |
|||
Else |
|||
Console.WriteLine("Odd") |
|||
End If |
|||
Else |
|||
Console.WriteLine("Bad input.") |
|||
End If |
|||
End While |
|||
End Sub |
|||
End Module</syntaxhighlight> |
|||
==== BigInteger ==== |
|||
{{Libheader|System.Numerics}} |
|||
<syntaxhighlight lang="vbnet">Imports System.Numerics |
|||
Module Module1 |
|||
Function IsOdd(bi As BigInteger) As Boolean |
|||
Return Not bi.IsEven |
|||
End Function |
|||
Function IsEven(bi As BigInteger) As Boolean |
|||
Return bi.IsEven |
|||
End Function |
|||
Sub Main() |
|||
' uncomment one of the following Dim statements |
|||
' Dim x As Byte = 3 |
|||
' Dim x As Short = 3 |
|||
' Dim x As Integer = 3 |
|||
' Dim x As Long = 3 |
|||
' Dim x As SByte = 3 |
|||
' Dim x As UShort = 3 |
|||
' Dim x As UInteger = 3 |
|||
' Dim x As ULong = 3 |
|||
' Dim x as BigInteger = 3 |
|||
' the following three types give a warning, but will work |
|||
' Dim x As Single = 3 |
|||
' Dim x As Double = 3 |
|||
' Dim x As Decimal = 3 |
|||
Console.WriteLine("{0} {1}", IsOdd(x), IsEven(x)) |
|||
End Sub |
|||
End Module</syntaxhighlight> |
|||
==={{header|XBasic}}=== |
|||
{{works with|Windows XBasic}} |
|||
<syntaxhighlight lang="xbasic">PROGRAM "Even/Odd" |
|||
DECLARE FUNCTION Entry () |
|||
FUNCTION Entry () |
|||
FOR i = 1 TO 10 |
|||
IF (i MOD 2) THEN PRINT i;" is odd" ELSE PRINT i;" is even" |
|||
NEXT i |
|||
END FUNCTION |
|||
END PROGRAM</syntaxhighlight> |
|||
==={{header|Yabasic}}=== |
|||
{{trans|Phix}} |
|||
<syntaxhighlight lang="yabasic">for i = -5 to 5 |
|||
print i, and(i,1), mod(i,2) |
|||
next |
|||
</syntaxhighlight> |
|||
==={{header|ZX Spectrum Basic}}=== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Batch File}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|bc}}== |
=={{header|bc}}== |
||
There are no bitwise operations, so this solution compares a remainder with zero. Calculation of ''i % 2'' only works when ''scale = 0''. |
There are no bitwise operations, so this solution compares a remainder with zero. Calculation of ''i % 2'' only works when ''scale = 0''. |
||
< |
<syntaxhighlight lang="bc">i = -3 |
||
/* Assumes that i is an integer. */ |
/* Assumes that i is an integer. */ |
||
Line 78: | Line 1,243: | ||
" |
" |
||
if (i % 2) "i is odd |
if (i % 2) "i is odd |
||
"</ |
"</syntaxhighlight> |
||
=={{header|Beads}}== |
|||
<syntaxhighlight lang="beads">beads 1 program 'Even or odd' |
|||
calc main_init |
|||
loop across:[-10, -5, 10, 5] val:v |
|||
log "{v}\todd:{is_odd(v)}\teven:{is_even(v)}"</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
-10 odd:N even:Y |
|||
-5 odd:Y even:N |
|||
10 odd:N even:Y |
|||
5 odd:Y even:N |
|||
</pre> |
|||
=={{header|Befunge}}== |
|||
<syntaxhighlight lang="befunge">&2%52**"E"+,@</syntaxhighlight> |
|||
Outputs E if even, O if odd. |
|||
=={{header|Binary Lambda Calculus}}== |
|||
In lambda calculus, the oddness of a given church numeral n can be computed as n applications of <code>not</code> to <code>false</code>: <code>\n. n (\b\x\y. b y x) (\x\y.y)</code>, which in BLC is |
|||
<pre>00 01 01 10 0000000101111010110 000010</pre> |
|||
To compute the evenness, one need only replace <code>false</code> by <code>true</code>, i.e. replace the final 0 bit by 10. |
|||
=={{header|BQN}}== |
|||
<syntaxhighlight lang="bqn"> |
|||
odd ← 2⊸| |
|||
!0 ≡ odd 12 |
|||
!1 ≡ odd 31</syntaxhighlight> |
|||
=={{header|Bracmat}}== |
=={{header|Bracmat}}== |
||
Not the simplest solution, but the cheapest if the number that must be tested has thousands of digits. |
Not the simplest solution, but the cheapest if the number that must be tested has thousands of digits. |
||
< |
<syntaxhighlight lang="bracmat">( ( even |
||
= |
= |
||
. @( !arg |
. @( !arg |
||
Line 110: | Line 1,309: | ||
& eventest$857234098750432987502398457089435 |
& eventest$857234098750432987502398457089435 |
||
& oddtest$857234098750432987502398457089435 |
& oddtest$857234098750432987502398457089435 |
||
)</ |
)</syntaxhighlight> |
||
{{out}} |
|||
Output: |
|||
<pre>5556 is even |
<pre>5556 is even |
||
5556 is not odd |
5556 is not odd |
||
857234098750432987502398457089435 is not even |
857234098750432987502398457089435 is not even |
||
857234098750432987502398457089435 is odd</pre> |
857234098750432987502398457089435 is odd</pre> |
||
=={{header|Brainf***}}== |
=={{header|Brainf***}}== |
||
Assumes that input characters are an ASCII representation of a valid integer. |
Assumes that input characters are an ASCII representation of a valid integer. |
||
Output is input <tt>mod</tt> 2. |
|||
<lang bf>+ |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
+++++ |
|||
[<<--[>+<[-]]>>-] |
|||
If one need only determine rather than act on the parity of the input, |
|||
<----->+< |
|||
the following is sufficient; it terminates either quickly or never. |
|||
[> |
|||
<syntaxhighlight lang="bf">,[>,----------]<[--]</syntaxhighlight> |
|||
++++++++++ |
|||
++++++++++ |
|||
=={{header|Burlesque}}== |
|||
++++++++++ |
|||
<syntaxhighlight lang="burlesque">2.%</syntaxhighlight> |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++. |
|||
++++++++++ |
|||
++++++++++ |
|||
+..[-]<[-]]>[> |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++++ |
|||
+++++++++. |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++++ |
|||
++++++++++ |
|||
+++++++++. |
|||
---------- |
|||
-------. |
|||
+++++++++. |
|||
[-]]</lang> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
Test by bitwise and'ing 1, works for any builtin integer type as long as it's 2's |
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): |
||
< |
<syntaxhighlight lang="c">if (x & 1) { |
||
/* x is odd */ |
/* x is odd */ |
||
} else { |
} else { |
||
/* or not */ |
/* or not */ |
||
}</ |
}</syntaxhighlight> |
||
If using long integer type from GMP (<code>mpz_t</code>), there are provided macros: |
If using long integer type from GMP (<code>mpz_t</code>), there are provided macros: |
||
< |
<syntaxhighlight lang="c">mpz_t x; |
||
... |
... |
||
if (mpz_even_p(x)) { /* x is even */ } |
if (mpz_even_p(x)) { /* x is even */ } |
||
if (mpz_odd_p(x)) { /* x is odd */ }</ |
if (mpz_odd_p(x)) { /* x is odd */ }</syntaxhighlight> |
||
The macros evaluate <code>x</code> more than once, so it should not be something with side effects. |
The macros evaluate <code>x</code> more than once, so it should not be something with side effects. |
||
=={{header|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> |
|||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
< |
<syntaxhighlight lang="csharp">namespace RosettaCode |
||
{ |
{ |
||
using System; |
using System; |
||
Line 223: | Line 1,390: | ||
} |
} |
||
} |
} |
||
public class Program |
|||
}</lang> |
|||
{ |
|||
public static void Main() |
|||
{ |
|||
int num = 26; //Set this to any integer. |
|||
if (num.IsEvenBitwise()) //Replace this with any even function. |
|||
{ |
|||
Console.Write("Even"); |
|||
} |
|||
else |
|||
{ |
|||
Console.Write("Odd"); |
|||
} |
|||
//Prints "Even". |
|||
if (num.IsOddBitwise()) //Replace this with any odd function. |
|||
{ |
|||
Console.Write("Odd"); |
|||
} |
|||
else |
|||
{ |
|||
Console.Write("Even"); |
|||
} |
|||
//Prints "Even". |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|C++}}== |
|||
Test using the modulo operator, or use the C example from above. |
|||
<syntaxhighlight lang="cpp">bool isOdd(int x) |
|||
{ |
|||
return x % 2; |
|||
} |
|||
bool isEven(int x) |
|||
{ |
|||
return !(x % 2); |
|||
}</syntaxhighlight> |
|||
A slightly more type-generic version, for C++11 and later. This should theoretically work for any type convertible to <code>int</code>: |
|||
<syntaxhighlight 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); |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
Standard predicates: |
Standard predicates: |
||
< |
<syntaxhighlight lang="clojure">(if (even? some-var) (do-even-stuff)) |
||
(if (odd? some-var) (do-odd-stuff))</ |
(if (odd? some-var) (do-odd-stuff))</syntaxhighlight> |
||
=={{header|COBOL}}== |
|||
<syntaxhighlight lang="cobol"> IF FUNCTION REM(Num, 2) = 0 |
|||
DISPLAY Num " is even." |
|||
ELSE |
|||
DISPLAY Num " is odd." |
|||
END-IF</syntaxhighlight> |
|||
=={{header|CoffeeScript}}== |
|||
<syntaxhighlight lang="coffeescript">isEven = (x) -> !(x%2)</syntaxhighlight> |
|||
=={{header|ColdFusion}}== |
|||
<syntaxhighlight lang="cfm"> |
|||
function f(numeric n) { |
|||
return n mod 2?"odd":"even" |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
Standard predicates: |
Standard predicates: |
||
< |
<syntaxhighlight lang="lisp">(if (evenp some-var) (do-even-stuff)) |
||
(if (oddp some-other-var) (do-odd-stuff))</ |
(if (oddp some-other-var) (do-odd-stuff))</syntaxhighlight> |
||
===Alternate solution=== |
|||
I use [https://franz.com/downloads/clp/survey Allegro CL 10.1] |
|||
<syntaxhighlight lang="lisp"> |
|||
;; Project : Even or odd |
|||
(defun evenodd (nr) |
|||
(cond ((evenp nr) "even") |
|||
((oddp nr) "odd"))) |
|||
(dotimes (n 10) |
|||
(if (< n 1) (terpri)) |
|||
(if (< n 9) (format t "~a" " ")) |
|||
(write(+ n 1)) (format t "~a" ": ") |
|||
(format t "~a" (evenodd (+ n 1))) (terpri)) |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
1: odd |
|||
2: even |
|||
3: odd |
|||
4: even |
|||
5: odd |
|||
6: even |
|||
7: odd |
|||
8: even |
|||
9: odd |
|||
10: even |
|||
</pre> |
|||
=={{header|Component Pascal}}== |
|||
BlackBox Component Builder |
|||
<syntaxhighlight 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; |
|||
</syntaxhighlight> |
|||
Execute: ^Q EvenOdd.Do 10 11 0 57 34 -23 -42~<br/> |
|||
{{out}} |
|||
<pre> |
|||
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 |
|||
</pre> |
|||
=={{header|Crystal}}== |
|||
<syntaxhighlight 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) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>false |
|||
true |
|||
true |
|||
false |
|||
false |
|||
true |
|||
</pre> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
<syntaxhighlight lang="d">void main() { |
|||
<lang d>import std.stdio, std.bigint; |
|||
import std.stdio, std.bigint; |
|||
foreach (immutable i; -5 .. 6) |
|||
void main() { |
|||
writeln(i, " ", i & 1, " ", i % 2, " ", i.BigInt % 2); |
|||
foreach (i; -5 .. 6) |
|||
}</syntaxhighlight> |
|||
writeln(i, " ", i & 1, " ", i % 2, " ", BigInt(i) % 2); |
|||
}</lang> |
|||
{{out}} |
{{out}} |
||
<pre>-5 1 -1 -1 |
<pre>-5 1 -1 -1 |
||
Line 254: | Line 1,660: | ||
4 0 0 0 |
4 0 0 0 |
||
5 1 1 1</pre> |
5 1 1 1</pre> |
||
=={{header|Dart}}== |
|||
<syntaxhighlight lang="dart">void main() { |
|||
for (var i = 1; i <= 10; i++) { |
|||
if (i % 2 != 0) { |
|||
print("$i is odd"); |
|||
} else { |
|||
print("$i is even"); |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|dc}}== |
|||
This macro expects an integer on the stack, pops it, and pushes 1 if it is odd, or 0 if it is even (independently from the precision currently set). |
|||
<syntaxhighlight lang="dc">[K Sk 0 k 2 % Lk k]</syntaxhighlight> |
|||
=={{header|DCL}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
{{out}} |
|||
<pre>$ @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</pre> |
|||
=={{header|Delphi}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
program EvenOdd; |
|||
{$APPTYPE CONSOLE} |
|||
{$R *.res} |
|||
uses |
|||
System.SysUtils; |
|||
procedure IsOdd(aValue: Integer); |
|||
var |
|||
Odd: Boolean; |
|||
begin |
|||
Odd := aValue and 1 <> 0; |
|||
Write(Format('%d is ', [aValue])); |
|||
if Odd then |
|||
Writeln('odd') |
|||
else |
|||
Writeln('even'); |
|||
end; |
|||
var |
|||
i: Integer; |
|||
begin |
|||
for i := -5 to 10 do |
|||
IsOdd(i); |
|||
Readln; |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>-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 |
|||
7 is odd |
|||
8 is even |
|||
9 is odd |
|||
10 is even |
|||
</pre> |
|||
=={{header|Déjà Vu}}== |
|||
<syntaxhighlight lang="dejavu">even n: |
|||
= 0 % n 2 |
|||
odd: |
|||
not even |
|||
!. odd 0 |
|||
!. even 0 |
|||
!. odd 7 |
|||
!. even 7 |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>false |
|||
true |
|||
true |
|||
false</pre> |
|||
=={{header|Diego}}== |
|||
<syntaxhighlight lang="diego">use_namespace(rosettacode)_me(); |
|||
funct(isEven)_arg(i)_ret()_calc(i%2)_equals(0); |
|||
reset_namespace[];</syntaxhighlight> |
|||
=={{header|DWScript}}== |
=={{header|DWScript}}== |
||
Predicate: |
Predicate: |
||
< |
<syntaxhighlight lang="delphi">var isOdd := Odd(i);</syntaxhighlight> |
||
Bitwise and: |
Bitwise and: |
||
< |
<syntaxhighlight lang="delphi">var isOdd := (i and 1)<>0;</syntaxhighlight> |
||
Modulo: |
Modulo: |
||
< |
<syntaxhighlight lang="delphi">var isOdd := (i mod 2)=1;</syntaxhighlight> |
||
=={{header|EasyLang}}== |
|||
<syntaxhighlight lang="easylang"> |
|||
a = 13 |
|||
if a mod 2 = 0 |
|||
print a & " is even" |
|||
else |
|||
print a & " is odd" |
|||
. |
|||
</syntaxhighlight> |
|||
=={{header|Ed}}== |
|||
Checks the least significant digit of a line. |
|||
<syntaxhighlight lang="sed"> |
|||
H |
|||
g/(.*[13579])$/s//\1 is odd/ |
|||
v/odd/s/(.*)/\1 is even/ |
|||
,p |
|||
Q |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>$ cat even-odd.ed | ed -GlEs even-odd.input |
|||
Newline appended |
|||
1 is odd |
|||
3 is odd |
|||
5 is odd |
|||
9 is odd |
|||
23 is odd |
|||
9 is odd |
|||
0 is even |
|||
83 is odd |
|||
3 is odd |
|||
54 is even |
|||
6 is even |
|||
2 is even |
|||
7 is odd |
|||
433 is odd |
|||
78 is even</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). |
|||
<syntaxhighlight lang="edsac">[ Even or odd |
|||
=========== |
|||
A program for the EDSAC |
|||
Determines whether the number stored at |
|||
address 15@ is even or odd, and prints |
|||
'E' or 'O' accordingly |
|||
Works with Initial Orders 2 ] |
|||
T56K [ load point ] |
|||
GK [ base address ] |
|||
O11@ [ print letter shift ] |
|||
T10@ [ clear accumulator ] |
|||
H15@ [ multiplier := n ] |
|||
C12@ [ acc +:= mult AND 1 ] |
|||
S12@ [ acc -:= 1 ] |
|||
G8@ [ branch on negative ] |
|||
O14@ [ print 'O' ] |
|||
ZF [ halt ] |
|||
[ 8 ] O13@ [ print 'E' ] |
|||
ZF [ halt ] |
|||
[ 10 ] P0F [ used to clear acc ] |
|||
[ 11 ] *F [ letter shift character ] |
|||
[ 12 ] P0D [ const: 1 ] |
|||
[ 13 ] EF [ character 'E' ] |
|||
[ 14 ] OF [ character 'O' ] |
|||
[ 15 ] P18D [ number to test: 37 ] |
|||
EZPF [ branch to load point ]</syntaxhighlight> |
|||
{{out}} |
|||
<pre>O</pre> |
|||
=={{header|Eiffel}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Elixir}}== |
|||
<syntaxhighlight lang="elixir">defmodule RC do |
|||
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 |
|||
if 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)</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
-2 is even |
|||
-1 is odd |
|||
0 is even |
|||
1 is odd |
|||
2 is even |
|||
3 is odd |
|||
</pre> |
|||
Other ways to test even-ness: |
|||
<syntaxhighlight lang="elixir">rem(n,2) == 0</syntaxhighlight> |
|||
=={{header|Emacs Lisp}}== |
|||
<syntaxhighlight lang="lisp">(require 'cl-lib) |
|||
(defun even-or-odd-p (n) |
|||
(if (cl-evenp n) 'even 'odd)) |
|||
(defun even-or-odd-p (n) |
|||
(if (zerop (% n 2)) 'even 'odd)) |
|||
(message "%d is %s" 3 (even-or-oddp 3)) |
|||
(message "%d is %s" 2 (even-or-oddp 2))</syntaxhighlight> |
|||
{{out}} |
|||
3 is odd |
|||
2 is even |
|||
=={{header|EMal}}== |
|||
<syntaxhighlight lang="emal"> |
|||
List evenCheckers = fun[ |
|||
logic by int i do return i % 2 == 0 end, |
|||
logic by int i do return i & 1 == 0 end] |
|||
List oddCheckers = fun[ |
|||
logic by int i do return i % 2 != 0 end, |
|||
logic by int i do return i & 1 == 1 end] |
|||
writeLine("integer".padStart(10, " ") + "|is_even" + "|is_odd |") |
|||
writeLine("----------+-------+-------+") |
|||
for each int i in range(-5, 6).append(3141592653) |
|||
write((text!i).padStart(10, " ") + "| ") |
|||
for each fun isEven in evenCheckers |
|||
write(isEven(i) + " ") |
|||
end |
|||
write("| ") |
|||
for each fun isOdd in oddCheckers |
|||
write(isOdd(i) + " ") |
|||
end |
|||
writeLine("|") |
|||
end |
|||
writeLine("----------+-------+-------+") |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
integer|is_even|is_odd | |
|||
----------+-------+-------+ |
|||
-5| ⊥ ⊥ | ⊤ ⊤ | |
|||
-4| ⊤ ⊤ | ⊥ ⊥ | |
|||
-3| ⊥ ⊥ | ⊤ ⊤ | |
|||
-2| ⊤ ⊤ | ⊥ ⊥ | |
|||
-1| ⊥ ⊥ | ⊤ ⊤ | |
|||
0| ⊤ ⊤ | ⊥ ⊥ | |
|||
1| ⊥ ⊥ | ⊤ ⊤ | |
|||
2| ⊤ ⊤ | ⊥ ⊥ | |
|||
3| ⊥ ⊥ | ⊤ ⊤ | |
|||
4| ⊤ ⊤ | ⊥ ⊥ | |
|||
5| ⊥ ⊥ | ⊤ ⊤ | |
|||
3141592653| ⊥ ⊥ | ⊤ ⊤ | |
|||
----------+-------+-------+ |
|||
</pre> |
|||
=={{header|Erlang}}== |
|||
===Using Division by 2 Method=== |
|||
<syntaxhighlight 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. |
|||
</syntaxhighlight> |
|||
===Using the least-significant bit method=== |
|||
<syntaxhighlight 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. |
|||
</syntaxhighlight> |
|||
=={{header|ERRE}}== |
|||
<syntaxhighlight 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 |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
14 is even |
|||
15 is odd |
|||
9876543210 is even |
|||
9876543211 is odd |
|||
</pre> |
|||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
Using standard function |
Using standard function |
||
<syntaxhighlight lang="euphoria"> |
|||
<lang Euphoria> |
|||
include std/math.e |
include std/math.e |
||
Line 270: | Line 2,040: | ||
? {i, is_even(i)} |
? {i, is_even(i)} |
||
end for |
end for |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
|||
Output |
|||
<pre> |
<pre> |
||
{1,0} |
{1,0} |
||
Line 284: | Line 2,054: | ||
{10,1} |
{10,1} |
||
</pre> |
</pre> |
||
=={{header|Excel}}== |
|||
Use the MOD function |
|||
<syntaxhighlight lang="excel"> |
|||
=MOD(33;2) |
|||
=MOD(18;2) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 |
|||
0 |
|||
</pre> |
|||
Use the ISEVEN function, returns TRUE or FALSE |
|||
<syntaxhighlight lang="excel"> |
|||
=ISEVEN(33) |
|||
=ISEVEN(18) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
FALSE |
|||
TRUE |
|||
</pre> |
|||
Use the ISODD function, returns TRUE or FALSE |
|||
<syntaxhighlight lang="excel"> |
|||
=ISODD(33) |
|||
=ISODD(18) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
TRUE |
|||
FALSE |
|||
</pre> |
|||
=={{header|F Sharp|F#}}== |
|||
Bitwise and: |
|||
<syntaxhighlight lang="fsharp">let isEven x = |
|||
x &&& 1 = 0</syntaxhighlight> |
|||
Modulo: |
|||
<syntaxhighlight lang="fsharp">let isEven x = |
|||
x % 2 = 0</syntaxhighlight> |
|||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
Line 299: | Line 2,116: | ||
=={{header|Fish}}== |
=={{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. |
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. |
||
< |
<syntaxhighlight lang="fish"><v"Please enter a number:"a |
||
>l0)?!vo v < v o< |
>l0)?!vo v < v o< |
||
^ >i:a=?v>i:a=?v$a*+^>"The number is even."ar>l0=?!^> |
^ >i:a=?v>i:a=?v$a*+^>"The number is even."ar>l0=?!^> |
||
> >2%0=?^"The number is odd."ar ^</ |
> >2%0=?^"The number is odd."ar ^</syntaxhighlight> |
||
The actual computation is the 2%0= part. The rest is either user interface or parsing input. |
The actual computation is the 2%0= part. The rest is either user interface or parsing input. |
||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
<syntaxhighlight lang="forth"> |
|||
<lang forth>: odd? ( n -- ? ) 1 and ;</lang> |
|||
: odd? ( n -- ? ) 1 and ; |
|||
: even? ( n -- ? ) odd? 0= ; |
|||
\ Every value not equal to zero is considered true. Only zero is considered false. |
|||
</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight 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 |
|||
</syntaxhighlight> |
|||
=={{header|Frink}}== |
|||
<syntaxhighlight lang="frink">isEven[x is isInteger] := getBit[x,0] == 0 |
|||
isOdd[x is isInteger] := getBit[x,0] == 1</syntaxhighlight> |
|||
=={{header|Futhark}}== |
|||
{{incorrect|Futhark|Futhark's syntax has changed, so this example will not compile}} |
|||
<syntaxhighlight lang="futhark"> |
|||
fun main(x: int): bool = (x & 1) == 0 |
|||
</syntaxhighlight> |
|||
=={{header|FutureBasic}}== |
|||
<syntaxhighlight lang="futurebasic"> |
|||
local fn OddOrEven( i as NSInteger ) as CFStringRef |
|||
CFStringRef result |
|||
if ( i mod 2 ) == 0 then result = @"Even" else result = @"Odd" |
|||
end fn = result |
|||
NSUInteger i |
|||
for i = 1 to 10 |
|||
printf @"%d is %@", i, fn OddOrEven( i ) |
|||
next |
|||
HandleEvents |
|||
</syntaxhighlight> |
|||
=={{header|Fōrmulæ}}== |
|||
{{FormulaeEntry|page=https://formulae.org/?script=examples/Even_or_odd}} |
|||
'''Solutions''' |
|||
'''Case 1.''' Intrinsic expressions: |
|||
[[File:Fōrmulæ - Even or odd 01.png]] |
|||
[[File:Fōrmulæ - Even or odd 02.png]] |
|||
'''Case 2.''' Using the Divides and DoesNotDivide expressions: |
|||
[[File:Fōrmulæ - Even or odd 03.png]] |
|||
[[File:Fōrmulæ - Even or odd 04.png]] |
|||
'''Case 3.''' Using modular congruences |
|||
[[File:Fōrmulæ - Even or odd 05.png]] |
|||
[[File:Fōrmulæ - Even or odd 06.png]] |
|||
'''Case 4.''' Using bitwise operations |
|||
[[File:Fōrmulæ - Even or odd 07.png]] |
|||
[[File:Fōrmulæ - Even or odd 08.png]] |
|||
'''Case 5.''' Using IsRational |
|||
[[File:Fōrmulæ - Even or odd 09.png]] |
|||
[[File:Fōrmulæ - Even or odd 10.png]] |
|||
=={{header|GAP}}== |
|||
<syntaxhighlight lang="gap">IsEvenInt(n); |
|||
IsOddInt(n);</syntaxhighlight> |
|||
=={{header|Genie}}== |
|||
Using bitwise AND of the zero-bit. |
|||
<syntaxhighlight lang="genie">[indent = 4] |
|||
/* |
|||
Even or odd, in Genie |
|||
valac even_or_odd.gs |
|||
*/ |
|||
def parity(n:int):bool |
|||
return ((n & 1) == 0) |
|||
def show_parity(n:int):void |
|||
print "%d is %s", n, parity(n) ? "even" : "odd" |
|||
init |
|||
show_parity(0) |
|||
show_parity(1) |
|||
show_parity(2) |
|||
show_parity(-2) |
|||
show_parity(-1)</syntaxhighlight> |
|||
{{out}} |
|||
<pre>prompt$ valac even_or_odd.gs |
|||
prompt$ ./even_or_odd |
|||
0 is even |
|||
1 is odd |
|||
2 is even |
|||
-2 is even |
|||
-1 is odd</pre> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 356: | Line 2,361: | ||
fmt.Println("odd") |
fmt.Println("odd") |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 373: | Line 2,378: | ||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
Solution: |
Solution: |
||
< |
<syntaxhighlight lang="groovy">def isOdd = { int i -> (i & 1) as boolean } |
||
def isEven = {int i -> ! isOdd(i) }</ |
def isEven = {int i -> ! isOdd(i) }</syntaxhighlight> |
||
Test: |
Test: |
||
< |
<syntaxhighlight lang="groovy">1.step(20, 2) { assert isOdd(it) } |
||
50.step(-50, -2) { assert isEven(it) }</ |
50.step(-50, -2) { assert isEven(it) }</syntaxhighlight> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
<code>even</code> and <code>odd</code> functions are already included in the standard Prelude. |
<code>even</code> and <code>odd</code> functions are already included in the standard Prelude. |
||
< |
<syntaxhighlight lang="haskell">Prelude> even 5 |
||
False |
False |
||
Prelude> even 42 |
Prelude> even 42 |
||
Line 389: | Line 2,394: | ||
True |
True |
||
Prelude> odd 42 |
Prelude> odd 42 |
||
False</ |
False</syntaxhighlight> |
||
Where '''even''' is derived from '''rem''', and '''odd''' is derived from even: |
|||
<syntaxhighlight lang="haskell">import Prelude hiding (even, odd) |
|||
even, odd |
|||
:: (Integral a) |
|||
=> a -> Bool |
|||
even = (0 ==) . (`rem` 2) |
|||
odd = not . even |
|||
main :: IO () |
|||
main = print (even <$> [0 .. 9])</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>[True,False,True,False,True,False,True,False,True,False]</pre> |
|||
=={{header|Hoon}}== |
|||
<syntaxhighlight lang="hoon">|= n=@ud |
|||
?: =((mod n 2) 0) |
|||
"even" |
|||
"odd"</syntaxhighlight> |
|||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
One way is to check the remainder: |
One way is to check the remainder: |
||
< |
<syntaxhighlight lang="unicon">procedure isEven(n) |
||
return n%2 = 0 |
return n%2 = 0 |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Insitux}}== |
|||
Exactly the same as [[Even_or_odd#Clojure|Clojure]], these are built-in predicates. |
|||
<syntaxhighlight lang="insitux">(if (even? some-var) (do-even-stuff)) |
|||
(if (odd? some-var) (do-odd-stuff))</syntaxhighlight> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
Modulo: |
Modulo: |
||
< |
<syntaxhighlight lang="j"> 2 | 2 3 5 7 |
||
0 1 1 1 |
0 1 1 1 |
||
2|2 3 5 7 + (2^89x)-1 |
2|2 3 5 7 + (2^89x)-1 |
||
1 0 0 0</ |
1 0 0 0</syntaxhighlight> |
||
Remainder: |
Remainder: |
||
< |
<syntaxhighlight lang="j"> (= <.&.-:) 2 3 5 7 |
||
1 0 0 0 |
1 0 0 0 |
||
(= <.&.-:) 2 3 5 7+(2^89x)-1 |
(= <.&.-:) 2 3 5 7+(2^89x)-1 |
||
0 1 1 1</ |
0 1 1 1</syntaxhighlight> |
||
Last bit in bit representation: |
Last bit in bit representation: |
||
< |
<syntaxhighlight lang="j"> {:"1@#: 2 3 5 7 |
||
0 1 1 1 |
0 1 1 1 |
||
{:"1@#: 2 3 5 7+(2^89x)-1 |
{:"1@#: 2 3 5 7+(2^89x)-1 |
||
1 0 0 0</ |
1 0 0 0</syntaxhighlight> |
||
Bitwise and: |
Bitwise and: |
||
< |
<syntaxhighlight lang="j"> 1 (17 b.) 2 3 5 7 |
||
0 1 1 1</ |
0 1 1 1</syntaxhighlight> |
||
Note: as a general rule, the simplest expressions in J should be preferred over more complex approaches. |
Note: as a general rule, the simplest expressions in J should be preferred over more complex approaches. |
||
=={{header|Jakt}}== |
|||
<syntaxhighlight lang="jakt"> |
|||
fn is_even<T>(anon n: T) -> bool => 0 == (n & 1) |
|||
fn is_odd<T>(anon n: T) -> bool => 0 != (n & 1) |
|||
fn main() { |
|||
for i in 0..11 { |
|||
println("{} {} {}", i, is_even(i), is_odd(i)) |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
Bitwise and: |
Bitwise and: |
||
< |
<syntaxhighlight lang="java">public static boolean isEven(int i){ |
||
return (i & 1) == 0; |
return (i & 1) == 0; |
||
}</ |
}</syntaxhighlight> |
||
Modulo: |
Modulo: |
||
< |
<syntaxhighlight lang="java">public static boolean isEven(int i){ |
||
return (i % 2) == 0; |
return (i % 2) == 0; |
||
}</ |
}</syntaxhighlight> |
||
Arbitrary precision bitwise: |
Arbitrary precision bitwise: |
||
< |
<syntaxhighlight lang="java">public static boolean isEven(BigInteger i){ |
||
return i.and(BigInteger.ONE).equals(BigInteger.ZERO); |
return i.and(BigInteger.ONE).equals(BigInteger.ZERO); |
||
}</ |
}</syntaxhighlight> |
||
Arbitrary precision bit test (even works for negative numbers because of the way <code>BigInteger</code> represents the bits of numbers): |
Arbitrary precision bit test (even works for negative numbers because of the way <code>BigInteger</code> represents the bits of numbers): |
||
< |
<syntaxhighlight lang="java">public static boolean isEven(BigInteger i){ |
||
return !i.testBit(0); |
return !i.testBit(0); |
||
}</ |
}</syntaxhighlight> |
||
Arbitrary precision modulo: |
Arbitrary precision modulo: |
||
< |
<syntaxhighlight lang="java">public static boolean isEven(BigInteger i){ |
||
return i.mod(BigInteger.valueOf(2)).equals(BigInteger.ZERO); |
return i.mod(BigInteger.valueOf(2)).equals(BigInteger.ZERO); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|JavaScript}}== |
|||
===ES5=== |
|||
Bitwise: |
|||
<syntaxhighlight lang="javascript">function isEven( i ) { |
|||
return (i & 1) === 0; |
|||
} |
|||
</syntaxhighlight> |
|||
Modulo: |
|||
<syntaxhighlight lang="javascript">function isEven( i ) { |
|||
return i % 2 === 0; |
|||
} |
|||
// Alternative |
|||
function isEven( i ) { |
|||
return !(i % 2); |
|||
}</syntaxhighlight> |
|||
===ES6=== |
|||
Lambda: |
|||
<syntaxhighlight lang="javascript">// EMCAScript 6 |
|||
const isEven = x => !(x % 2)</syntaxhighlight> |
|||
or, avoiding type coercion: |
|||
<syntaxhighlight lang="javascript">(() => { |
|||
'use strict'; |
|||
// even : Integral a => a -> Bool |
|||
const even = x => (x % 2) === 0; |
|||
// odd : Integral a => a -> Bool |
|||
const odd = x => !even(x); |
|||
// TEST ---------------------------------------- |
|||
// range :: Int -> Int -> [Int] |
|||
const range = (m, n) => |
|||
Array.from({ |
|||
length: Math.floor(n - m) + 1 |
|||
}, (_, i) => m + i); |
|||
// show :: a -> String |
|||
const show = JSON.stringify; |
|||
// xs :: [Int] |
|||
const xs = range(-6, 6); |
|||
return show([xs.filter(even), xs.filter(odd)]); |
|||
})();</syntaxhighlight> |
|||
{{Out}} |
|||
<pre>[[-6,-4,-2,0,2,4,6],[-5,-3,-1,1,3,5]]</pre> |
|||
=={{header|Joy}}== |
|||
<syntaxhighlight lang="joy">DEFINE |
|||
even == 2 rem null; |
|||
odd == even not.</syntaxhighlight> |
|||
=={{header|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: |
|||
<syntaxhighlight lang="jq">def is_even: type == "number" and floor == 0 and . % 2 == 0;</syntaxhighlight> |
|||
The check that the floor is 0 is necessary as % is defined on floating point numbers. |
|||
"is_odd" could be similarly defined: |
|||
<syntaxhighlight lang="jq">def is_odd: type == "number" and floor == 0 and . % 2 == 1;</syntaxhighlight> |
|||
=={{header|Jsish}}== |
|||
Using bitwise and of low bit. |
|||
<syntaxhighlight lang="javascript">#!/usr/bin/env jsish |
|||
/* Even or Odd, in Jsish */ |
|||
function isEven(n:number):boolean { return (n & 1) === 0; } |
|||
provide('isEven', 1); |
|||
if (Interp.conf('unitTest')) { |
|||
; isEven(0); |
|||
; isEven(1); |
|||
; isEven(2); |
|||
; isEven(-13); |
|||
} |
|||
/* |
|||
=!EXPECTSTART!= |
|||
isEven(0) ==> true |
|||
isEven(1) ==> false |
|||
isEven(2) ==> true |
|||
isEven(-13) ==> false |
|||
=!EXPECTEND!= |
|||
*/</syntaxhighlight> |
|||
{{out}} |
|||
<pre>$ jsish --U isEven.jsi |
|||
isEven(0) ==> true |
|||
isEven(1) ==> false |
|||
isEven(2) ==> true |
|||
isEven(-13) ==> false</pre> |
|||
=={{header|Julia}}== |
|||
Built-in functions: |
|||
<syntaxhighlight lang="julia">iseven(i), isodd(i)</syntaxhighlight> |
|||
=={{header|K}}== |
|||
The following implementation uses the modulo of |
|||
division by 2 |
|||
<syntaxhighlight lang="k"> |
|||
oddp: {:[x!2;1;0]} /Returns 1 if arg. is odd |
|||
evenp: {~oddp[x]} /Returns 1 if arg. is even |
|||
Examples: |
|||
oddp 32 |
|||
0 |
|||
evenp 32 |
|||
1 |
|||
</syntaxhighlight> |
|||
=={{header|Klingphix}}== |
|||
<syntaxhighlight lang="klingphix">( -5 5 ) [ |
|||
dup print " " print 2 mod ( ["Odd"] ["Even"] ) if print nl |
|||
] for |
|||
" " input</syntaxhighlight> |
|||
{{out}} |
|||
<pre>-5 Odd |
|||
-4 Even |
|||
-3 Odd |
|||
-2 Even |
|||
-1 Odd |
|||
0 Even |
|||
1 Odd |
|||
2 Even |
|||
3 Odd |
|||
4 Even |
|||
5 Odd</pre> |
|||
=={{header|Kotlin}}== |
|||
<syntaxhighlight lang="scala">// version 1.0.5-2 |
|||
fun main(args: Array<String>) { |
|||
while (true) { |
|||
print("Enter an integer or 0 to finish : ") |
|||
val n = readLine()!!.toInt() |
|||
when { |
|||
n == 0 -> return |
|||
n % 2 == 0 -> println("Your number is even") |
|||
else -> println("Your number is odd") |
|||
} |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Lambdatalk}}== |
|||
<syntaxhighlight lang="scheme"> |
|||
{def is_odd {lambda {:i} {= {% :i 2} 1}}} |
|||
-> is_odd |
|||
{def is_even {lambda {:i} {= {% :i 2} 0}}} |
|||
-> is_even |
|||
{is_odd 2} |
|||
-> false |
|||
{is_even 2} |
|||
-> true |
|||
</syntaxhighlight> |
|||
=={{header|L++}}== |
|||
<syntaxhighlight lang="lisp">(defn bool isEven (int x) (return (% x 2)))</syntaxhighlight> |
|||
=={{header|LabVIEW}}== |
=={{header|LabVIEW}}== |
||
Line 444: | Line 2,660: | ||
{{VI solution|LabVIEW_Even_or_odd.png}} |
{{VI solution|LabVIEW_Even_or_odd.png}} |
||
=={{header| |
=={{header|Lang5}}== |
||
<syntaxhighlight lang="lang5">: even? 2 % not ; |
|||
<lang lb> |
|||
: odd? 2 % ; |
|||
n=12 |
|||
1 even? . # 0 |
|||
1 odd? . # 1</syntaxhighlight> |
|||
=={{header|Lasso}}== |
|||
if n mod 2 = 0 then print "even" else print "odd" |
|||
<syntaxhighlight lang="lasso">define isoddoreven(i::integer) => { |
|||
</lang> |
|||
#i % 2 ? return 'odd' |
|||
return 'even' |
|||
} |
|||
isoddoreven(12)</syntaxhighlight> |
|||
=={{header|LC3 Assembly}}== |
|||
Prints <tt>EVEN</tt> if the number stored in <tt>NUM</tt> is even, otherwise <tt>ODD</tt>. |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Lingo}}== |
|||
<syntaxhighlight lang="lingo">on even (n) |
|||
return n mod 2 = 0 |
|||
end |
|||
on odd (n) |
|||
return n mode 2 <> 0 |
|||
end</syntaxhighlight> |
|||
=={{header|Little Man Computer}}== |
|||
Runs in Peter Higginson's simulator, to allow comments. Does not use his other extensions to the language. |
|||
LMC has no division instruction. To divide by 2 we could use repeated subtraction: |
|||
<syntaxhighlight lang="little man computer"> |
|||
// Input number; output its residue mod 2 |
|||
INP // read input into acc |
|||
BRZ write // input = 0 is special case |
|||
loop SUB k2 // keep subtracting 2 from acc |
|||
BRZ write // if acc = 0, input is even |
|||
BRP loop // if acc > 0, loop back |
|||
// (BRP branches if acc >= 0, but we've dealt with acc = 0) |
|||
LDA k1 // if acc < 0, input is odd |
|||
write OUT // output 0 or 1 |
|||
HLT // halt |
|||
k1 DAT 1 // constant 1 |
|||
k2 DAT 2 // constant 2 |
|||
// end |
|||
</syntaxhighlight> |
|||
The above program might need 500 subtractions before it found the result. To speed things up we could use something along the following lines. |
|||
<syntaxhighlight lang="little man computer"> |
|||
// Input number; output its residue mod 2 |
|||
INP // read input into accumulator |
|||
loop1 STA save_acc // save accumulator (see note below) |
|||
SUB k128 // keep subtracting 128 until acc < 0 |
|||
BRP loop1 |
|||
LDA save_acc // save_acc holds a number in range 0..127 |
|||
loop2 STA save_acc |
|||
SUB k16 // keep subtracting 16 until acc < 0 |
|||
BRP loop2 |
|||
LDA save_acc // save_acc holds a number in range 0..15 |
|||
loop3 STA save_acc |
|||
SUB k2 // keep subtracting 2 until acc < 0 |
|||
BRP loop3 |
|||
LDA save_acc // save_acc holds 0 or 1, the result |
|||
write OUT // output result |
|||
HLT |
|||
k2 DAT 2 |
|||
k16 DAT 16 |
|||
k128 DAT 128 |
|||
save_acc DAT |
|||
// end |
|||
</syntaxhighlight> |
|||
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}}== |
|||
<syntaxhighlight lang="livecode">function odd n |
|||
return (n bitand 1) = 1 |
|||
end odd |
|||
function notEven n |
|||
return (n mod 2) = 1 |
|||
end notEven</syntaxhighlight> |
|||
=={{header|LLVM}}== |
|||
<syntaxhighlight lang="llvm">; This is not strictly LLVM, as it uses the C library function "printf". |
|||
; 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. |
|||
; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps |
|||
;--- The declarations for the external C functions |
|||
declare i32 @printf(i8*, ...) |
|||
$"EVEN_STR" = comdat any |
|||
$"ODD_STR" = comdat any |
|||
@"EVEN_STR" = linkonce_odr unnamed_addr constant [12 x i8] c"%d is even\0A\00", comdat, align 1 |
|||
@"ODD_STR" = linkonce_odr unnamed_addr constant [11 x i8] c"%d is odd\0A\00", comdat, align 1 |
|||
; Function Attrs: noinline nounwind optnone uwtable |
|||
define i32 @main() #0 { |
|||
%1 = alloca i32, align 4 ;-- allocate i |
|||
store i32 0, i32* %1, align 4 ;-- store 0 in i |
|||
br label %loop |
|||
loop: |
|||
%2 = load i32, i32* %1, align 4 ;-- load i |
|||
%3 = icmp ult i32 %2, 4 ;-- i < 4 |
|||
br i1 %3, label %loop_body, label %exit |
|||
loop_body: |
|||
%4 = load i32, i32* %1, align 4 ;-- load i |
|||
%5 = and i32 %4, 1 ;-- i & 1 |
|||
%6 = icmp eq i32 %5, 0 ;-- (i & 1) == 0 |
|||
br i1 %6, label %even_branch, label %odd_branch |
|||
even_branch: |
|||
%7 = load i32, i32* %1, align 4 ;-- load i |
|||
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @"EVEN_STR", i32 0, i32 0), i32 %7) |
|||
br label %loop_increment |
|||
odd_branch: |
|||
%9 = load i32, i32* %1, align 4 ;-- load i |
|||
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @"ODD_STR", i32 0, i32 0), i32 %9) |
|||
br label %loop_increment |
|||
loop_increment: |
|||
%11 = load i32, i32* %1, align 4 ;-- load i |
|||
%12 = add i32 %11, 1 ;-- increment i |
|||
store i32 %12, i32* %1, align 4 ;-- store i |
|||
br label %loop |
|||
exit: |
|||
ret i32 0 |
|||
} |
|||
attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }</syntaxhighlight> |
|||
{{out}} |
|||
<pre>0 is even |
|||
1 is odd |
|||
2 is even |
|||
3 is odd</pre> |
|||
=={{header|Logo}}== |
|||
<syntaxhighlight lang="logo">to even? :num |
|||
output equal? 0 modulo :num 2 |
|||
end</syntaxhighlight> |
|||
=={{header|Logtalk}}== |
|||
<syntaxhighlight 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. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<syntaxhighlight 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 |
|||
</syntaxhighlight> |
|||
=={{header|LOLCODE}}== |
|||
<syntaxhighlight lang="lolcode">HAI 1.4 |
|||
I HAS A integer |
|||
GIMMEH integer |
|||
I HAS A remainder |
|||
remainder R MOD OF integer AN 2 |
|||
BOTH SAEM remainder AN 1, O RLY? |
|||
YA RLY |
|||
VISIBLE "The integer is odd." |
|||
NO WAI |
|||
VISIBLE "The integer is even." |
|||
OIC |
|||
KTHXBYE</syntaxhighlight> |
|||
=={{header|Lua}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|M2000 Interpreter}}== |
|||
Binary.Add take any numeric type, but value from newer versions can trait as unsigned with range of 0 to 0xFFFFFFFF (so if the number is out of this range, a cut made). |
|||
Print binary.and(0xFFFFFFF+10, 0XF)=9 // 0xFFFFFFFF is type Currency and return 4294967295, number 10 is type double so the final number for addition is type double. |
|||
Print binary.and(0xFFFFFFF&+10, 0XF)=9 // 0xFFFFFFFF& is type long and return -1, number 10 is type double so the final number for addition is type double. |
|||
Print binary.and(0x7FFFFFFF&*16&+10&, 0xF)=15 // 0x7FFFFFFF&*16& cant fit in long so it is type of double 34359738352 (this performed automatic). But if we give this Long A=0x7FFFFFFF&*16& we get an overflow error, because A is a Long, and 34359738352 can't fit. |
|||
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 |
|||
Def used to define variables (an error occur if same variable exist), or to define one line local functions. If a function exist then replace code. This is the same for modules/functions, a newer definition alter an old definition with same name, in current module if they are local, or global if they defined as global, like this: |
|||
Function Global F(x) { code block here}. |
|||
A function F(x) {} is same as |
|||
<pre > |
|||
Function F { |
|||
Read x |
|||
code here |
|||
} |
|||
</pre > |
|||
The same hold for Def Odd(a)=binary.and(Abs(a), 1)=1 |
|||
Interpreter execute this: |
|||
<pre > |
|||
Function Odd { |
|||
Read a |
|||
=binary.and(Abs(a), 1)=1 |
|||
} |
|||
</pre > |
|||
So here is the task. Show an overflow from a decimal, then change function. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Module CheckOdd { |
|||
Def Odd(a)= binary.and(Abs(a), 1)=1 |
|||
Print Odd(-5), Odd(6), Odd(11) |
|||
Print Odd(21212121212122122122121@) |
|||
def Odd(a)= Int(Abs(a)) mod 2 =1 |
|||
Print Odd(21212121212122122122121@) |
|||
Print Odd(-5), Odd(6), Odd(11) |
|||
} |
|||
CheckOdd |
|||
</syntaxhighlight> |
|||
=={{header|M4}}== |
|||
<syntaxhighlight 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)</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
<syntaxhighlight lang="maple">EvenOrOdd := proc( x::integer ) |
|||
if x mod 2 = 0 then |
|||
print("Even"): |
|||
else |
|||
print("Odd"): |
|||
end if: |
|||
end proc: |
|||
EvenOrOdd(9);</syntaxhighlight> |
|||
<pre>"Odd"</pre> |
|||
=={{header|Mathematica}}== |
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
||
<lang |
<syntaxhighlight lang="mathematica">EvenQ[8]</syntaxhighlight> |
||
=={{header|MATLAB}} / {{header|Octave}}== |
=={{header|MATLAB}} / {{header|Octave}}== |
||
Bitwise And: |
Bitwise And: |
||
< |
<syntaxhighlight lang="matlab"> isOdd = logical(bitand(N,1)); |
||
isEven = ~logical(bitand(N,1)); </ |
isEven = ~logical(bitand(N,1)); </syntaxhighlight> |
||
Remainder of division by two |
Remainder of division by two: |
||
< |
<syntaxhighlight lang="matlab"> isOdd = logical(rem(N,2)); |
||
isEven = ~logical(rem(N,2)); </ |
isEven = ~logical(rem(N,2)); </syntaxhighlight> |
||
Modulo: 2 |
Modulo: 2 |
||
< |
<syntaxhighlight lang="matlab"> isOdd = logical(mod(N,2)); |
||
isEven = ~logical(mod(N,2)); </ |
isEven = ~logical(mod(N,2)); </syntaxhighlight> |
||
=={{header|Maxima}}== |
=={{header|Maxima}}== |
||
< |
<syntaxhighlight lang="maxima">evenp(n); |
||
oddp(n);</ |
oddp(n);</syntaxhighlight> |
||
=={{header|MAXScript}}== |
|||
<syntaxhighlight lang="maxscript">-- MAXScript : Even or Odd : N.H. 2019 |
|||
-- Open the MAXScript Listener for input and output |
|||
userInt = getKBValue prompt:"Enter an integer and i will tell you if its Even or Odd : " |
|||
if classOf userInt != Integer then print "The value you enter must be an integer" |
|||
else if (Mod userInt 2) == 0 Then Print "Your number is even" |
|||
else Print "Your number is odd" |
|||
</syntaxhighlight> |
|||
=={{header|Mercury}}== |
=={{header|Mercury}}== |
||
Mercury's 'int' module provides tests for even/odd, along with all the operators that would be otherwise used to implement them. |
Mercury's 'int' module provides tests for even/odd, along with all the operators that would be otherwise used to implement them. |
||
< |
<syntaxhighlight lang="mercury">even(N) % in a body, suceeeds iff N is even. |
||
odd(N). % in a body, succeeds iff N is odd. |
odd(N). % in a body, succeeds iff N is odd. |
||
Line 480: | Line 2,998: | ||
even(N) :- N mod 2 = 0. % using division that truncates towards -infinity |
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 rem 2 = 0. % using division that truncates towards zero |
||
even(N) :- N /\ 1 = 0. % using bit-wise and.</ |
even(N) :- N /\ 1 = 0. % using bit-wise and.</syntaxhighlight> |
||
=={{header|min}}== |
|||
{{works with|min|0.19.3}} |
|||
<syntaxhighlight lang="min">3 even? |
|||
4 even? |
|||
5 odd? |
|||
get-stack print</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
(false true true) |
|||
</pre> |
|||
=={{header|MiniScript}}== |
|||
<syntaxhighlight lang="miniscript">for i in range(-4, 4) |
|||
if i % 2 == 0 then print i + " is even" else print i + " is odd" |
|||
end for</syntaxhighlight> |
|||
{{out}} |
|||
<pre>-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</pre> |
|||
=={{header|MIPS Assembly}}== |
|||
This uses bitwise AND |
|||
<syntaxhighlight 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 |
|||
</syntaxhighlight> |
|||
=={{header|МК-61/52}}== |
|||
<syntaxhighlight lang="text">/ 2 {x} ЗН</syntaxhighlight> |
|||
''Result:'' "0" - number is even; "1" - number is odd. |
|||
=={{header|ML}}== |
|||
<syntaxhighlight lang="ml"> |
|||
fun even( x: int ) = (x mod 2 = 0); |
|||
fun odd( x: int ) = (x mod 2 = 1); |
|||
</syntaxhighlight> |
|||
==={{header|mLite}}=== |
|||
<syntaxhighlight lang="ocaml">fun odd |
|||
(x rem 2 = 1) = true |
|||
| _ = false |
|||
; |
|||
fun even |
|||
(x rem 2 = 0) = true |
|||
| _ = false |
|||
; |
|||
</syntaxhighlight> |
|||
=={{header|Modula-2}}== |
|||
<syntaxhighlight lang="modula2">MODULE EvenOrOdd; |
|||
FROM FormatString IMPORT FormatString; |
|||
FROM Terminal IMPORT WriteString,ReadChar; |
|||
VAR |
|||
buf : ARRAY[0..63] OF CHAR; |
|||
i : INTEGER; |
|||
BEGIN |
|||
FOR i:=-5 TO 5 DO |
|||
FormatString("%i is even: %b\n", buf, i, i MOD 2 = 0); |
|||
WriteString(buf) |
|||
END; |
|||
ReadChar |
|||
END EvenOrOdd.</syntaxhighlight> |
|||
=={{header|Nanoquery}}== |
|||
<syntaxhighlight lang="nanoquery">def isEven(n) |
|||
if ((n % 2) = 1) |
|||
return false |
|||
else |
|||
return true |
|||
end |
|||
end |
|||
for i in range(1, 10) |
|||
print i |
|||
if isEven(i) |
|||
println " is even." |
|||
else |
|||
println " is odd." |
|||
end |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre>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.</pre> |
|||
=={{header|Neko}}== |
|||
<syntaxhighlight lang="neko">var number = 6; |
|||
if(number % 2 == 0) { |
|||
$print("Even"); |
|||
} else { |
|||
$print("Odd"); |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Even</pre> |
|||
=={{header|NESL}}== |
|||
NESL provides <tt>evenp</tt> and <tt>oddp</tt> functions, but they wouldn't be hard to reimplement. |
|||
<syntaxhighlight 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]};</syntaxhighlight> |
|||
{{out}} |
|||
<pre>it = [F, T, F, T, F, T, F, T, F, T] : [bool]</pre> |
|||
=={{header|NetRexx}}== |
|||
<syntaxhighlight 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) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
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 |
|||
</pre> |
|||
=={{header|Never}}== |
|||
<syntaxhighlight lang="never"> |
|||
func isOdd(n : int) -> int { |
|||
n % 2 == 1 |
|||
} |
|||
func isEven(n : int) -> int { |
|||
n % 2 == 0 |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|NewLISP}}== |
|||
<syntaxhighlight lang="newlisp">(odd? 1) |
|||
(even? 2)</syntaxhighlight> |
|||
=={{header|Nim}}== |
|||
<syntaxhighlight 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)</syntaxhighlight> |
|||
=={{header|Nu}}== |
|||
{{works with|Nushell|0.91.1}} |
|||
<syntaxhighlight lang="nu">def is-even [x: int] { |
|||
($x bit-and 1) == 0 |
|||
} |
|||
def is-odd [x: int] { |
|||
($x bit-and 1) == 1 |
|||
}</syntaxhighlight> |
|||
=={{header|Oberon-2}}== |
|||
{{works with|oo2c}} |
|||
<syntaxhighlight 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. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
10 even |
|||
11 odd |
|||
12 even |
|||
</pre> |
|||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
< |
<syntaxhighlight lang="objeck">a := Console->ReadString()->ToInt(); |
||
if(a % 2 = 0) { |
if(a % 2 = 0) { |
||
"even"->PrintLine(); |
"even"->PrintLine(); |
||
Line 489: | Line 3,297: | ||
else { |
else { |
||
"odd"->PrintLine(); |
"odd"->PrintLine(); |
||
};</ |
};</syntaxhighlight> |
||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
Modulo: |
Modulo: |
||
< |
<syntaxhighlight lang="ocaml">let is_even d = |
||
(d mod 2) = 0 |
(d mod 2) = 0 |
||
let is_odd d = |
let is_odd d = |
||
(d mod 2) <> 0</ |
(d mod 2) <> 0</syntaxhighlight> |
||
Bitwise and: |
Bitwise and: |
||
< |
<syntaxhighlight lang="ocaml">let is_even d = |
||
(d land 1) = 0 |
(d land 1) = 0 |
||
let is_odd d = |
let is_odd d = |
||
(d land 1) <> 0</ |
(d land 1) <> 0</syntaxhighlight> |
||
An instructive view on functional programming and recursion: |
|||
<syntaxhighlight lang="ocaml">(* hmm, only valid for N >= 0 *) |
|||
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</syntaxhighlight> |
|||
=={{header|Oforth}}== |
|||
<syntaxhighlight lang="oforth">12 isEven |
|||
12 isOdd</syntaxhighlight> |
|||
=={{header|Ol}}== |
|||
Actually, 'even?' and 'odd?' functions are built-in. But, |
|||
<syntaxhighlight lang="scheme"> |
|||
; 1. Check the least significant bit. |
|||
(define (even? i) |
|||
(if (eq? (band i 1) 0) #t #f)) |
|||
(define (odd? i) |
|||
(if (eq? (band i 1) 1) #t #f)) |
|||
(print (if (even? 12345678987654321) "even" "odd")) ; ==> odd |
|||
(print (if (odd? 12345678987654321) "odd" "even")) ; ==> odd |
|||
(print (if (even? 1234567898765432) "even" "odd")) ; ==> even |
|||
(print (if (odd? 1234567898765432) "odd" "even")) ; ==> even |
|||
; 2. Divide i by 2. The remainder equals 0 iff i is even. |
|||
(define (even? i) |
|||
(if (eq? (remainder i 2) 0) #t #f)) |
|||
(define (odd? i) |
|||
(if (eq? (remainder i 2) 1) #t #f)) |
|||
(print (if (even? 12345678987654321) "even" "odd")) ; ==> odd |
|||
(print (if (odd? 12345678987654321) "odd" "even")) ; ==> odd |
|||
(print (if (even? 1234567898765432) "even" "odd")) ; ==> even |
|||
(print (if (odd? 1234567898765432) "odd" "even")) ; ==> even |
|||
; 3. Use modular congruences. Same as 2. |
|||
(define (even? i) |
|||
(if (eq? (mod i 2) 0) #t #f)) |
|||
(define (odd? i) |
|||
(if (eq? (mod i 2) 1) #t #f)) |
|||
(print (if (even? 12345678987654321) "even" "odd")) ; ==> odd |
|||
(print (if (odd? 12345678987654321) "odd" "even")) ; ==> odd |
|||
(print (if (even? 1234567898765432) "even" "odd")) ; ==> even |
|||
(print (if (odd? 1234567898765432) "odd" "even")) ; ==> even |
|||
</syntaxhighlight> |
|||
=={{header|OOC}}== |
|||
<syntaxhighlight 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 |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
GP does not have a built-in predicate for testing parity, but it's easy to code: |
GP does not have a built-in predicate for testing parity, but it's easy to code: |
||
< |
<syntaxhighlight lang="parigp">odd(n)=n%2;</syntaxhighlight> |
||
Alternately: |
Alternately: |
||
< |
<syntaxhighlight lang="parigp">odd(n)=bitand(n,1);</syntaxhighlight> |
||
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. |
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|PascalABC.NET}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
function IsOddRemainder(x: integer) := x mod 2 <> 0; |
|||
function IsEvenRemainder(x: integer) := x mod 2 = 0; |
|||
function IsOddBitwise(x: integer) := x and 1 = 1; |
|||
function IsEvenBitwise(x: integer) := x and 1 = 0; |
|||
begin |
|||
var x := 3; |
|||
Println(x.IsEven,x.IsOdd); // Standard Predicates |
|||
Println(IsEvenRemainder(x),IsOddRemainder(x)); |
|||
Println(IsEvenBitwise(x),IsOddBitwise(x)); |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
Built-in boolean function odd: |
Built-in boolean function odd: |
||
< |
<syntaxhighlight lang="pascal">isOdd := odd(someIntegerNumber);</syntaxhighlight> |
||
bitwise and: |
bitwise and: |
||
< |
<syntaxhighlight lang="pascal">function isOdd(Number: integer): boolean |
||
begin |
begin |
||
isOdd := boolean(Number and 1) |
isOdd := boolean(Number and 1) |
||
end;</ |
end;</syntaxhighlight> |
||
Dividing and multiplying by 2 and test on equality: |
Dividing and multiplying by 2 and test on equality: |
||
< |
<syntaxhighlight lang="pascal">function isEven(Number: integer): boolean |
||
begin |
begin |
||
isEven := (Number = ((Number div 2) * 2)) |
isEven := (Number = ((Number div 2) * 2)) |
||
end;</ |
end;</syntaxhighlight> |
||
Using built-in modulo |
Using built-in modulo |
||
< |
<syntaxhighlight lang="pascal">function isOdd(Number: integer): boolean |
||
begin |
begin |
||
isOdd := boolean(Number mod 2) |
isOdd := boolean(Number mod 2) |
||
end;</ |
end;</syntaxhighlight> |
||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
< |
<syntaxhighlight lang="perl">for(0..10){ |
||
print "$_ is ", qw(even odd)[$_ % 2],"\n"; |
print "$_ is ", qw(even odd)[$_ % 2],"\n"; |
||
}</ |
}</syntaxhighlight> |
||
or |
or |
||
< |
<syntaxhighlight lang="perl">print 6 % 2 ? 'odd' : 'even'; # prints even</syntaxhighlight> |
||
=={{header| |
=={{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. |
|||
Perl 6 doesn't have a built-in for this, but with subsets it's easy to define a predicate for it. |
|||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
<lang perl6>subset Even of Int where * %% 2; |
|||
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> |
|||
subset Odd of Int where * % 2; |
|||
<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: #004080;">mpz</span> <span style="color: #000000;">z</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_init</span><span style="color: #0000FF;">()</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;">" i odd even &&1 rmdr(2)\n"</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=-</span><span style="color: #000000;">5</span> <span style="color: #008080;">to</span> <span style="color: #000000;">5</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #7060A8;">mpz_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</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> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
i odd even &&1 rmdr(2) |
|||
-5: true false 1 -1 |
|||
-4: false true 0 0 |
|||
-3: true false 1 -1 |
|||
-2: false true 0 0 |
|||
-1: true false 1 -1 |
|||
0: false true 0 0 |
|||
1: true false 1 1 |
|||
2: false true 0 0 |
|||
3: true false 1 1 |
|||
4: false true 0 0 |
|||
5: true false 1 1 |
|||
</pre> |
|||
=={{header|Phixmonti}}== |
|||
say 1 ~~ Even; # false |
|||
<syntaxhighlight lang="phixmonti">-5 5 2 tolist for |
|||
say 1 ~~ Odd; # true |
|||
dup print " " print 2 mod if "Odd" else "Even" endif print nl |
|||
say 1.5 ~~ Odd # false ( 1.5 is not an Int )</lang> |
|||
endfor</syntaxhighlight> |
|||
=={{header|PHP}}== |
|||
<syntaxhighlight 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'; |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>even |
|||
odd |
|||
odd |
|||
even</pre> |
|||
=={{header|Picat}}== |
|||
{{works with|Picat}} |
|||
<syntaxhighlight lang="picat"> |
|||
% Bitwise and |
|||
is_even_bitwise(I) = cond(I /\ 1 == 0, true, false). |
|||
% Modulo |
|||
is_even_mod(I) = cond(I mod 2 == 0, true, false). |
|||
% Remainder |
|||
is_even_rem(I) = cond(I rem 2 == 0, true, false). |
|||
yes_or_no(B) = YN => |
|||
B = true, YN = "Yes"; |
|||
B = false, YN = "No". |
|||
main :- |
|||
foreach (I in 2..3) |
|||
printf("%d is even? %s\n", I, yes_or_no(is_even_bitwise(I))), |
|||
printf("%d is even? %s\n", I, yes_or_no(is_even_mod(I))), |
|||
printf("%d is even? %s\n", I, yes_or_no(is_even_rem(I))) |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 is even? Yes |
|||
2 is even? Yes |
|||
2 is even? Yes |
|||
3 is even? No |
|||
3 is even? No |
|||
3 is even? No |
|||
</pre> |
|||
Note: Picat has even/1 and odd/1 as built-ins predicates. |
|||
=={{header|PicoLisp}}== |
=={{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. |
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. |
||
< |
<syntaxhighlight lang="picolisp">: (bit? 1 3) |
||
-> 1 # Odd |
-> 1 # Odd |
||
: (bit? 1 4) |
: (bit? 1 4) |
||
-> NIL # Even</ |
-> NIL # Even</syntaxhighlight> |
||
=={{header|Pike}}== |
=={{header|Pike}}== |
||
< |
<syntaxhighlight lang="pike">> int i = 73; |
||
> (i&1); |
> (i&1); |
||
Result: 1 |
Result: 1 |
||
> i%2; |
> i%2; |
||
Result: 1</ |
Result: 1</syntaxhighlight> |
||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
< |
<syntaxhighlight lang="pl/i">i = iand(i,1)</syntaxhighlight> |
||
The result is 1 when i is odd, and 0 when i is even. |
The result is 1 when i is odd, and 0 when i is even. |
||
=={{header| |
=={{header|PL/M}}== |
||
In PL/M, even numbers are falsy and odd numbers are truthy, so no explicit test is needed |
|||
<lang PureBasic>;use last bit method |
|||
at all. |
|||
isOdd = i & 1 ;isOdd is non-zero if i is odd |
|||
isEven = i & 1 ! 1 ;isEven is non-zero if i is even |
|||
<syntaxhighlight lang="plm">100H: |
|||
;use modular method |
|||
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS; |
|||
isOdd = i % 2 ;isOdd is non-zero if i is odd |
|||
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT; |
|||
isEven = i % 2 ! 1 ;isEven is non-zero if i is even</lang> |
|||
PUT$CHAR: PROCEDURE (CH); DECLARE CH BYTE; CALL BDOS(2, CH); END PUT$CHAR; |
|||
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9, S); END PRINT; |
|||
DECLARE I BYTE; |
|||
DO I='0' TO '9'; |
|||
CALL PUT$CHAR(I); |
|||
CALL PRINT(.' IS $'); |
|||
IF I THEN |
|||
CALL PRINT(.'ODD$'); |
|||
ELSE |
|||
CALL PRINT(.'EVEN$'); |
|||
CALL PRINT(.(13,10,'$')); |
|||
END; |
|||
CALL EXIT; |
|||
EOF</syntaxhighlight> |
|||
{{out}} |
|||
<pre>0 IS EVEN |
|||
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</pre> |
|||
=={{header|Plain English}}== |
|||
The noodle comes with even and odd deciders. |
|||
<syntaxhighlight lang="plainenglish">To run: |
|||
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. |
|||
Shut down.</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
56 is even! |
|||
</pre> |
|||
=={{header|PowerShell}}== |
|||
{{works with|PowerShell|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]. |
|||
<syntaxhighlight lang="powershell"> |
|||
$IsOdd = -not ( [bigint]$N ).IsEven |
|||
$IsEven = ( [bigint]$N ).IsEven |
|||
</syntaxhighlight> |
|||
===Least significant digit=== |
|||
<syntaxhighlight lang="powershell"> |
|||
$IsOdd = [boolean]( $N -band 1 ) |
|||
$IsEven = [boolean]( $N -band 0 ) |
|||
</syntaxhighlight> |
|||
===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. |
|||
<syntaxhighlight lang="powershell"> |
|||
$IsOdd = $N % 2 -ne 0 |
|||
$IsEven = $N % 2 -eq 0 |
|||
</syntaxhighlight> |
|||
=={{header|Processing}}== |
|||
<syntaxhighlight lang="processing"> |
|||
boolean isEven(int i){ |
|||
return i%2 == 0; |
|||
} |
|||
boolean isOdd(int i){ |
|||
return i%2 == 1; |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|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: |
|||
<syntaxhighlight lang="prolog"> |
|||
even(N) :- |
|||
(between(0, inf, N); integer(N) ), |
|||
0 is N mod 2. |
|||
</syntaxhighlight> |
|||
===Least Significant Bit=== |
|||
If N is a positive integer, then lsb(N) is the offset of its least significant bit, so we could write: |
|||
<syntaxhighlight lang="prolog"> |
|||
odd(N) :- N = 0 -> false; 0 is lsb(abs(N)). |
|||
</syntaxhighlight> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
===Python: Using the least-significant bit method=== |
===Python: Using the least-significant bit method=== |
||
< |
<syntaxhighlight lang="python">>>> def is_odd(i): return bool(i & 1) |
||
>>> def is_even(i): return not is_odd(i) |
>>> def is_even(i): return not is_odd(i) |
||
Line 585: | Line 3,640: | ||
>>> [(j, is_even(j)) for j in range(10)] |
>>> [(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)] |
[(0, True), (1, False), (2, True), (3, False), (4, True), (5, False), (6, True), (7, False), (8, True), (9, False)] |
||
>>> </ |
>>> </syntaxhighlight> |
||
===Python: Using modular congruences=== |
===Python: Using modular congruences=== |
||
< |
<syntaxhighlight lang="python">>> def is_even(i): |
||
return (i % 2) == 0 |
return (i % 2) == 0 |
||
Line 595: | Line 3,650: | ||
>>> is_even(2) |
>>> is_even(2) |
||
True |
True |
||
>>></ |
>>></syntaxhighlight> |
||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery">[ 1 & ] is odd ( n --> b ) |
|||
[ odd not ] is even ( n --> b )</syntaxhighlight> |
|||
{{out}} |
|||
In the Quackery shell (REPL): |
|||
<pre> |
|||
/O> 10 even |
|||
... 10 odd |
|||
... 11 even |
|||
... 11 odd |
|||
... |
|||
Stack: 1 0 0 1 |
|||
</pre> |
|||
===Quackery: With Anonymous Mutual Recursion=== |
|||
Adapted from the example code at [[wp:Mutual recursion#Basic examples]], with the additional observation that the parity of a negative number is the same as the parity of its absolute value. |
|||
See also [https://rosettacode.org/wiki/Mutual_recursion#Quackery Mutual recursion#Quackery] and [https://rosettacode.org/wiki/Anonymous_recursion#Quackery Anonymous recursion#Quackery]. |
|||
<syntaxhighlight lang="quackery"> [ abs |
|||
' [ dup 0 = iff |
|||
[ 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 ) |
|||
11 times |
|||
[ i^ 5 - dup echo |
|||
say " is " |
|||
even iff [ $ "even" ] |
|||
else [ $ "odd" ] |
|||
echo$ say "." cr ] </syntaxhighlight> |
|||
{{out}} |
|||
<pre>-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.</pre> |
|||
=={{header|R}}== |
=={{header|R}}== |
||
< |
<syntaxhighlight lang="r">is.even <- function(x) !is.odd(x) |
||
is.odd <- function(x) intToBits(x)[1] == 1 |
is.odd <- function(x) intToBits(x)[1] == 1 |
||
#or |
#or |
||
is.odd <- function(x) x %% 2 == 1</ |
is.odd <- function(x) x %% 2 == 1</syntaxhighlight> |
||
=={{header|Racket}}== |
|||
With built in predicates: |
|||
<syntaxhighlight lang="racket">(even? 6) ; -> true |
|||
(even? 5) ; -> false |
|||
(odd? 6) ; -> false |
|||
(odd? 5) ; -> true </syntaxhighlight> |
|||
With modular arithmetic: |
|||
<syntaxhighlight lang="racket">(define (my-even? x) |
|||
(= (modulo x 2) 0)) |
|||
(define (my-odd? x) |
|||
(= (modulo x 2) 1))</syntaxhighlight> |
|||
With mutually recursive functions: |
|||
<syntaxhighlight lang="racket"> |
|||
(define (even-or-odd? i) |
|||
(letrec ([even? (λ (n) |
|||
(if (= n 0) |
|||
'even |
|||
(odd? (sub1 n))))] |
|||
[odd? (λ (n) |
|||
(if (= n 0) |
|||
'odd |
|||
(even? (sub1 n))))]) |
|||
(even? i))) |
|||
(even-or-odd? 100) ; => 'even |
|||
(even-or-odd? 101) ; => 'odd |
|||
</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="raku" line>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 )</syntaxhighlight> |
|||
=={{header|Rascal}}== |
=={{header|Rascal}}== |
||
< |
<syntaxhighlight lang="rascal">public bool isEven(int n) = (n % 2) == 0; |
||
public bool isOdd(int n) = (n % 2) == 1;</ |
public bool isOdd(int n) = (n % 2) == 1;</syntaxhighlight> |
||
Or with block quotes: |
Or with block quotes: |
||
< |
<syntaxhighlight lang="rascal">public bool isEven(int n){return (n % 2) == 0;} |
||
public bool isOdd(int n){return (n % 2) == 1;}</ |
public bool isOdd(int n){return (n % 2) == 1;}</syntaxhighlight> |
||
=={{header|RATFOR}}== |
|||
<syntaxhighlight lang="ratfor"> |
|||
program evenodd |
|||
integer a |
|||
write(*,101,ADVANCE="NO") |
|||
read(*,102)a |
|||
if (mod(a,2) .eq. 0) write(*,103)a |
|||
else write(*,104)a |
|||
101 format("Enter a number: ") |
|||
102 format(i7) |
|||
103 format(i7," Is Even.") |
|||
104 format(i7," Is Odd.") |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|Rapira}}== |
|||
<syntaxhighlight lang="rapira">fun is_even(n) |
|||
return (n /% 2) = 0 |
|||
end</syntaxhighlight> |
|||
=={{header|Red}}== |
|||
<syntaxhighlight lang="red">Red [ |
|||
date: 2021-10-24 |
|||
red-version: 0.6.4 |
|||
description: "Test whether an integer is even or odd." |
|||
] |
|||
print even? 10 ;== true |
|||
print odd? 10 ;== false</syntaxhighlight> |
|||
=={{header|ReScript}}== |
|||
<syntaxhighlight lang="rescript">let is_even = d => mod(d, 2) == 0 |
|||
let is_odd = d => mod(d, 2) != 0</syntaxhighlight> |
|||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
Programming note: division by <big> '''1''' </big> (one) in REXX is a way to normalize a number: |
|||
<lang rexx>/*REXX program displays if an integer is even or odd. */ |
|||
:::* by removing a superfluous leading '''+''' sign |
|||
numeric digits 1000 /*handle most big 'uns from the CL*/ |
|||
:::* by removing superfluous leading zeroes |
|||
parse arg x _ . /*get arg(s) from the command line*/ |
|||
:::* by removing superfluous trailing zeroes |
|||
if x=='' then call terr 'no input' |
|||
:::* by removing a trailing decimal point |
|||
if _\=='' | arg()\==1 then call terr 'too many arguments:' arg(1) |
|||
:::* possible converting an exponentiated number |
|||
if \datatype(x,'N') then call terr x "isn't numeric" |
|||
:::* possible rounding the number to the current ''digits'' |
|||
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.*/ |
|||
'''Programming note''': the last method is the fastest method in REXX to determine oddness/evenness. |
|||
/*──────────────────────────────────TERR subroutine─────────────────────*/ |
|||
<br>It requires a sparse stemmed array '''!.''' be defined in the program's prologue (or elsewhere). |
|||
terr: say; say '***error!***'; say; say arg(1); say; exit 13</lang> |
|||
<br>This method gets its speed from ''not'' using any BIF and ''not'' performing any (remainder) division. |
|||
'''output''' when using the input of <tt> 0 </tt> |
|||
<pre style="height:10ex;overflow:scroll"> |
|||
'''Some notes on programming styles''': |
|||
─────────────modulo method────────────── |
|||
If (execution) speed isn't an issue, then the 1<sup>st</sup> test method |
|||
<br>shown would be the simplest (in terms of coding the concisest/tightest/smallest code). The other test |
|||
<br>methods differ mostly in programming techniques, mostly depending on the REXX programmer's style. |
|||
<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 (and it requires additional REXX statement baggage). |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
'''output''' when using the input of: <tt> 0 </tt> |
|||
<pre> |
|||
═════════════════════using the remainder method (oddness)══════════════════════ |
|||
0 is even |
0 is even |
||
══════════════using the rightmost digit using BIF (not evenness)═══════════════ |
|||
───test rightmost digit for evenness──── |
|||
0 is even |
0 is even |
||
════════════════using the rightmost digit using BIF (evenness)═════════════════ |
|||
────test rightmost digit for oddness──── |
|||
0 is even |
0 is even |
||
═════════════using the even rightmost digit using array (evenness)═════════════ |
|||
───────────test rightmost bit─────────── |
|||
0 is even |
0 is even |
||
</pre> |
|||
'''out0put''' when using the input of: <tt> 9876543210987654321098765432109876543210987654321 </tt> |
|||
<pre style="height:20ex;overflow:scroll"> |
|||
─────────────modulo method────────────── |
|||
9876543210987654321098765432109876543210987654321 is odd |
|||
════════using the remainder of division via function invoke (evenness)═════════ |
|||
───test rightmost digit for evenness──── |
|||
0 is even |
|||
9876543210987654321098765432109876543210987654321 is odd |
|||
═════════using the remainder of division via function invoke (oddness)═════════ |
|||
────test rightmost digit for oddness──── |
|||
0 is even |
|||
9876543210987654321098765432109876543210987654321 is odd |
|||
═══════════════using the rightmost digit using BIF (not oddness)═══════════════ |
|||
───────────test rightmost bit─────────── |
|||
0 is even |
|||
9876543210987654321098765432109876543210987654321 is odd |
|||
</pre> |
|||
'''output''' when using the input of <tt> 00067.00 </tt> |
|||
<pre style="height:30ex;overflow:scroll"> |
|||
────────test using modulo method──────── |
|||
00067.00 is odd |
|||
══════════════════using the rightmost (binary) bit (oddness)═══════════════════ |
|||
───test rightmost digit for evenness──── |
|||
0 is even |
|||
═══════════════using the parse statement using BIF (not oddness)═══════════════ |
|||
────test rightmost digit for oddness──── |
|||
0 is even |
|||
═══════════════using the parse statement using array (evenness)════════════════ |
|||
───────────test rightmost bit─────────── |
|||
0 is even |
|||
</pre> |
</pre> |
||
'''output''' when using the input of: <tt> |
'''output''' when using the input of: <tt> 9876543210987654321098765432109876543210987654321 </tt> |
||
<pre> |
|||
<pre style="overflow:scroll"> |
|||
═════════════════════using the remainder method (oddness)══════════════════════ |
|||
─────────────modulo method────────────── |
|||
9876543210987654321098765432109876543210987654321 is odd |
|||
-9411 is odd |
|||
(rest of the output was elided.) |
|||
───test rightmost digit for evenness──── |
|||
</pre> |
|||
-9411 is odd |
|||
'''output''' when using the input of: <tt> .6821e4 </tt> |
|||
<pre> |
|||
═════════════════════using the remainder method (oddness)══════════════════════ |
|||
.8621e4 is odd |
|||
(rest of the output was elided.) |
|||
────test rightmost digit for oddness──── |
|||
</pre> |
|||
-9411 is odd |
|||
'''output''' when using the input of: <tt> -9411 </tt> |
|||
───────────test rightmost bit─────────── |
|||
<pre> |
|||
═════════════════════using the remainder method (oddness)══════════════════════ |
|||
-9411 is odd |
-9411 is odd |
||
(rest of the output was elided.) |
|||
</pre> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight 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 |
|||
</syntaxhighlight> |
|||
=={{header|RPL}}== |
|||
To test oddity of real numbers (floating point numbers) : |
|||
≪ 2 MOD ≫ ‘ODD?’ STO |
|||
To test oddity of binary integers (unsigned integers) : |
|||
≪ #1 AND #1 ≠ ≫ ‘BODD?’ STO |
|||
To test oddity without caring of the data type : |
|||
≪ IF DUP TYPE THEN #1 AND #1 ≠ ELSE 2 MOD END ≫ |
|||
{{in}} |
|||
<pre> |
|||
47 ODD? |
|||
#Fh BODD? |
|||
</pre> |
|||
{{out}} |
|||
<pre> |
|||
2: 1 |
|||
1: 1 |
|||
</pre> |
</pre> |
||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
In Ruby, integers behave like objects, so they respond to methods like : 5.even? resulting to false |
|||
Ruby 1.8.7 added Integer#even? and Integer#odd? as new methods. |
|||
<syntaxhighlight lang="ruby">print "evens: " |
|||
{{works with|Ruby|1.8.7}} |
|||
p -5.upto(5).select(&:even?) |
|||
<lang ruby>print "evens: " |
|||
p -5.upto(5).select {|n| n.even?} |
|||
print "odds: " |
print "odds: " |
||
p -5.upto(5).select |
p -5.upto(5).select(&:odd?)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>evens: [-4, -2, 0, 2, 4] |
<pre>evens: [-4, -2, 0, 2, 4] |
||
odds: [-5, -3, -1, 1, 3, 5]</pre> |
odds: [-5, -3, -1, 1, 3, 5]</pre> |
||
Other ways to test even-ness: |
Other ways to test even-ness: |
||
< |
<syntaxhighlight lang="ruby">n & 1 == 0 |
||
quotient, remainder = n.divmod(2); remainder == 0 |
quotient, remainder = n.divmod(2); remainder == 0 |
||
Line 725: | Line 4,001: | ||
# You can use the bracket operator to access the i'th bit |
# You can use the bracket operator to access the i'th bit |
||
# of a Fixnum or Bignum (i = 0 means least significant bit) |
# of a Fixnum or Bignum (i = 0 means least significant bit) |
||
n[0].zero?</ |
n[0].zero?</syntaxhighlight> |
||
=={{header|Run BASIC}}== |
|||
=={{header|Rust}}== |
|||
<lang runbasic>for i = 1 to 10 |
|||
Checking the least significant digit: |
|||
if i and 1 then print i;" is odd" else print i;" is even" |
|||
<syntaxhighlight lang="rust">let is_odd = |x: i32| x & 1 == 1; |
|||
next i</lang> |
|||
let is_even = |x: i32| x & 1 == 0;</syntaxhighlight> |
|||
<pre> |
|||
1 is odd |
|||
Using modular congruences: |
|||
2 is even |
|||
<syntaxhighlight lang="rust">let is_odd = |x: i32| x % 2 != 0; |
|||
3 is odd |
|||
let is_even = |x: i32| x % 2 == 0;</syntaxhighlight> |
|||
4 is even |
|||
5 is odd |
|||
=={{header|Scala}}== |
|||
6 is even |
|||
<syntaxhighlight lang="scala">def isEven( v:Int ) : Boolean = v % 2 == 0 |
|||
7 is odd |
|||
def isOdd( v:Int ) : Boolean = v % 2 != 0</syntaxhighlight> |
|||
8 is even |
|||
Accept any numeric type as an argument: |
|||
9 is odd |
|||
<syntaxhighlight lang="scala">def isEven( v:Number ) : Boolean = v.longValue % 2 == 0 |
|||
10 is even |
|||
def isOdd( v:Number ) : Boolean = v.longValue % 2 != 0</syntaxhighlight> |
|||
</pre> |
|||
{{out}} |
|||
<pre>isOdd( 81 ) // Results in true |
|||
isEven( BigInt(378) ) // Results in true |
|||
isEven( 234.05003513013145 ) // Results in true</pre> |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
<code>even?</code> and <code>odd?</code> functions are built-in (R<sup>4</sup>RS, R<sup>5</sup>RS, and R<sup>6</sup>RS): |
<code>even?</code> and <code>odd?</code> functions are built-in (R<sup>4</sup>RS, R<sup>5</sup>RS, and R<sup>6</sup>RS): |
||
< |
<syntaxhighlight lang="scheme">> (even? 5) |
||
#f |
#f |
||
> (even? 42) |
> (even? 42) |
||
Line 752: | Line 4,032: | ||
#t |
#t |
||
> (odd? 42) |
> (odd? 42) |
||
#f</ |
#f</syntaxhighlight> |
||
=={{header|sed}}== |
|||
<syntaxhighlight lang="sed">s/[02468]$/& is even/ |
|||
s/[13579]$/& is odd/</syntaxhighlight> |
|||
{{out}} |
|||
<pre>$ seq -18 7 17 | sed -f even_or_odd.sed |
|||
-18 is even |
|||
-11 is odd |
|||
-4 is even |
|||
3 is odd |
|||
10 is even |
|||
17 is odd</pre> |
|||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
Test whether an integer or bigInteger is odd: |
Test whether an integer or bigInteger is odd: |
||
<lang |
<syntaxhighlight lang="seed7">odd(aNumber)</syntaxhighlight> |
||
Test whether an integer or bigInteger is even: |
Test whether an integer or bigInteger is even: |
||
<lang |
<syntaxhighlight lang="seed7">not odd(aNumber)</syntaxhighlight> |
||
=={{header|SenseTalk}}== |
|||
<syntaxhighlight lang="sensetalk"> |
|||
set num to random of 100 -- start with a random number from 1 to 100 |
|||
// use the 'is a' operator to test the value |
|||
if num is an odd number then put num & " is odd" |
|||
// see if num is divisible by 2 |
|||
if num is divisible by 2 then put num & " is even (is divisible by 2)" |
|||
// 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)" |
|||
</syntaxhighlight> |
|||
=={{header|SequenceL}}== |
|||
<syntaxhighlight lang="sequencel">even(x) := x mod 2 = 0; |
|||
odd(x) := x mod 2 = 1;</syntaxhighlight> |
|||
{{out}} |
|||
<pre style="height: 25ex; overflow: scroll"> |
|||
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] |
|||
</pre> |
|||
=={{header|SETL}}== |
|||
SETL provides built-in <tt>even</tt> and <tt>odd</tt> functions. This short program illustrates their use. |
|||
<syntaxhighlight lang="setl">xs := {1..10}; |
|||
evens := {x in xs | even( x )}; |
|||
odds := {x in xs | odd( x )}; |
|||
print( evens ); |
|||
print( odds );</syntaxhighlight> |
|||
{{out}} |
|||
<pre>{2 4 6 8 10} |
|||
{1 3 5 7 9}</pre> |
|||
=={{header|Shen}}== |
|||
Mutual Recursion: |
|||
<syntaxhighlight lang="shen">(define even? |
|||
0 -> true |
|||
X -> (odd? (- X 1))) |
|||
(define odd? |
|||
0 -> false |
|||
X -> (even? (- X 1)))</syntaxhighlight> |
|||
Modulo: |
|||
<syntaxhighlight lang="shen">(define even? X -> (= 0 (shen.mod X 2))) |
|||
(define odd? X -> (not (= 0 (shen.mod X 2))))</syntaxhighlight> |
|||
=={{header|Sidef}}== |
|||
Built-in methods: |
|||
<syntaxhighlight lang="ruby">var n = 42; |
|||
say n.is_odd; # false |
|||
say n.is_even; # true</syntaxhighlight> |
|||
Checking the last significant digit: |
|||
<syntaxhighlight lang="ruby">func is_odd(n) { n&1 == 1 }; |
|||
func is_even(n) { n&1 == 0 };</syntaxhighlight> |
|||
Using modular congruences: |
|||
<syntaxhighlight lang="ruby">func is_odd(n) { n%2 == 1 }; |
|||
func is_even(n) { n%2 == 0 };</syntaxhighlight> |
|||
=={{header|Smalltalk}}== |
|||
Using the built in methods on Number class: |
|||
<syntaxhighlight lang="smalltalk">5 even |
|||
5 odd</syntaxhighlight> |
|||
even is implemented as follows: |
|||
<syntaxhighlight lang="smalltalk">Number>>even |
|||
^((self digitAt: 1) bitAnd: 1) = 0 |
|||
</syntaxhighlight> |
|||
=={{header|SNOBOL4}}== |
|||
{{works with|Macro SNOBOL4 in C}} |
|||
{{works with|Spitbol}} |
|||
{{Works with|SNOBOL4+}} |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
{{output}}<pre>-2 is even |
|||
-1 is odd |
|||
0 is even |
|||
1 is odd |
|||
2 is even |
|||
</pre> |
|||
=={{header|SNUSP}}== |
=={{header|SNUSP}}== |
||
<syntaxhighlight lang="snusp"> |
|||
<lang SNUSP> |
|||
$====!/?\==even# |
$====!/?\==even# |
||
- - |
- - |
||
#odd==\?/ |
#odd==\?/ |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|SPL}}== |
|||
<syntaxhighlight lang="spl">> n, 0..9 |
|||
? #.even(n), #.output(n," even") |
|||
? #.odd(n), #.output(n," odd") |
|||
<</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0 even |
|||
1 odd |
|||
2 even |
|||
3 odd |
|||
4 even |
|||
5 odd |
|||
6 even |
|||
7 odd |
|||
8 even |
|||
9 odd |
|||
</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)". |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
INT CASE |
|||
---------- ---- |
|||
-1 Odd |
|||
0 Even |
|||
1 Odd |
|||
2 Even</pre> |
|||
=={{header|SSEM}}== |
|||
The SSEM doesn't provide <tt>AND</tt>, but for once the instruction set does allow the problem to be solved quite elegantly (albeit extravagantly slowly). Load the value of <math>n</math> into storage address 15. The first three instructions test whether <math>n</math> 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 <math>n</math> 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 <tt>Sub.</tt> 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 <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. |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
=={{header|Standard ML}}== |
|||
<syntaxhighlight 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;</syntaxhighlight> |
|||
=={{header|Stata}}== |
|||
<syntaxhighlight lang="stata">mata |
|||
function iseven(n) { |
|||
return(mod(n,2)==0) |
|||
} |
|||
function isodd(n) { |
|||
return(mod(n,2)==1) |
|||
} |
|||
end</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
<syntaxhighlight 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 |
|||
}</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
<syntaxhighlight lang="swift"> |
|||
// Swift has Int.isMultiple(of:Int) -> Bool |
|||
var isEven: (_:Int) -> Bool = {$0.isMultiple(of: 2)} |
|||
</syntaxhighlight> |
|||
=={{header|Symsyn}}== |
|||
<syntaxhighlight lang="symsyn"> |
|||
n : 23 |
|||
if n bit 0 |
|||
'n is odd' [] |
|||
else |
|||
'n is even' [] |
|||
</syntaxhighlight> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
< |
<syntaxhighlight lang="tcl">package require Tcl 8.5 |
||
# Bitwise test is the most efficient |
# Bitwise test is the most efficient |
||
Line 776: | Line 4,293: | ||
puts " # O E" |
puts " # O E" |
||
puts 24:[expr isOdd(24)],[expr isEven(24)] |
puts 24:[expr isOdd(24)],[expr isEven(24)] |
||
puts 49:[expr isOdd(49)],[expr isEven(49)]</ |
puts 49:[expr isOdd(49)],[expr isEven(49)]</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 783: | Line 4,300: | ||
49:1,0 |
49:1,0 |
||
</pre> |
</pre> |
||
=={{header|TI-57}}== |
|||
This routine returns the remainder of the division by 2 of the number in the display register. It is therefore a kind of is_odd(x) function. |
|||
Lbl 9 |
|||
/ |
|||
2 |
|||
- |
|||
CE |
|||
Int |
|||
= |
|||
× |
|||
2 |
|||
= |
|||
INV SBR |
|||
=={{header|TUSCRIPT}}== |
=={{header|TUSCRIPT}}== |
||
< |
<syntaxhighlight lang="tuscript">$$ MODE TUSCRIPT |
||
LOOP n=-5,5 |
LOOP n=-5,5 |
||
x=MOD(n,2) |
x=MOD(n,2) |
||
Line 794: | Line 4,325: | ||
PRINT n," is odd" |
PRINT n," is odd" |
||
ENDSELECT |
ENDSELECT |
||
ENDLOOP</ |
ENDLOOP</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 808: | Line 4,339: | ||
4 is even |
4 is even |
||
5 is odd |
5 is odd |
||
</pre> |
|||
=={{header|UNIX Shell}}== |
|||
<syntaxhighlight lang="sh">is_even() { |
|||
return $(($1 & 1)) |
|||
}</syntaxhighlight> |
|||
=={{header|Ursa}}== |
|||
<syntaxhighlight 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</syntaxhighlight> |
|||
Output: |
|||
<pre>123 |
|||
odd</pre> |
|||
=={{header|உயிர்/Uyir}}== |
|||
<syntaxhighlight lang="உயிர்/uyir">முதன்மை என்பதின் வகை எண் பணி {{ |
|||
எ இன் வகை எண்{$5} = 0; |
|||
படை வகை சரம்; |
|||
"எண்ணைக் கொடுங்கள்? ") ஐ திரை.இடு; |
|||
எ = எண்{$5} ஐ விசை.எடு; |
|||
ஒருக்கால் (எ.இருமம்(0) == 1) ஆகில் { |
|||
படை = "ஒற்றை"; |
|||
} இல்லையேல் { |
|||
படை = "இரட்டை "; |
|||
} |
|||
{எ, " ஒரு ", படை, "ப்படை எண் ஆகும்"} என்பதை திரை.இடு; |
|||
முதன்மை = 0; |
|||
}};</syntaxhighlight> |
|||
=={{header|Verilog}}== |
|||
<syntaxhighlight lang="verilog">module main; |
|||
integer i; |
|||
initial begin |
|||
for (i = 1; i <= 10; i = i+1) begin |
|||
if (i % 2 == 0) $display(i, " is even"); |
|||
else $display(i, " is odd"); |
|||
end |
|||
$finish ; |
|||
end |
|||
endmodule</syntaxhighlight> |
|||
=={{header|V (Vlang)}}== |
|||
<syntaxhighlight lang="v (vlang)">fn test(n i64) { |
|||
print('Testing integer $n') |
|||
if n&1 == 0 { |
|||
print(' even') |
|||
}else{ |
|||
print(' odd') |
|||
} |
|||
if n%2 == 0 { |
|||
println(' even') |
|||
}else{ |
|||
println(' odd') |
|||
} |
|||
} |
|||
fn main(){ |
|||
test(-2) |
|||
test(-1) |
|||
test(0) |
|||
test(1) |
|||
test(2) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
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 |
|||
</pre> |
|||
=={{header|WDTE}}== |
|||
<syntaxhighlight lang="wdte">let s => import 'stream'; |
|||
let str => import 'strings'; |
|||
let evenOrOdd n => ( |
|||
let even n => == (% n 2) 0; |
|||
switch n { |
|||
even => 'even'; |
|||
default => 'odd'; |
|||
}; |
|||
); |
|||
s.range 10 |
|||
-> s.map (@ s n => str.format '{} is {}.' n (evenOrOdd n)) |
|||
-> s.map (io.writeln io.stdout) |
|||
-> s.drain;</syntaxhighlight> |
|||
=={{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). |
|||
<syntaxhighlight lang="webassembly">(module |
|||
;; function isOdd: returns 1 if its argument is odd, 0 if it is even. |
|||
(func $isOdd (param $n i32) (result i32) |
|||
get_local $n |
|||
i32.const 1 |
|||
i32.and ;; computes (n & 1), i.e. returns low bit of n |
|||
) |
|||
(export "isOdd" (func $isOdd)) |
|||
)</syntaxhighlight> |
|||
=={{header|Wren}}== |
|||
{{libheader|Wren-fmt}} |
|||
<syntaxhighlight lang="wren">import "./fmt" for Fmt |
|||
var isEven1 = Fn.new { |i| i & 1 == 0 } |
|||
var isEven2 = Fn.new { |i| i % 2 == 0 } |
|||
var tests = [10, 11, 0, 57, 34, -23, -42] |
|||
System.print("Tests : %(Fmt.v("s", -4, tests, 0, " ", ""))") |
|||
var res1 = tests.map { |t| isEven1.call(t) ? "even" : "odd" }.toList |
|||
System.print("Method 1 : %(Fmt.v("s", -4, res1, 0, " ", ""))") |
|||
var res2 = tests.map { |t| isEven2.call(t) ? "even" : "odd" }.toList |
|||
System.print("Method 2 : %(Fmt.v("s", -4, res2, 0, " ", ""))")</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Tests : 10 11 0 57 34 -23 -42 |
|||
Method 1 : even odd even odd even odd even |
|||
Method 2 : even odd even odd even odd even |
|||
</pre> |
|||
=={{header|x86-64 Assembly}}== |
|||
<syntaxhighlight lang="x86_64 assembly"> |
|||
evenOdd: |
|||
mov rax,1 |
|||
and rax,rdi |
|||
ret |
|||
</syntaxhighlight> |
|||
=={{header|XBS}}== |
|||
<syntaxhighlight lang="xbs">#> |
|||
Typed XBS |
|||
evenOrOdd function |
|||
true = even |
|||
false = odd |
|||
<# |
|||
func evenOrOdd(a:number=0){ |
|||
send a%2==0; |
|||
} |
|||
set arr:array = [0,1,2,3,4,5,6,7,9,10]; |
|||
foreach(v of arr){ |
|||
log(v+" is even? "+evenOrOdd(v)) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0 is even? true |
|||
1 is even? false |
|||
2 is even? true |
|||
3 is even? false |
|||
4 is even? true |
|||
5 is even? false |
|||
6 is even? true |
|||
7 is even? false |
|||
9 is even? false |
|||
10 is even? true |
|||
</pre> |
|||
=={{header|xEec}}== |
|||
<syntaxhighlight lang="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 |
|||
</syntaxhighlight> |
|||
=={{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). |
|||
<syntaxhighlight lang="lisp">(defun my-evenp (x) |
|||
(= (logand x 1) 0) ) |
|||
(defun my-oddp (x) |
|||
(/= (logand x 1) 0) )</syntaxhighlight> |
|||
=={{header|Xojo}}== |
|||
<syntaxhighlight lang="vb"> |
|||
For num As Integer = 1 To 5 |
|||
If num Mod 2 = 0 Then |
|||
MsgBox(Str(num) + " is even.") |
|||
Else |
|||
MsgBox(Str(num) + " is odd.") |
|||
End If |
|||
Next |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
1 is odd. |
|||
2 is even. |
|||
3 is odd. |
|||
4 is even. |
|||
5 is odd. |
|||
</pre> |
</pre> |
||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">include c:\cxpl\codes; |
||
int I; |
int I; |
||
[for I:= -4 to +3 do |
[for I:= -4 to +3 do |
||
[IntOut(0, I); |
[IntOut(0, I); |
||
Text(0, if I&1 then " is odd " else " is even "); |
Text(0, if I&1 then " is odd " else " is even "); |
||
Text(0, if rem(I/2)#0 then "odd" else "even"); |
Text(0, if rem(I/2)#0 then "odd" else "even"); |
||
CrLf(0); |
CrLf(0); |
||
]; |
]; |
||
]</ |
]</syntaxhighlight> |
||
{{out}} |
|||
Output: |
|||
<pre> |
<pre> |
||
-4 is even even |
-4 is even even |
||
Line 831: | Line 4,569: | ||
2 is even even |
2 is even even |
||
3 is odd odd |
3 is odd odd |
||
</pre> |
|||
=={{header|Z80 Assembly}}== |
|||
Z80 Assembly has a few ways of testing if a number is even or odd: |
|||
===RRC=== |
|||
A right rotate will set the carry if the register's value is odd and clear it if it's even. This does alter the contents of the register, so only use this method if you don't need to remember the number being tested after getting the results of the test. This is the fastest way the Z80 can test a value for even or odd, but only when testing the accumulator <tt>A</tt> |
|||
<syntaxhighlight lang="z80">rrca |
|||
jp nc,isEven</syntaxhighlight> |
|||
===SRA/SRL=== |
|||
In similar vein, there are also shift instructions. The arithmetic shift instruction retains the sign bit (bit 7) of the operand in question, while the logical shift sets bit 7 to 0. |
|||
<syntaxhighlight lang="z80">sra a |
|||
jp nc,isEven</syntaxhighlight> |
|||
===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. |
|||
<syntaxhighlight lang="z80">and &01 |
|||
jp z,isEven</syntaxhighlight> |
|||
===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! |
|||
<syntaxhighlight lang="z80">bit 0,c |
|||
jp z,C_IS_EVEN</syntaxhighlight> |
|||
=={{header|zkl}}== |
|||
<syntaxhighlight lang="zkl">[-3..4].pump(fcn(n){ println(n," is ",n.isEven and "even" or "odd") })</syntaxhighlight> |
|||
Ints have isEven and isOdd properties. pump, in this case, is the same as apply/map without aggregating a result. |
|||
{{out}} |
|||
<pre> |
|||
-3 is odd |
|||
-2 is even |
|||
-1 is odd |
|||
0 is even |
|||
1 is odd |
|||
2 is even |
|||
3 is odd |
|||
4 is even |
|||
</pre> |
|||
<syntaxhighlight lang="zkl">[-3..4].apply("isEven").println();</syntaxhighlight> |
|||
{{out}} |
|||
<pre>L(False,True,False,True,False,True,False,True)</pre> |
|||
=={{header|Zoea}}== |
|||
<syntaxhighlight lang="zoea"> |
|||
program: even_or_odd |
|||
case: 1 |
|||
input: 2 |
|||
output: even |
|||
case: 2 |
|||
input: 4 |
|||
output: even |
|||
case: 3 |
|||
input: 1 |
|||
output: odd |
|||
case: 4 |
|||
input: 7 |
|||
output: odd |
|||
</syntaxhighlight> |
|||
=={{header|Zoea Visual}}== |
|||
[http://zoea.co.uk/examples/zv-rc/Even_or_odd.png Even or odd] |
|||
=={{header|zonnon}}== |
|||
<syntaxhighlight lang="zonnon"> |
|||
module Main; |
|||
var |
|||
x: integer; |
|||
s: set; |
|||
begin |
|||
x := 10;writeln(x:3," is odd?",odd(x)); |
|||
s := set(s);writeln(x:3," is odd?",0 in s); (* check right bit *) |
|||
x := 11;writeln(x:3," is odd?",odd(x)); |
|||
s := set(x);writeln(x:3," is odd?",0 in s); (* check right bit *) |
|||
end Main. |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
10 is odd? false |
|||
10 is odd? false |
|||
11 is odd? true |
|||
11 is odd? true |
|||
</pre> |
</pre> |
Latest revision as of 12:42, 9 August 2024
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
- 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
}:s:|=<:2:x~#:e:=/~%~<:20:~$=<:73:x<:69:~$~$~<:20:~$=^:o:<:65:
x<:76:=$=$~$<:6E:~$<:a:~$^:s:}:o:<:6F:x<:64:x~$~$$<:a:~$^:s:
11l
F is_even(i)
R i % 2 == 0
F is_odd(i)
R i % 2 == 1
6502 Assembly
.lf evenodd6502.lst
.cr 6502
.tf evenodd6502.obj,ap1
;------------------------------------------------------
; Even or Odd for the 6502 by barrym95838 2014.12.10
; Thanks to sbprojects.com for a very nice assembler!
; The target for this assembly is an Apple II with
; mixed-case output capabilities. Apple IIs like to
; work in '+128' ascii, and this version is tailored
; to that preference.
; Tested and verified on AppleWin 1.20.0.0
;------------------------------------------------------
; Constant Section
;
CharIn = $fd0c ;Specific to the Apple II
CharOut = $fded ;Specific to the Apple II
;------------------------------------------------------
; The main program
;
main ldy #sIntro-sbase
jsr puts ;Print Intro
loop jsr CharIn ;Get a char from stdin
cmp #$83 ;Ctrl-C?
beq done ; yes: end program
jsr CharOut ;Echo char
ldy #sOdd-sbase ;Pre-load odd string
lsr ;LSB of char to carry flag
bcs isodd
ldy #sEven-sbase
isodd jsr puts ;Print appropriate response
beq loop ;Always taken
; Output NUL-terminated string @ offset Y
;
puts lda sbase,y ;Get string char
beq done ;Done if NUL
jsr CharOut ;Output the char
iny ;Point to next char
bne puts ;Loop up to 255 times
done rts ;Return to caller
;------------------------------------------------------
; String Constants (in '+128' ascii, Apple II style)
;
sbase: ;String base address
sIntro .az -"Hit any key (Ctrl-C to quit):",-#13
sEven .az -" is even.",-#13
sOdd .az -" is odd.",-#13
;------------------------------------------------------
.en
68000 Assembly
Non-Destructive
BTST D0,#1
BNE isOdd
;else, is even.
Destructive
AND.B D0,#1
BNE isOdd
;else, is even.
ROR.B D0,#1
BCS isOdd
;else, is even.
ROXR.B D0,#1
BCS isOdd
;else, is even.
LSR.B D0,#1
BCS isOdd
;else, is even.
ASR.B D0,#1
BCS isOdd
;else, is even.
You can also use BCLR
,BSET
, and BCHG
in the same way you use BTST
, as all of them copy the affected bit to the zero flag. BCLR
,BSET
, and BCHG
will change the value of that bit after the test, so keep that in mind.
8080 Assembly
The instruction that's doing all the work here is rar
, 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
set if odd and clear if even.
CMDLIN: equ 80h ; Location of CP/M command line argument
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
mov a,m
add l ; Look up last character (digit)
mov l,a
mov a,m ; Retrieve low digit
rar ; Rotate low bit into carry flag
mvi c,puts ; Prepare to print string
lxi d,odd ; If carry is set, then the number is odd
jc 5 ; So print 'odd'
lxi d,even ; Otherwise, the number is even
jmp 5 ; So print 'even'
even: db 'Even$' ; Strings
odd: db 'Odd$'
- Output:
A>evenodd 0 Even A>evenodd 1 Odd A>evenodd 2 Even A>evenodd 3141592653 Odd A>
8086 Assembly
Non-Destructive
test ax,1
jne isOdd
;else, is even
Destructive
and ax,1
jne isOdd
;else, is even
ror ax,1
jc isOdd
;else, is even
rcr ax,1
jc isOdd
;else, is even
sar ax,1
jc isOdd
;else, is even
shr ax,1
jc isOdd
;else, is even
The DIV
instruction can also work, but using DIV
to divide by 2 is a waste of time, since the shift and rotate commands above do it faster.
8th
The 'mod' method also works, but the bit method is fastest.
: odd? \ n -- boolean
dup 1 n:band 1 n:= ;
: even? \ n -- boolean
odd? not ;
This could be shortened to:
: even? \ n -- f
1 n:band not ;
: odd? \ n -- f
even? not ;
AArch64 Assembly
/* ARM assembly AARCH64 Raspberry PI 3B and android arm 64 bits*/
/* program oddEven64.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResultOdd: .asciz " @ is odd (impair) \n"
sMessResultEven: .asciz " @ is even (pair) \n"
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: //entry of program
mov x0,#5
bl testOddEven
mov x0,#12
bl testOddEven
mov x0,#2021
bl testOddEven
100: //standard end of the program
mov x0, #0 //return code
mov x8, #EXIT //request to exit program
svc #0 //perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsMessResultOdd: .quad sMessResultOdd
qAdrsMessResultEven: .quad sMessResultEven
qAdrsZoneConv: .quad sZoneConv
/***************************************************/
/* test if number is odd or even */
/***************************************************/
// x0 contains à number
testOddEven:
stp x1,lr,[sp,-16]! // save registres
tst x0,#1 //test bit 0 to one
beq 1f //if result are all zéro, go to even
ldr x1,qAdrsZoneConv //else display odd message
bl conversion10 //call decimal conversion
ldr x0,qAdrsMessResultOdd
ldr x1,qAdrsZoneConv //insert value conversion in message
bl strInsertAtCharInc
bl affichageMess
b 100f
1:
ldr x1,qAdrsZoneConv
bl conversion10 //call decimal conversion
ldr x0,qAdrsMessResultEven
ldr x1,qAdrsZoneConv //insert conversion in message
bl strInsertAtCharInc
bl affichageMess
100:
ldp x1,lr,[sp],16 // restaur des 2 registres
ret
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
- Output:
5 is odd (impair) 12 is even (pair) 2021 is odd (impair)
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|
)
)
)
).
- 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
Action!
PROC OddByAnd(INT v)
IF (v&1)=0 THEN
Print(" even")
ELSE
Print(" odd ")
FI
RETURN
PROC OddByMod(INT v)
;MOD doesn't work properly for negative numbers in Action!
IF v<0 THEN
v=-v
FI
IF v MOD 2=0 THEN
Print(" even")
ELSE
Print(" odd ")
FI
RETURN
PROC OddByDiv(INT v)
INT d
d=(v/2)*2
IF v=d THEN
Print(" even")
ELSE
Print(" odd ")
FI
RETURN
PROC Main()
INT i
FOR i=-4 TO 4
DO
PrintF("%I is",i)
OddByAnd(i)
OddByMod(i)
OddByDiv(i)
PutE()
OD
RETURN
- Output:
Screenshot from Atari 8-bit computer
-4 is even even even -3 is odd odd odd -2 is even even even -1 is odd odd odd 0 is even even even 1 is odd odd odd 2 is even even even 3 is odd odd odd 4 is even even even
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;
Agda
module EvenOrOdd where
open import Data.Bool using (Bool; false; true)
open import Data.Nat using (ℕ; zero; suc)
even : ℕ → Bool
odd : ℕ → Bool
even zero = true
even (suc n) = odd n
odd zero = false
odd (suc n) = even n
Aime
if (x & 1) {
# x is odd
} else {
# x is even
}
ALGOL 68
# 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 ) )
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
% RETURN 1 IF EVEN, OTHERWISE 0 %
INTEGER FUNCTION EVEN(I);
INTEGER I;
BEGIN
EVEN := 1 - (I - 2 * (I / 2));
END;
% TEST THE ROUTINE %
INTEGER K;
FOR K := 1 STEP 3 UNTIL 10 DO
WRITE(K," IS ", IF EVEN(K) = 1 THEN "EVEN" ELSE "ODD");
END
- Output:
1 IS ODD 4 IS EVEN 7 IS ODD 10 IS EVEN
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);
INTEGER I;
BEGIN
EVEN := (IF I = 2 * (I / 2) THEN 1 ELSE 0);
END;
ALGOL W
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.
- Output:
1 is odd 1702 is even 23 is odd -26 is even
AntLang
odd: {x mod 2}
even: {1 - x mod 2}
APL
The easiest way is probably to use modulo.
2|28
0
2|37
1
So you can write a user-defined operator.
odd ← 2∘|
AppleScript
set L to {3, 2, 1, 0, -1, -2, -3}
set evens to {}
set odds to {}
repeat with x in L
if (x mod 2 = 0) then
set the end of evens to x's contents
else
set the end of odds to x's contents
end if
end repeat
return {even:evens, odd:odds}
- Output:
{even:{2, 0, -2}, odd:{3, 1, -1, -3}}
Or, packaging reusable functions that can serve as arguments to filter, partition etc
(deriving even from mod, and odd from even):
----------------------- EVEN OR ODD ------------------------
-- even :: Int -> Bool
on even(n)
0 = n mod 2
end even
-- odd :: Int -> Bool
on odd(n)
not even(n)
end odd
--------------------------- TEST ---------------------------
on run
partition(odd, enumFromTo(-6, 6))
--> {{-5, -3, -1, 1, 3, 5}, {-6, -4, -2, 0, 2, 4, 6}}
end run
-------------------- GENERICS FOR TEST ---------------------
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if m ≤ n then
set lst to {}
repeat with i from m to n
set end of lst to i
end repeat
lst
else
{}
end if
end enumFromTo
-- partition :: (a -> Bool) -> [a] -> ([a], [a])
on partition(p, xs)
tell mReturn(p)
set {ys, zs} to {{}, {}}
repeat with x in xs
set v to contents of x
if |λ|(v) then
set end of ys to v
else
set end of zs to v
end if
end repeat
end tell
{ys, zs}
end partition
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper.
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end mReturn
- Output:
{{-5, -3, -1, 1, 3, 5}, {-6, -4, -2, 0, 2, 4, 6}}
Arendelle
( input , "Please enter a number: " ) { @input % 2 = 0 , "| @input | is even!" , "| @input | is odd!" }
ARM Assembly
/* ARM assembly Raspberry PI or android 32 bits */
/* program oddEven.s */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
sMessResultOdd: .asciz " @ is odd (impair) \n"
sMessResultEven: .asciz " @ is even (pair) \n"
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
mov r0,#5
bl testOddEven
mov r0,#12
bl testOddEven
mov r0,#2021
bl testOddEven
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsMessResultOdd: .int sMessResultOdd
iAdrsMessResultEven: .int sMessResultEven
iAdrsZoneConv: .int sZoneConv
/***************************************************/
/* test if number is odd or even */
/***************************************************/
// r0 contains à number
testOddEven:
push {r2-r8,lr} @ save registers
tst r0,#1 @ test bit 0 to one
beq 1f @ if result are all zéro, go to even
ldr r1,iAdrsZoneConv @ else display odd message
bl conversion10 @ call decimal conversion
ldr r0,iAdrsMessResultOdd
ldr r1,iAdrsZoneConv @ insert value conversion in message
bl strInsertAtCharInc
bl affichageMess
b 100f
1:
ldr r1,iAdrsZoneConv
bl conversion10 @ call decimal conversion
ldr r0,iAdrsMessResultEven
ldr r1,iAdrsZoneConv @ insert conversion in message
bl strInsertAtCharInc
bl affichageMess
100:
pop {r2-r8,lr} @ restaur registers
bx lr @ return
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
ArnoldC
LISTEN TO ME VERY CAREFULLY isOdd
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n
GIVE THESE PEOPLE AIR
HEY CHRISTMAS TREE result
YOU SET US UP @I LIED
GET TO THE CHOPPER result
HERE IS MY INVITATION n
I LET HIM GO 2
ENOUGH TALK
I'LL BE BACK result
HASTA LA VISTA, BABY
LISTEN TO ME VERY CAREFULLY showParity
I NEED YOUR CLOTHES YOUR BOOTS AND YOUR MOTORCYCLE n
TALK TO THE HAND n
HEY CHRISTMAS TREE parity
YOU SET US UP @I LIED
GET YOUR A** TO MARS parity
DO IT NOW isOdd n
BECAUSE I'M GOING TO SAY PLEASE parity
TALK TO THE HAND "odd"
BULLS***
TALK TO THE HAND "even"
YOU HAVE NO RESPECT FOR LOGIC
TALK TO THE HAND ""
HASTA LA VISTA, BABY
IT'S SHOWTIME
DO IT NOW showParity 5
DO IT NOW showParity 6
DO IT NOW showParity -11
YOU HAVE BEEN TERMINATED
- Output:
5 odd 6 even -11 odd
Arturo
loop (neg 5)..5 [x][
if? even? x -> print [pad to :string x 4 ": even"]
else -> print [pad to :string x 4 ": odd"]
]
- Output:
-5 : odd -4 : even -3 : odd -2 : even -1 : odd 0 : even 1 : odd 2 : even 3 : odd 4 : even 5 : odd
Asymptote
for (int i = 1; i <= 10; ++i) {
if (i % 2 == 0) {
write(string(i), " is even");
} else {
write(string(i), " is odd");
}
}
AutoHotkey
Bitwise ops are probably most efficient:
if ( int & 1 ){
; do odd stuff
}else{
; do even stuff
}
AWK
function isodd(x) {
return x % 2 != 0
}
function iseven(x) {
return x % 2 == 0
}
BASIC
Applesoft 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
BaCon
' Even or odd
OPTION MEMTYPE int
SPLIT ARGUMENT$ BY " " TO arg$ SIZE dim
n = IIF$(dim < 2, 0, VAL(arg$[1]))
PRINT n, " is ", IIF$(EVEN(n), "even", "odd")
- Output:
prompt$ ./even-or-odd 42 42 is even prompt$ ./even-or-odd 41 41 is odd
BASIC256
for i = 1 to 10
if (i mod 2) then print i;" is odd" else print i;" is even"
next i
end
BBC BASIC
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.
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)
- Output:
14 is even 15 is odd 9876543210 is even 9876543211 is odd
Chipmunk Basic
Uses bitwise AND as suggested.
10 cls
20 for n = 1 to 10
30 print n;
40 if (n and 1) = 1 then print "is odd" else print "is even"
50 next n
60 end
Commodore BASIC
Uses bitwise AND as suggested.
10 rem determine if integer is even or odd
20 print "Enter an integer:";
30 input i%
35 print
40 eo$="even"
50 if (i% and 1)=1 then eo$="odd"
60 print "The number ";i%;"is ";eo$;"."
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
Gambas
Public Sub Form_Open()
Dim sAnswer, sMessage As String
sAnswer = InputBox("Input an integer", "Odd or even")
If IsInteger(sAnswer) Then
If Odd(Val(sAnswer)) Then sMessage = "' is an odd number"
If Even(Val(sAnswer)) Then sMessage = "' is an even number"
Else
sMessage = "' does not compute!!"
Endif
Print "'" & sAnswer & sMessage
End
Output:
'25' is an odd number '100' is an even number 'Fred' does not compute!!
GW-BASIC
10 INPUT "Enter a number: ", N
20 IF N MOD 2 = 1 THEN PRINT "It is odd." ELSE PRINT "It is even."
IS-BASIC
100 DEF ODD(X)=MOD(X,2)
110 INPUT PROMPT "Enter a number: ":X
120 IF ODD(X) THEN
130 PRINT X;"is odd."
140 ELSE
150 PRINT X;"is even."
160 END IF
Liberty BASIC
n=12
if n mod 2 = 0 then print "even" else print "odd"
Minimal BASIC
10 REM Even or odd
20 PRINT "Enter an integer number";
30 INPUT N
40 IF N/2 <> INT(N/2) THEN 70
50 PRINT "The number is even."
60 GOTO 80
70 PRINT "The number is odd."
80 END
MSX Basic
Uses bitwise AND as suggested.
10 CLS
20 FOR N = -5 TO 5
30 PRINT N;
40 IF (N AND 1) = 1 THEN PRINT "is odd" ELSE PRINT "is even"
50 NEXT N
60 END
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
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.
'This is a comment line. It also could have been preceded with "Rem"
Dim i% 'This line is not necessary, but % strict casts
'as an Int (2 bytes). "As Int" could have been used instead.
Input "#? ", i% 'Prints "#? " as a prompt and waits
'for user input terminated by pressing [ENTER].
'Binary integers example
If i% And 1 Then 'Test whether the input value AND 1 is 0 (false) or 1 (true).
'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)"
Print "Even" 'Prints "Even in all other cases (Else)
'or if the logical inverse of the input value AND 1 tested
'"true" (ElseIf).
End If
'Modular congruence example
If i% Mod 2 Then
Print "Still Odd"
Else
Print "Still Even"
End If
QBasic
FOR i = 1 TO 10
IF i AND 1 THEN PRINT i; " is odd" ELSE PRINT i; " is even"
NEXT i
Quite BASIC
10 CLS
20 FOR n = -5 TO 5
30 PRINT n;
40 IF n % 2 <> 0 THEN PRINT " is odd" ELSE PRINT " is even"
50 NEXT n
60 END
Run BASIC
for i = 1 to 10
if i and 1 then print i;" is odd" else print i;" is even"
next i
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
S-BASIC
S-BASIC lacks a MOD operator but supports bitwise operations on integer variables, so that is the approach taken.
rem - return true (-1) if even, otherwise false (0)
function even(i = integer) = integer
var one = integer rem - both operands must be variables
one = 1
end = ((i and one) = 0)
rem - exercise the function
var i = integer
for i = 1 to 10 step 3
print i; " is ";
if even(i) then
print "even"
else
print "odd"
next
end
- Output:
1 is odd 4 is even 7 is odd 10 is even
SmallBASIC
FOR i = 1 to 10
IF(i % 2 == 0)
PRINT i; " is even"
ELSE
PRINT i; " is odd"
ENDIF
NEXT
TI-83 BASIC
TI-83 BASIC does not have a modulus operator.
If fPart(.5Ans
Then
Disp "ODD
Else
Disp "EVEN
End
Tiny BASIC
10 PRINT "Enter a number:"
20 INPUT N
30 IF 2*(N/2) = N THEN GOTO 60
40 PRINT "It's odd."
50 END
60 PRINT "It's even."
70 END
True BASIC
FOR i = 1 to 10
IF MOD(i, 2) = 0 THEN PRINT i; " is odd" ELSE PRINT i; " is even"
NEXT i
END
VBA
4 ways = 4 Functions : IsEven ==> Use the even and odd predicates IsEven2 ==> Check the least significant digit. With binary integers, i bitwise-and 1 equals 0 iff i is even IsEven3 ==> Divide i by 2. The remainder equals 0 if i is even. IsEven4 ==> Use modular congruences
Option Explicit
Sub Main_Even_Odd()
Dim i As Long
For i = -50 To 48 Step 7
Debug.Print i & " : IsEven ==> " & IIf(IsEven(i), "is even", "is odd") _
& " " & Chr(124) & " IsEven2 ==> " & IIf(IsEven2(i), "is even", "is odd") _
& " " & Chr(124) & " IsEven3 ==> " & IIf(IsEven3(i), "is even", "is odd") _
& " " & Chr(124) & " IsEven4 ==> " & IIf(IsEven4(i), "is even", "is odd")
Next
End Sub
Function IsEven(Number As Long) As Boolean
'Use the even and odd predicates
IsEven = (WorksheetFunction.Even(Number) = Number)
End Function
Function IsEven2(Number As Long) As Boolean
'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.
Dim lngTemp As Long
lngTemp = CLng(Right(CStr(Number), 1))
If (lngTemp And 1) = 0 Then IsEven2 = True
End Function
Function IsEven3(Number As Long) As Boolean
'Divide i by 2.
'The remainder equals 0 if i is even.
Dim sngTemp As Single
sngTemp = Number / 2
IsEven3 = ((Int(sngTemp) - sngTemp) = 0)
End Function
Function IsEven4(Number As Long) As Boolean
'Use modular congruences
IsEven4 = (Number Mod 2 = 0)
End Function
- Output:
-50 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even -43 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd -36 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even -29 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd -22 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even -15 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd -8 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even -1 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd 6 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even 13 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd 20 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even 27 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd 34 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even 41 : IsEven ==> is odd | IsEven2 ==> is odd | IsEven3 ==> is odd | IsEven4 ==> is odd 48 : IsEven ==> is even | IsEven2 ==> is even | IsEven3 ==> is even | IsEven4 ==> is even
VBScript
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
- 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
Visual Basic .NET
Module Module1
Sub Main()
Dim str As String
Dim num As Integer
While True
Console.Write("Enter an integer or 0 to finish: ")
str = Console.ReadLine()
If Integer.TryParse(str, num) Then
If num = 0 Then
Exit While
End If
If num Mod 2 = 0 Then
Console.WriteLine("Even")
Else
Console.WriteLine("Odd")
End If
Else
Console.WriteLine("Bad input.")
End If
End While
End Sub
End Module
BigInteger
Imports System.Numerics
Module Module1
Function IsOdd(bi As BigInteger) As Boolean
Return Not bi.IsEven
End Function
Function IsEven(bi As BigInteger) As Boolean
Return bi.IsEven
End Function
Sub Main()
' uncomment one of the following Dim statements
' Dim x As Byte = 3
' Dim x As Short = 3
' Dim x As Integer = 3
' Dim x As Long = 3
' Dim x As SByte = 3
' Dim x As UShort = 3
' Dim x As UInteger = 3
' Dim x As ULong = 3
' Dim x as BigInteger = 3
' the following three types give a warning, but will work
' Dim x As Single = 3
' Dim x As Double = 3
' Dim x As Decimal = 3
Console.WriteLine("{0} {1}", IsOdd(x), IsEven(x))
End Sub
End Module
XBasic
PROGRAM "Even/Odd"
DECLARE FUNCTION Entry ()
FUNCTION Entry ()
FOR i = 1 TO 10
IF (i MOD 2) THEN PRINT i;" is odd" ELSE PRINT i;" is even"
NEXT i
END FUNCTION
END PROGRAM
Yabasic
for i = -5 to 5
print i, and(i,1), mod(i,2)
next
ZX Spectrum Basic
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
Batch File
@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
bc
There are no bitwise operations, so this solution compares a remainder with zero. Calculation of i % 2 only works when scale = 0.
i = -3
/* Assumes that i is an integer. */
scale = 0
if (i % 2 == 0) "i is even
"
if (i % 2) "i is odd
"
Beads
beads 1 program 'Even or odd'
calc main_init
loop across:[-10, -5, 10, 5] val:v
log "{v}\todd:{is_odd(v)}\teven:{is_even(v)}"
- Output:
-10 odd:N even:Y -5 odd:Y even:N 10 odd:N even:Y 5 odd:Y even:N
Befunge
&2%52**"E"+,@
Outputs E if even, O if odd.
Binary Lambda Calculus
In lambda calculus, the oddness of a given church numeral n can be computed as n applications of not
to false
: \n. n (\b\x\y. b y x) (\x\y.y)
, which in BLC is
00 01 01 10 0000000101111010110 000010
To compute the evenness, one need only replace false
by true
, i.e. replace the final 0 bit by 10.
BQN
odd ← 2⊸|
!0 ≡ odd 12
!1 ≡ odd 31
Bracmat
Not the simplest solution, but the cheapest if the number that must be tested has thousands of digits.
( ( even
=
. @( !arg
: ?
[-2
( 0
| 2
| 4
| 6
| 8
)
)
)
& (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
)
- 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.
,[>,----------] 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
If one need only determine rather than act on the parity of the input, the following is sufficient; it terminates either quickly or never.
,[>,----------]<[--]
Burlesque
2.%
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):
if (x & 1) {
/* x is odd */
} else {
/* or not */
}
If using long integer type from GMP (mpz_t
), there are provided macros:
mpz_t x;
...
if (mpz_even_p(x)) { /* x is even */ }
if (mpz_odd_p(x)) { /* x is odd */ }
The macros evaluate x
more than once, so it should not be something with side effects.
C#
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;
}
}
public class Program
{
public static void Main()
{
int num = 26; //Set this to any integer.
if (num.IsEvenBitwise()) //Replace this with any even function.
{
Console.Write("Even");
}
else
{
Console.Write("Odd");
}
//Prints "Even".
if (num.IsOddBitwise()) //Replace this with any odd function.
{
Console.Write("Odd");
}
else
{
Console.Write("Even");
}
//Prints "Even".
}
}
}
C++
Test using the modulo operator, or use the C example from above.
bool isOdd(int x)
{
return x % 2;
}
bool isEven(int x)
{
return !(x % 2);
}
A slightly more type-generic version, for C++11 and later. This should theoretically work for any type convertible to int
:
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);
}
Clojure
Standard predicates:
(if (even? some-var) (do-even-stuff))
(if (odd? some-var) (do-odd-stuff))
COBOL
IF FUNCTION REM(Num, 2) = 0
DISPLAY Num " is even."
ELSE
DISPLAY Num " is odd."
END-IF
CoffeeScript
isEven = (x) -> !(x%2)
ColdFusion
function f(numeric n) {
return n mod 2?"odd":"even"
}
Common Lisp
Standard predicates:
(if (evenp some-var) (do-even-stuff))
(if (oddp some-other-var) (do-odd-stuff))
Alternate solution
I use Allegro CL 10.1
;; Project : Even or odd
(defun evenodd (nr)
(cond ((evenp nr) "even")
((oddp nr) "odd")))
(dotimes (n 10)
(if (< n 1) (terpri))
(if (< n 9) (format t "~a" " "))
(write(+ n 1)) (format t "~a" ": ")
(format t "~a" (evenodd (+ n 1))) (terpri))
Output:
1: odd 2: even 3: odd 4: even 5: odd 6: even 7: odd 8: even 9: odd 10: even
Component Pascal
BlackBox Component Builder
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;
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
#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)
- Output:
false true true false false true
D
void main() {
import std.stdio, std.bigint;
foreach (immutable i; -5 .. 6)
writeln(i, " ", i & 1, " ", i % 2, " ", i.BigInt % 2);
}
- Output:
-5 1 -1 -1 -4 0 0 0 -3 1 -1 -1 -2 0 0 0 -1 1 -1 -1 0 0 0 0 1 1 1 1 2 0 0 0 3 1 1 1 4 0 0 0 5 1 1 1
Dart
void main() {
for (var i = 1; i <= 10; i++) {
if (i % 2 != 0) {
print("$i is odd");
} else {
print("$i is even");
}
}
}
dc
This macro expects an integer on the stack, pops it, and pushes 1 if it is odd, or 0 if it is even (independently from the precision currently set).
[K Sk 0 k 2 % Lk k]
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
- 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
Delphi
program EvenOdd;
{$APPTYPE CONSOLE}
{$R *.res}
uses
System.SysUtils;
procedure IsOdd(aValue: Integer);
var
Odd: Boolean;
begin
Odd := aValue and 1 <> 0;
Write(Format('%d is ', [aValue]));
if Odd then
Writeln('odd')
else
Writeln('even');
end;
var
i: Integer;
begin
for i := -5 to 10 do
IsOdd(i);
Readln;
end.
- 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 6 is even 7 is odd 8 is even 9 is odd 10 is even
Déjà Vu
even n:
= 0 % n 2
odd:
not even
!. odd 0
!. even 0
!. odd 7
!. even 7
- Output:
false true true false
Diego
use_namespace(rosettacode)_me();
funct(isEven)_arg(i)_ret()_calc(i%2)_equals(0);
reset_namespace[];
DWScript
Predicate:
var isOdd := Odd(i);
Bitwise and:
var isOdd := (i and 1)<>0;
Modulo:
var isOdd := (i mod 2)=1;
EasyLang
a = 13
if a mod 2 = 0
print a & " is even"
else
print a & " is odd"
.
Ed
Checks the least significant digit of a line.
H
g/(.*[13579])$/s//\1 is odd/
v/odd/s/(.*)/\1 is even/
,p
Q
- Output:
$ cat even-odd.ed | ed -GlEs even-odd.input Newline appended 1 is odd 3 is odd 5 is odd 9 is odd 23 is odd 9 is odd 0 is even 83 is odd 3 is odd 54 is even 6 is even 2 is even 7 is odd 433 is odd 78 is even
EDSAC order code
This implementation uses the C
(logical AND multiplier register with memory) order. It will cause the machine to print an E if the number stored at address θ+15 is even, or an O if it is odd. As an example, we shall test the number 37 (P18D
in EDSAC encoding).
[ Even or odd
===========
A program for the EDSAC
Determines whether the number stored at
address 15@ is even or odd, and prints
'E' or 'O' accordingly
Works with Initial Orders 2 ]
T56K [ load point ]
GK [ base address ]
O11@ [ print letter shift ]
T10@ [ clear accumulator ]
H15@ [ multiplier := n ]
C12@ [ acc +:= mult AND 1 ]
S12@ [ acc -:= 1 ]
G8@ [ branch on negative ]
O14@ [ print 'O' ]
ZF [ halt ]
[ 8 ] O13@ [ print 'E' ]
ZF [ halt ]
[ 10 ] P0F [ used to clear acc ]
[ 11 ] *F [ letter shift character ]
[ 12 ] P0D [ const: 1 ]
[ 13 ] EF [ character 'E' ]
[ 14 ] OF [ character 'O' ]
[ 15 ] P18D [ number to test: 37 ]
EZPF [ branch to load point ]
- Output:
O
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
Elixir
defmodule RC do
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
if 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)
- 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:
rem(n,2) == 0
Emacs Lisp
(require 'cl-lib)
(defun even-or-odd-p (n)
(if (cl-evenp n) 'even 'odd))
(defun even-or-odd-p (n)
(if (zerop (% n 2)) 'even 'odd))
(message "%d is %s" 3 (even-or-oddp 3))
(message "%d is %s" 2 (even-or-oddp 2))
- Output:
3 is odd 2 is even
EMal
List evenCheckers = fun[
logic by int i do return i % 2 == 0 end,
logic by int i do return i & 1 == 0 end]
List oddCheckers = fun[
logic by int i do return i % 2 != 0 end,
logic by int i do return i & 1 == 1 end]
writeLine("integer".padStart(10, " ") + "|is_even" + "|is_odd |")
writeLine("----------+-------+-------+")
for each int i in range(-5, 6).append(3141592653)
write((text!i).padStart(10, " ") + "| ")
for each fun isEven in evenCheckers
write(isEven(i) + " ")
end
write("| ")
for each fun isOdd in oddCheckers
write(isOdd(i) + " ")
end
writeLine("|")
end
writeLine("----------+-------+-------+")
- Output:
integer|is_even|is_odd | ----------+-------+-------+ -5| ⊥ ⊥ | ⊤ ⊤ | -4| ⊤ ⊤ | ⊥ ⊥ | -3| ⊥ ⊥ | ⊤ ⊤ | -2| ⊤ ⊤ | ⊥ ⊥ | -1| ⊥ ⊥ | ⊤ ⊤ | 0| ⊤ ⊤ | ⊥ ⊥ | 1| ⊥ ⊥ | ⊤ ⊤ | 2| ⊤ ⊤ | ⊥ ⊥ | 3| ⊥ ⊥ | ⊤ ⊤ | 4| ⊤ ⊤ | ⊥ ⊥ | 5| ⊥ ⊥ | ⊤ ⊤ | 3141592653| ⊥ ⊥ | ⊤ ⊤ | ----------+-------+-------+
Erlang
Using Division by 2 Method
%% 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.
Using the least-significant bit method
%% 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.
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
- Output:
14 is even 15 is odd 9876543210 is even 9876543211 is odd
Euphoria
Using standard function
include std/math.e
for i = 1 to 10 do
? {i, is_even(i)}
end for
- 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
=MOD(33;2)
=MOD(18;2)
- Output:
1 0
Use the ISEVEN function, returns TRUE or FALSE
=ISEVEN(33)
=ISEVEN(18)
- Output:
FALSE TRUE
Use the ISODD function, returns TRUE or FALSE
=ISODD(33)
=ISODD(18)
- Output:
TRUE FALSE
F#
Bitwise and:
let isEven x =
x &&& 1 = 0
Modulo:
let isEven x =
x % 2 = 0
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.
<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 ^
The actual computation is the 2%0= part. The rest is either user interface or parsing input.
Forth
: odd? ( n -- ? ) 1 and ;
: even? ( n -- ? ) odd? 0= ;
\ Every value not equal to zero is considered true. Only zero is considered false.
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
!
!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
Frink
isEven[x is isInteger] := getBit[x,0] == 0
isOdd[x is isInteger] := getBit[x,0] == 1
Futhark
fun main(x: int): bool = (x & 1) == 0
FutureBasic
local fn OddOrEven( i as NSInteger ) as CFStringRef
CFStringRef result
if ( i mod 2 ) == 0 then result = @"Even" else result = @"Odd"
end fn = result
NSUInteger i
for i = 1 to 10
printf @"%d is %@", i, fn OddOrEven( i )
next
HandleEvents
Fōrmulæ
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.
Programs in Fōrmulæ are created/edited online in its website.
In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation.
Solutions
Case 1. Intrinsic expressions:
Case 2. Using the Divides and DoesNotDivide expressions:
Case 3. Using modular congruences
Case 4. Using bitwise operations
Case 5. Using IsRational
GAP
IsEvenInt(n);
IsOddInt(n);
Genie
Using bitwise AND of the zero-bit.
[indent = 4]
/*
Even or odd, in Genie
valac even_or_odd.gs
*/
def parity(n:int):bool
return ((n & 1) == 0)
def show_parity(n:int):void
print "%d is %s", n, parity(n) ? "even" : "odd"
init
show_parity(0)
show_parity(1)
show_parity(2)
show_parity(-2)
show_parity(-1)
- Output:
prompt$ valac even_or_odd.gs prompt$ ./even_or_odd 0 is even 1 is odd 2 is even -2 is even -1 is odd
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")
}
}
- 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:
def isOdd = { int i -> (i & 1) as boolean }
def isEven = {int i -> ! isOdd(i) }
Test:
1.step(20, 2) { assert isOdd(it) }
50.step(-50, -2) { assert isEven(it) }
Haskell
even
and odd
functions are already included in the standard Prelude.
Prelude> even 5
False
Prelude> even 42
True
Prelude> odd 5
True
Prelude> odd 42
False
Where even is derived from rem, and odd is derived from even:
import Prelude hiding (even, odd)
even, odd
:: (Integral a)
=> a -> Bool
even = (0 ==) . (`rem` 2)
odd = not . even
main :: IO ()
main = print (even <$> [0 .. 9])
- Output:
[True,False,True,False,True,False,True,False,True,False]
Hoon
|= n=@ud
?: =((mod n 2) 0)
"even"
"odd"
Icon and Unicon
One way is to check the remainder:
procedure isEven(n)
return n%2 = 0
end
Insitux
Exactly the same as Clojure, these are built-in predicates.
(if (even? some-var) (do-even-stuff))
(if (odd? some-var) (do-odd-stuff))
J
Modulo:
2 | 2 3 5 7
0 1 1 1
2|2 3 5 7 + (2^89x)-1
1 0 0 0
Remainder:
(= <.&.-:) 2 3 5 7
1 0 0 0
(= <.&.-:) 2 3 5 7+(2^89x)-1
0 1 1 1
Last bit in bit representation:
{:"1@#: 2 3 5 7
0 1 1 1
{:"1@#: 2 3 5 7+(2^89x)-1
1 0 0 0
Bitwise and:
1 (17 b.) 2 3 5 7
0 1 1 1
Note: as a general rule, the simplest expressions in J should be preferred over more complex approaches.
Jakt
fn is_even<T>(anon n: T) -> bool => 0 == (n & 1)
fn is_odd<T>(anon n: T) -> bool => 0 != (n & 1)
fn main() {
for i in 0..11 {
println("{} {} {}", i, is_even(i), is_odd(i))
}
}
Java
Bitwise and:
public static boolean isEven(int i){
return (i & 1) == 0;
}
Modulo:
public static boolean isEven(int i){
return (i % 2) == 0;
}
Arbitrary precision bitwise:
public static boolean isEven(BigInteger i){
return i.and(BigInteger.ONE).equals(BigInteger.ZERO);
}
Arbitrary precision bit test (even works for negative numbers because of the way BigInteger
represents the bits of numbers):
public static boolean isEven(BigInteger i){
return !i.testBit(0);
}
Arbitrary precision modulo:
public static boolean isEven(BigInteger i){
return i.mod(BigInteger.valueOf(2)).equals(BigInteger.ZERO);
}
JavaScript
ES5
Bitwise:
function isEven( i ) {
return (i & 1) === 0;
}
Modulo:
function isEven( i ) {
return i % 2 === 0;
}
// Alternative
function isEven( i ) {
return !(i % 2);
}
ES6
Lambda:
// EMCAScript 6
const isEven = x => !(x % 2)
or, avoiding type coercion:
(() => {
'use strict';
// even : Integral a => a -> Bool
const even = x => (x % 2) === 0;
// odd : Integral a => a -> Bool
const odd = x => !even(x);
// TEST ----------------------------------------
// range :: Int -> Int -> [Int]
const range = (m, n) =>
Array.from({
length: Math.floor(n - m) + 1
}, (_, i) => m + i);
// show :: a -> String
const show = JSON.stringify;
// xs :: [Int]
const xs = range(-6, 6);
return show([xs.filter(even), xs.filter(odd)]);
})();
- Output:
[[-6,-4,-2,0,2,4,6],[-5,-3,-1,1,3,5]]
Joy
DEFINE
even == 2 rem null;
odd == even not.
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:
def is_even: type == "number" and floor == 0 and . % 2 == 0;
The check that the floor is 0 is necessary as % is defined on floating point numbers.
"is_odd" could be similarly defined:
def is_odd: type == "number" and floor == 0 and . % 2 == 1;
Jsish
Using bitwise and of low bit.
#!/usr/bin/env jsish
/* Even or Odd, in Jsish */
function isEven(n:number):boolean { return (n & 1) === 0; }
provide('isEven', 1);
if (Interp.conf('unitTest')) {
; isEven(0);
; isEven(1);
; isEven(2);
; isEven(-13);
}
/*
=!EXPECTSTART!=
isEven(0) ==> true
isEven(1) ==> false
isEven(2) ==> true
isEven(-13) ==> false
=!EXPECTEND!=
*/
- Output:
$ jsish --U isEven.jsi isEven(0) ==> true isEven(1) ==> false isEven(2) ==> true isEven(-13) ==> false
Julia
Built-in functions:
iseven(i), isodd(i)
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
Examples:
oddp 32
0
evenp 32
1
Klingphix
( -5 5 ) [
dup print " " print 2 mod ( ["Odd"] ["Even"] ) if print nl
] for
" " input
- Output:
-5 Odd -4 Even -3 Odd -2 Even -1 Odd 0 Even 1 Odd 2 Even 3 Odd 4 Even 5 Odd
Kotlin
// version 1.0.5-2
fun main(args: Array<String>) {
while (true) {
print("Enter an integer or 0 to finish : ")
val n = readLine()!!.toInt()
when {
n == 0 -> return
n % 2 == 0 -> println("Your number is even")
else -> println("Your number is odd")
}
}
}
Lambdatalk
{def is_odd {lambda {:i} {= {% :i 2} 1}}}
-> is_odd
{def is_even {lambda {:i} {= {% :i 2} 0}}}
-> is_even
{is_odd 2}
-> false
{is_even 2}
-> true
L++
(defn bool isEven (int x) (return (% x 2)))
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
: even? 2 % not ;
: odd? 2 % ;
1 even? . # 0
1 odd? . # 1
Lasso
define isoddoreven(i::integer) => {
#i % 2 ? return 'odd'
return 'even'
}
isoddoreven(12)
LC3 Assembly
Prints EVEN if the number stored in NUM is even, otherwise ODD.
.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
Lingo
on even (n)
return n mod 2 = 0
end
on odd (n)
return n mode 2 <> 0
end
Little Man Computer
Runs in Peter Higginson's simulator, to allow comments. Does not use his other extensions to the language.
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
BRZ write // input = 0 is special case
loop SUB k2 // keep subtracting 2 from acc
BRZ write // if acc = 0, input is even
BRP loop // if acc > 0, loop back
// (BRP branches if acc >= 0, but we've dealt with acc = 0)
LDA k1 // if acc < 0, input is odd
write OUT // output 0 or 1
HLT // halt
k1 DAT 1 // constant 1
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
loop1 STA save_acc // save accumulator (see note below)
SUB k128 // keep subtracting 128 until acc < 0
BRP loop1
LDA save_acc // save_acc holds a number in range 0..127
loop2 STA save_acc
SUB k16 // keep subtracting 16 until acc < 0
BRP loop2
LDA save_acc // save_acc holds a number in range 0..15
loop3 STA save_acc
SUB k2 // keep subtracting 2 until acc < 0
BRP loop3
LDA save_acc // save_acc holds 0 or 1, the result
write OUT // output result
HLT
k2 DAT 2
k16 DAT 16
k128 DAT 128
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.
LiveCode
function odd n
return (n bitand 1) = 1
end odd
function notEven n
return (n mod 2) = 1
end notEven
LLVM
; This is not strictly LLVM, as it uses the C library function "printf".
; 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.
; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps
;--- The declarations for the external C functions
declare i32 @printf(i8*, ...)
$"EVEN_STR" = comdat any
$"ODD_STR" = comdat any
@"EVEN_STR" = linkonce_odr unnamed_addr constant [12 x i8] c"%d is even\0A\00", comdat, align 1
@"ODD_STR" = linkonce_odr unnamed_addr constant [11 x i8] c"%d is odd\0A\00", comdat, align 1
; Function Attrs: noinline nounwind optnone uwtable
define i32 @main() #0 {
%1 = alloca i32, align 4 ;-- allocate i
store i32 0, i32* %1, align 4 ;-- store 0 in i
br label %loop
loop:
%2 = load i32, i32* %1, align 4 ;-- load i
%3 = icmp ult i32 %2, 4 ;-- i < 4
br i1 %3, label %loop_body, label %exit
loop_body:
%4 = load i32, i32* %1, align 4 ;-- load i
%5 = and i32 %4, 1 ;-- i & 1
%6 = icmp eq i32 %5, 0 ;-- (i & 1) == 0
br i1 %6, label %even_branch, label %odd_branch
even_branch:
%7 = load i32, i32* %1, align 4 ;-- load i
%8 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @"EVEN_STR", i32 0, i32 0), i32 %7)
br label %loop_increment
odd_branch:
%9 = load i32, i32* %1, align 4 ;-- load i
%10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @"ODD_STR", i32 0, i32 0), i32 %9)
br label %loop_increment
loop_increment:
%11 = load i32, i32* %1, align 4 ;-- load i
%12 = add i32 %11, 1 ;-- increment i
store i32 %12, i32* %1, align 4 ;-- store i
br label %loop
exit:
ret i32 0
}
attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
- Output:
0 is even 1 is odd 2 is even 3 is odd
Logo
to even? :num
output equal? 0 modulo :num 2
end
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.
- Output:
| ?- 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
LOLCODE
HAI 1.4
I HAS A integer
GIMMEH integer
I HAS A remainder
remainder R MOD OF integer AN 2
BOTH SAEM remainder AN 1, O RLY?
YA RLY
VISIBLE "The integer is odd."
NO WAI
VISIBLE "The integer is even."
OIC
KTHXBYE
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
M2000 Interpreter
Binary.Add take any numeric type, but value from newer versions can trait as unsigned with range of 0 to 0xFFFFFFFF (so if the number is out of this range, a cut made).
Print binary.and(0xFFFFFFF+10, 0XF)=9 // 0xFFFFFFFF is type Currency and return 4294967295, number 10 is type double so the final number for addition is type double.
Print binary.and(0xFFFFFFF&+10, 0XF)=9 // 0xFFFFFFFF& is type long and return -1, number 10 is type double so the final number for addition is type double.
Print binary.and(0x7FFFFFFF&*16&+10&, 0xF)=15 // 0x7FFFFFFF&*16& cant fit in long so it is type of double 34359738352 (this performed automatic). But if we give this Long A=0x7FFFFFFF&*16& we get an overflow error, because A is a Long, and 34359738352 can't fit.
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
Def used to define variables (an error occur if same variable exist), or to define one line local functions. If a function exist then replace code. This is the same for modules/functions, a newer definition alter an old definition with same name, in current module if they are local, or global if they defined as global, like this:
Function Global F(x) { code block here}.
A function F(x) {} is same as
Function F { Read x code here }
The same hold for Def Odd(a)=binary.and(Abs(a), 1)=1 Interpreter execute this:
Function Odd { Read a =binary.and(Abs(a), 1)=1 }
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)
Print Odd(21212121212122122122121@)
def Odd(a)= Int(Abs(a)) mod 2 =1
Print Odd(21212121212122122122121@)
Print Odd(-5), Odd(6), Odd(11)
}
CheckOdd
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)
Maple
EvenOrOdd := proc( x::integer )
if x mod 2 = 0 then
print("Even"):
else
print("Odd"):
end if:
end proc:
EvenOrOdd(9);
"Odd"
Mathematica / Wolfram Language
EvenQ[8]
MATLAB / Octave
Bitwise And:
isOdd = logical(bitand(N,1));
isEven = ~logical(bitand(N,1));
Remainder of division by two:
isOdd = logical(rem(N,2));
isEven = ~logical(rem(N,2));
Modulo: 2
isOdd = logical(mod(N,2));
isEven = ~logical(mod(N,2));
Maxima
evenp(n);
oddp(n);
MAXScript
-- MAXScript : Even or Odd : N.H. 2019
-- Open the MAXScript Listener for input and output
userInt = getKBValue prompt:"Enter an integer and i will tell you if its Even or Odd : "
if classOf userInt != Integer then print "The value you enter must be an integer"
else if (Mod userInt 2) == 0 Then Print "Your number is even"
else Print "Your number is odd"
Mercury
Mercury's 'int' module provides tests for even/odd, along with all the operators that would be otherwise used to implement them.
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.
min
3 even?
4 even?
5 odd?
get-stack print
- Output:
(false true true)
MiniScript
for i in range(-4, 4)
if i % 2 == 0 then print i + " is even" else print i + " is odd"
end for
- Output:
-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
MIPS Assembly
This uses bitwise AND
.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
МК-61/52
/ 2 {x} ЗН
Result: "0" - number is even; "1" - number is odd.
ML
fun even( x: int ) = (x mod 2 = 0);
fun odd( x: int ) = (x mod 2 = 1);
mLite
fun odd
(x rem 2 = 1) = true
| _ = false
;
fun even
(x rem 2 = 0) = true
| _ = false
;
Modula-2
MODULE EvenOrOdd;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,ReadChar;
VAR
buf : ARRAY[0..63] OF CHAR;
i : INTEGER;
BEGIN
FOR i:=-5 TO 5 DO
FormatString("%i is even: %b\n", buf, i, i MOD 2 = 0);
WriteString(buf)
END;
ReadChar
END EvenOrOdd.
Nanoquery
def isEven(n)
if ((n % 2) = 1)
return false
else
return true
end
end
for i in range(1, 10)
print i
if isEven(i)
println " is even."
else
println " is odd."
end
end
- Output:
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.
Neko
var number = 6;
if(number % 2 == 0) {
$print("Even");
} else {
$print("Odd");
}
- Output:
Even
NESL
NESL provides evenp and oddp functions, but they wouldn't be hard to reimplement.
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]};
- Output:
it = [F, T, F, T, F, T, F, T, F, T] : [bool]
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)
- 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
Never
func isOdd(n : int) -> int {
n % 2 == 1
}
func isEven(n : int) -> int {
n % 2 == 0
}
NewLISP
(odd? 1)
(even? 2)
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)
Nu
def is-even [x: int] {
($x bit-and 1) == 0
}
def is-odd [x: int] {
($x bit-and 1) == 1
}
Oberon-2
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.
- Output:
10 even 11 odd 12 even
Objeck
a := Console->ReadString()->ToInt();
if(a % 2 = 0) {
"even"->PrintLine();
}
else {
"odd"->PrintLine();
};
OCaml
Modulo:
let is_even d =
(d mod 2) = 0
let is_odd d =
(d mod 2) <> 0
Bitwise and:
let is_even d =
(d land 1) = 0
let is_odd d =
(d land 1) <> 0
An instructive view on functional programming and recursion:
(* hmm, only valid for N >= 0 *)
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
Oforth
12 isEven
12 isOdd
Ol
Actually, 'even?' and 'odd?' functions are built-in. But,
; 1. Check the least significant bit.
(define (even? i)
(if (eq? (band i 1) 0) #t #f))
(define (odd? i)
(if (eq? (band i 1) 1) #t #f))
(print (if (even? 12345678987654321) "even" "odd")) ; ==> odd
(print (if (odd? 12345678987654321) "odd" "even")) ; ==> odd
(print (if (even? 1234567898765432) "even" "odd")) ; ==> even
(print (if (odd? 1234567898765432) "odd" "even")) ; ==> even
; 2. Divide i by 2. The remainder equals 0 iff i is even.
(define (even? i)
(if (eq? (remainder i 2) 0) #t #f))
(define (odd? i)
(if (eq? (remainder i 2) 1) #t #f))
(print (if (even? 12345678987654321) "even" "odd")) ; ==> odd
(print (if (odd? 12345678987654321) "odd" "even")) ; ==> odd
(print (if (even? 1234567898765432) "even" "odd")) ; ==> even
(print (if (odd? 1234567898765432) "odd" "even")) ; ==> even
; 3. Use modular congruences. Same as 2.
(define (even? i)
(if (eq? (mod i 2) 0) #t #f))
(define (odd? i)
(if (eq? (mod i 2) 1) #t #f))
(print (if (even? 12345678987654321) "even" "odd")) ; ==> odd
(print (if (odd? 12345678987654321) "odd" "even")) ; ==> odd
(print (if (even? 1234567898765432) "even" "odd")) ; ==> even
(print (if (odd? 1234567898765432) "odd" "even")) ; ==> even
OOC
// Using the modulo operator
even: func (n: Int) -> Bool {
(n % 2) == 0
}
// Using bitwise and
odd: func (n: Int) -> Bool {
(n & 1) == 1
}
PARI/GP
GP does not have a built-in predicate for testing parity, but it's easy to code:
odd(n)=n%2;
Alternately:
odd(n)=bitand(n,1);
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.
PascalABC.NET
function IsOddRemainder(x: integer) := x mod 2 <> 0;
function IsEvenRemainder(x: integer) := x mod 2 = 0;
function IsOddBitwise(x: integer) := x and 1 = 1;
function IsEvenBitwise(x: integer) := x and 1 = 0;
begin
var x := 3;
Println(x.IsEven,x.IsOdd); // Standard Predicates
Println(IsEvenRemainder(x),IsOddRemainder(x));
Println(IsEvenBitwise(x),IsOddBitwise(x));
end.
Pascal
Built-in boolean function odd:
isOdd := odd(someIntegerNumber);
bitwise and:
function isOdd(Number: integer): boolean
begin
isOdd := boolean(Number and 1)
end;
Dividing and multiplying by 2 and test on equality:
function isEven(Number: integer): boolean
begin
isEven := (Number = ((Number div 2) * 2))
end;
Using built-in modulo
function isOdd(Number: integer): boolean
begin
isOdd := boolean(Number mod 2)
end;
Perl
for(0..10){
print "$_ is ", qw(even odd)[$_ % 2],"\n";
}
or
print 6 % 2 ? 'odd' : 'even'; # prints even
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.
with javascript_semantics include mpfr.e mpz z = mpz_init() printf(1," i odd even &&1 rmdr(2)\n") for i=-5 to 5 do mpz_set_si(z,i) printf(1,"%2d: %5t %5t %3d %5d\n",{i,odd(i),even(i),i&&1,remainder(i,2)}) end for
- Output:
i odd even &&1 rmdr(2) -5: true false 1 -1 -4: false true 0 0 -3: true false 1 -1 -2: false true 0 0 -1: true false 1 -1 0: false true 0 0 1: true false 1 1 2: false true 0 0 3: true false 1 1 4: false true 0 0 5: true false 1 1
Phixmonti
-5 5 2 tolist for
dup print " " print 2 mod if "Odd" else "Even" endif print nl
endfor
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';
- Output:
even odd odd even
Picat
% Bitwise and
is_even_bitwise(I) = cond(I /\ 1 == 0, true, false).
% Modulo
is_even_mod(I) = cond(I mod 2 == 0, true, false).
% Remainder
is_even_rem(I) = cond(I rem 2 == 0, true, false).
yes_or_no(B) = YN =>
B = true, YN = "Yes";
B = false, YN = "No".
main :-
foreach (I in 2..3)
printf("%d is even? %s\n", I, yes_or_no(is_even_bitwise(I))),
printf("%d is even? %s\n", I, yes_or_no(is_even_mod(I))),
printf("%d is even? %s\n", I, yes_or_no(is_even_rem(I)))
end.
- Output:
2 is even? Yes 2 is even? Yes 2 is even? Yes 3 is even? No 3 is even? No 3 is even? No
Note: Picat has even/1 and odd/1 as built-ins predicates.
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.
: (bit? 1 3)
-> 1 # Odd
: (bit? 1 4)
-> NIL # Even
Pike
> int i = 73;
> (i&1);
Result: 1
> i%2;
Result: 1
PL/I
i = iand(i,1)
The result is 1 when i is odd, and 0 when i is even.
PL/M
In PL/M, even numbers are falsy and odd numbers are truthy, so no explicit test is needed at all.
100H:
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
PUT$CHAR: PROCEDURE (CH); DECLARE CH BYTE; CALL BDOS(2, CH); END PUT$CHAR;
PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9, S); END PRINT;
DECLARE I BYTE;
DO I='0' TO '9';
CALL PUT$CHAR(I);
CALL PRINT(.' IS $');
IF I THEN
CALL PRINT(.'ODD$');
ELSE
CALL PRINT(.'EVEN$');
CALL PRINT(.(13,10,'$'));
END;
CALL EXIT;
EOF
- Output:
0 IS EVEN 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
Plain English
The noodle comes with even and odd deciders.
To run:
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.
Shut down.
- Output:
56 is even!
PowerShell
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
Processing
boolean isEven(int i){
return i%2 == 0;
}
boolean isOdd(int i){
return i%2 == 1;
}
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:
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)).
Python
Python: Using the least-significant bit method
>>> 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)]
>>>
Python: Using modular congruences
>> def is_even(i):
return (i % 2) == 0
>>> is_even(1)
False
>>> is_even(2)
True
>>>
Quackery
[ 1 & ] is odd ( n --> b )
[ odd not ] is even ( n --> b )
- Output:
In the Quackery shell (REPL):
/O> 10 even ... 10 odd ... 11 even ... 11 odd ... Stack: 1 0 0 1
Quackery: With Anonymous Mutual Recursion
Adapted from the example code at wp:Mutual recursion#Basic examples, with the additional observation that the parity of a negative number is the same as the parity of its absolute value.
See also Mutual recursion#Quackery and Anonymous recursion#Quackery.
[ abs
' [ dup 0 = iff
[ 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 )
11 times
[ i^ 5 - dup echo
say " is "
even iff [ $ "even" ]
else [ $ "odd" ]
echo$ say "." cr ]
- 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.
R
is.even <- function(x) !is.odd(x)
is.odd <- function(x) intToBits(x)[1] == 1
#or
is.odd <- function(x) x %% 2 == 1
Racket
With built in predicates:
(even? 6) ; -> true
(even? 5) ; -> false
(odd? 6) ; -> false
(odd? 5) ; -> true
With modular arithmetic:
(define (my-even? x)
(= (modulo x 2) 0))
(define (my-odd? x)
(= (modulo x 2) 1))
With mutually recursive functions:
(define (even-or-odd? i)
(letrec ([even? (λ (n)
(if (= n 0)
'even
(odd? (sub1 n))))]
[odd? (λ (n)
(if (= n 0)
'odd
(even? (sub1 n))))])
(even? i)))
(even-or-odd? 100) ; => 'even
(even-or-odd? 101) ; => 'odd
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 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 )
Rascal
public bool isEven(int n) = (n % 2) == 0;
public bool isOdd(int n) = (n % 2) == 1;
Or with block quotes:
public bool isEven(int n){return (n % 2) == 0;}
public bool isOdd(int n){return (n % 2) == 1;}
RATFOR
program evenodd
integer a
write(*,101,ADVANCE="NO")
read(*,102)a
if (mod(a,2) .eq. 0) write(*,103)a
else write(*,104)a
101 format("Enter a number: ")
102 format(i7)
103 format(i7," Is Even.")
104 format(i7," Is Odd.")
end
Rapira
fun is_even(n)
return (n /% 2) = 0
end
Red
Red [
date: 2021-10-24
red-version: 0.6.4
description: "Test whether an integer is even or odd."
]
print even? 10 ;== true
print odd? 10 ;== false
ReScript
let is_even = d => mod(d, 2) == 0
let is_odd = d => mod(d, 2) != 0
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 1st 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).
/*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
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
size = 10
for i = 1 to size
if i % 2 = 1 see "" + i + " is odd" + nl
else see "" + i + " is even" + nl ok
next
RPL
To test oddity of real numbers (floating point numbers) :
≪ 2 MOD ≫ ‘ODD?’ STO
To test oddity of binary integers (unsigned integers) :
≪ #1 AND #1 ≠ ≫ ‘BODD?’ STO
To test oddity without caring of the data type :
≪ IF DUP TYPE THEN #1 AND #1 ≠ ELSE 2 MOD END ≫
- Input:
47 ODD? #Fh BODD?
- Output:
2: 1 1: 1
Ruby
In Ruby, integers behave like objects, so they respond to methods like : 5.even? resulting to false
print "evens: "
p -5.upto(5).select(&:even?)
print "odds: "
p -5.upto(5).select(&:odd?)
- Output:
evens: [-4, -2, 0, 2, 4] odds: [-5, -3, -1, 1, 3, 5]
Other ways to test even-ness:
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?
Rust
Checking the least significant digit:
let is_odd = |x: i32| x & 1 == 1;
let is_even = |x: i32| x & 1 == 0;
Using modular congruences:
let is_odd = |x: i32| x % 2 != 0;
let is_even = |x: i32| x % 2 == 0;
Scala
def isEven( v:Int ) : Boolean = v % 2 == 0
def isOdd( v:Int ) : Boolean = v % 2 != 0
Accept any numeric type as an argument:
def isEven( v:Number ) : Boolean = v.longValue % 2 == 0
def isOdd( v:Number ) : Boolean = v.longValue % 2 != 0
- 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 (R4RS, R5RS, and R6RS):
> (even? 5)
#f
> (even? 42)
#t
> (odd? 5)
#t
> (odd? 42)
#f
sed
s/[02468]$/& is even/
s/[13579]$/& is odd/
- Output:
$ seq -18 7 17 | sed -f even_or_odd.sed -18 is even -11 is odd -4 is even 3 is odd 10 is even 17 is odd
Seed7
Test whether an integer or bigInteger is odd:
odd(aNumber)
Test whether an integer or bigInteger is even:
not odd(aNumber)
SenseTalk
set num to random of 100 -- start with a random number from 1 to 100
// use the 'is a' operator to test the value
if num is an odd number then put num & " is odd"
// see if num is divisible by 2
if num is divisible by 2 then put num & " is even (is divisible by 2)"
// 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)"
SequenceL
even(x) := x mod 2 = 0;
odd(x) := x mod 2 = 1;
- 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]
SETL
SETL provides built-in even and odd functions. This short program illustrates their use.
xs := {1..10};
evens := {x in xs | even( x )};
odds := {x in xs | odd( x )};
print( evens );
print( odds );
- Output:
{2 4 6 8 10} {1 3 5 7 9}
Shen
Mutual Recursion:
(define even?
0 -> true
X -> (odd? (- X 1)))
(define odd?
0 -> false
X -> (even? (- X 1)))
Modulo:
(define even? X -> (= 0 (shen.mod X 2)))
(define odd? X -> (not (= 0 (shen.mod X 2))))
Sidef
Built-in methods:
var n = 42;
say n.is_odd; # false
say n.is_even; # true
Checking the last significant digit:
func is_odd(n) { n&1 == 1 };
func is_even(n) { n&1 == 0 };
Using modular congruences:
func is_odd(n) { n%2 == 1 };
func is_even(n) { n%2 == 0 };
Smalltalk
Using the built in methods on Number class:
5 even
5 odd
even is implemented as follows:
Number>>even
^((self digitAt: 1) bitAnd: 1) = 0
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
- Output:
-2 is even-1 is odd 0 is even 1 is odd 2 is even
SNUSP
$====!/?\==even#
- -
#odd==\?/
SPL
> n, 0..9
? #.even(n), #.output(n," even")
? #.odd(n), #.output(n," odd")
<
- Output:
0 even 1 odd 2 even 3 odd 4 even 5 odd 6 even 7 odd 8 even 9 odd
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)".
-- 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;
- 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 into storage address 15. The first three instructions test whether 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 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 , 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.
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
Standard ML
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;
Stata
mata
function iseven(n) {
return(mod(n,2)==0)
}
function isodd(n) {
return(mod(n,2)==1)
}
end
Swift
func isEven(n:Int) -> Bool {
// Bitwise check
if (n & 1 != 0) {
return false
}
// Mod check
if (n % 2 != 0) {
return false
}
return true
}
Swift
// Swift has Int.isMultiple(of:Int) -> Bool
var isEven: (_:Int) -> Bool = {$0.isMultiple(of: 2)}
Symsyn
n : 23
if n bit 0
'n is odd' []
else
'n is even' []
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)]
- Output:
# O E 24:0,1 49:1,0
TI-57
This routine returns the remainder of the division by 2 of the number in the display register. It is therefore a kind of is_odd(x) function.
Lbl 9 / 2 - CE Int = × 2 = INV SBR
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
- 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
UNIX Shell
is_even() {
return $(($1 & 1))
}
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
Output:
123 odd
உயிர்/Uyir
முதன்மை என்பதின் வகை எண் பணி {{
எ இன் வகை எண்{$5} = 0;
படை வகை சரம்;
"எண்ணைக் கொடுங்கள்? ") ஐ திரை.இடு;
எ = எண்{$5} ஐ விசை.எடு;
ஒருக்கால் (எ.இருமம்(0) == 1) ஆகில் {
படை = "ஒற்றை";
} இல்லையேல் {
படை = "இரட்டை ";
}
{எ, " ஒரு ", படை, "ப்படை எண் ஆகும்"} என்பதை திரை.இடு;
முதன்மை = 0;
}};
Verilog
module main;
integer i;
initial begin
for (i = 1; i <= 10; i = i+1) begin
if (i % 2 == 0) $display(i, " is even");
else $display(i, " is odd");
end
$finish ;
end
endmodule
V (Vlang)
fn test(n i64) {
print('Testing integer $n')
if n&1 == 0 {
print(' even')
}else{
print(' odd')
}
if n%2 == 0 {
println(' even')
}else{
println(' odd')
}
}
fn main(){
test(-2)
test(-1)
test(0)
test(1)
test(2)
}
- 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
WDTE
let s => import 'stream';
let str => import 'strings';
let evenOrOdd n => (
let even n => == (% n 2) 0;
switch n {
even => 'even';
default => 'odd';
};
);
s.range 10
-> s.map (@ s n => str.format '{} is {}.' n (evenOrOdd n))
-> s.map (io.writeln io.stdout)
-> s.drain;
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).
(module
;; function isOdd: returns 1 if its argument is odd, 0 if it is even.
(func $isOdd (param $n i32) (result i32)
get_local $n
i32.const 1
i32.and ;; computes (n & 1), i.e. returns low bit of n
)
(export "isOdd" (func $isOdd))
)
Wren
import "./fmt" for Fmt
var isEven1 = Fn.new { |i| i & 1 == 0 }
var isEven2 = Fn.new { |i| i % 2 == 0 }
var tests = [10, 11, 0, 57, 34, -23, -42]
System.print("Tests : %(Fmt.v("s", -4, tests, 0, " ", ""))")
var res1 = tests.map { |t| isEven1.call(t) ? "even" : "odd" }.toList
System.print("Method 1 : %(Fmt.v("s", -4, res1, 0, " ", ""))")
var res2 = tests.map { |t| isEven2.call(t) ? "even" : "odd" }.toList
System.print("Method 2 : %(Fmt.v("s", -4, res2, 0, " ", ""))")
- Output:
Tests : 10 11 0 57 34 -23 -42 Method 1 : even odd even odd even odd even Method 2 : even odd even odd even odd even
x86-64 Assembly
evenOdd:
mov rax,1
and rax,rdi
ret
XBS
#>
Typed XBS
evenOrOdd function
true = even
false = odd
<#
func evenOrOdd(a:number=0){
send a%2==0;
}
set arr:array = [0,1,2,3,4,5,6,7,9,10];
foreach(v of arr){
log(v+" is even? "+evenOrOdd(v))
}
- Output:
0 is even? true 1 is even? false 2 is even? true 3 is even? false 4 is even? true 5 is even? false 6 is even? true 7 is even? false 9 is even? false 10 is even? true
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
XLISP
XLISP provides EVENP and ODDP, or, if you prefer, EVEN? and ODD?; if one wanted to reimplement them, it could be done like this (or in other ways).
(defun my-evenp (x)
(= (logand x 1) 0) )
(defun my-oddp (x)
(/= (logand x 1) 0) )
Xojo
For num As Integer = 1 To 5
If num Mod 2 = 0 Then
MsgBox(Str(num) + " is even.")
Else
MsgBox(Str(num) + " is odd.")
End If
Next
- Output:
1 is odd. 2 is even. 3 is odd. 4 is even. 5 is odd.
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);
];
]
- 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
Z80 Assembly
Z80 Assembly has a few ways of testing if a number is even or odd:
RRC
A right rotate will set the carry if the register's value is odd and clear it if it's even. This does alter the contents of the register, so only use this method if you don't need to remember the number being tested after getting the results of the test. This is the fastest way the Z80 can test a value for even or odd, but only when testing the accumulator A
rrca
jp nc,isEven
SRA/SRL
In similar vein, there are also shift instructions. The arithmetic shift instruction retains the sign bit (bit 7) of the operand in question, while the logical shift sets bit 7 to 0.
sra a
jp nc,isEven
AND
AND 1
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 RRC
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.
and &01
jp z,isEven
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!
bit 0,c
jp z,C_IS_EVEN
zkl
[-3..4].pump(fcn(n){ println(n," is ",n.isEven and "even" or "odd") })
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
[-3..4].apply("isEven").println();
- Output:
L(False,True,False,True,False,True,False,True)
Zoea
program: even_or_odd
case: 1
input: 2
output: even
case: 2
input: 4
output: even
case: 3
input: 1
output: odd
case: 4
input: 7
output: odd
Zoea Visual
zonnon
module Main;
var
x: integer;
s: set;
begin
x := 10;writeln(x:3," is odd?",odd(x));
s := set(s);writeln(x:3," is odd?",0 in s); (* check right bit *)
x := 11;writeln(x:3," is odd?",odd(x));
s := set(x);writeln(x:3," is odd?",0 in s); (* check right bit *)
end Main.
- Output:
10 is odd? false 10 is odd? false 11 is odd? true 11 is odd? true
- Programming Tasks
- Solutions by Programming Task
- Simple
- 0815
- 11l
- 6502 Assembly
- 68000 Assembly
- 8080 Assembly
- 8086 Assembly
- 8th
- AArch64 Assembly
- ABAP
- Action!
- Ada
- Agda
- Aime
- ALGOL 68
- ALGOL-M
- ALGOL W
- AntLang
- APL
- AppleScript
- Arendelle
- ARM Assembly
- ArnoldC
- Arturo
- Asymptote
- AutoHotkey
- AWK
- BASIC
- Applesoft BASIC
- BaCon
- BASIC256
- BBC BASIC
- Chipmunk Basic
- Commodore BASIC
- FreeBASIC
- Gambas
- GW-BASIC
- IS-BASIC
- Liberty BASIC
- Minimal BASIC
- MSX Basic
- PureBasic
- QB64
- QBasic
- Quite BASIC
- Run BASIC
- S-BASIC
- SmallBASIC
- TI-83 BASIC
- Tiny BASIC
- True BASIC
- VBA
- VBScript
- Visual Basic .NET
- System.Numerics
- XBasic
- Yabasic
- ZX Spectrum Basic
- Batch File
- Bc
- Beads
- Befunge
- Binary Lambda Calculus
- BQN
- Bracmat
- Brainf***
- Burlesque
- C
- C sharp
- C++
- Clojure
- COBOL
- CoffeeScript
- ColdFusion
- Common Lisp
- Component Pascal
- Crystal
- D
- Dart
- Dc
- DCL
- Delphi
- Déjà Vu
- Diego
- DWScript
- EasyLang
- Ed
- EDSAC order code
- Eiffel
- Elixir
- Emacs Lisp
- EMal
- Erlang
- ERRE
- Euphoria
- Excel
- F Sharp
- Factor
- Fish
- Forth
- Fortran
- Frink
- Futhark
- Futhark examples needing attention
- Examples needing attention
- FutureBasic
- Fōrmulæ
- GAP
- Genie
- Go
- Groovy
- Haskell
- Hoon
- Icon
- Unicon
- Insitux
- J
- Jakt
- Java
- JavaScript
- Joy
- Jq
- Jsish
- Julia
- K
- Klingphix
- Kotlin
- Lambdatalk
- L++
- LabVIEW
- Lang5
- Lasso
- LC3 Assembly
- Lingo
- Little Man Computer
- LiveCode
- LLVM
- Logo
- Logtalk
- LOLCODE
- Lua
- M2000 Interpreter
- M4
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Octave
- Maxima
- MAXScript
- Mercury
- Min
- MiniScript
- MIPS Assembly
- МК-61/52
- ML
- MLite
- Modula-2
- Nanoquery
- Neko
- NESL
- NetRexx
- Never
- NewLISP
- Nim
- Nu
- Oberon-2
- Objeck
- OCaml
- Oforth
- Ol
- OOC
- PARI/GP
- PascalABC.NET
- Pascal
- Perl
- Phix
- Phixmonti
- PHP
- Picat
- PicoLisp
- Pike
- PL/I
- PL/M
- Plain English
- PowerShell
- Processing
- Prolog
- Python
- Quackery
- R
- Racket
- Raku
- Rascal
- RATFOR
- Rapira
- Red
- ReScript
- REXX
- Ring
- RPL
- Ruby
- Rust
- Scala
- Scheme
- Sed
- Seed7
- SenseTalk
- SequenceL
- SETL
- Shen
- Sidef
- Smalltalk
- SNOBOL4
- SNUSP
- SPL
- SQL
- SSEM
- Standard ML
- Stata
- Swift
- Symsyn
- Tcl
- TI-57
- TUSCRIPT
- UNIX Shell
- Ursa
- உயிர்/Uyir
- Verilog
- V (Vlang)
- WDTE
- WebAssembly
- Wren
- Wren-fmt
- X86-64 Assembly
- XBS
- XEec
- XLISP
- Xojo
- XPL0
- Z80 Assembly
- Zkl
- Zoea
- Zoea Visual
- Zonnon
- Pages with too many expensive parser function calls