Integer comparison: Difference between revisions
Add SmallBASIC |
|||
(18 intermediate revisions by 13 users not shown) | |||
Line 21: | Line 21: | ||
=={{header|11l}}== |
=={{header|11l}}== |
||
< |
<syntaxhighlight lang="11l">V a = Int(input(‘Enter value of a: ’)) |
||
V b = Int(input(‘Enter value of b: ’)) |
V b = Int(input(‘Enter value of b: ’)) |
||
Line 29: | Line 29: | ||
print(‘a is greater than b’) |
print(‘a is greater than b’) |
||
I a == b |
I a == b |
||
print(‘a is equal to b’)</ |
print(‘a is equal to b’)</syntaxhighlight> |
||
=={{header|360 Assembly}}== |
=={{header|360 Assembly}}== |
||
Input is done by a standard register 1 pointed parameter list. |
Input is done by a standard register 1 pointed parameter list. |
||
< |
<syntaxhighlight lang="360asm">INTCOMP PROLOG |
||
* Reg1=Addr(Addr(argA),Addr(argB)) |
* Reg1=Addr(Addr(argA),Addr(argB)) |
||
L 2,0(1) Reg2=Addr(argA) |
L 2,0(1) Reg2=Addr(argA) |
||
Line 65: | Line 65: | ||
A DS F 31-bit signed integer |
A DS F 31-bit signed integer |
||
B DS F 31-bit signed integer |
B DS F 31-bit signed integer |
||
END</ |
END</syntaxhighlight> |
||
=={{header|6502 Assembly}}== |
=={{header|6502 Assembly}}== |
||
Line 71: | Line 71: | ||
Specific OS/hardware routines for user input and printing are left unimplemented. |
Specific OS/hardware routines for user input and printing are left unimplemented. |
||
It should be noted that this is strictly an unsigned comparison. |
It should be noted that this is strictly an unsigned comparison. |
||
< |
<syntaxhighlight lang="6502asm">Compare PHA ;push Accumulator onto stack |
||
JSR GetUserInput ;routine not implemented |
JSR GetUserInput ;routine not implemented |
||
;integers to compare now in memory locations A and B |
;integers to compare now in memory locations A and B |
||
Line 85: | Line 85: | ||
A_equals_B: JSR DisplayAEqualsB ;routine not implemented |
A_equals_B: JSR DisplayAEqualsB ;routine not implemented |
||
Done: PLA ;restore Accumulator from stack |
Done: PLA ;restore Accumulator from stack |
||
RTS ;return from subroutine</ |
RTS ;return from subroutine</syntaxhighlight> |
||
=={{header|68000 Assembly}}== |
=={{header|68000 Assembly}}== |
||
Line 93: | Line 93: | ||
===Unsigned Comparison=== |
===Unsigned Comparison=== |
||
< |
<syntaxhighlight lang="68000devpac">Compare: |
||
;integers to compare are in D0 and D1 |
;integers to compare are in D0 and D1 |
||
CMP.L D1,D0 |
CMP.L D1,D0 |
||
Line 118: | Line 118: | ||
Equal: |
Equal: |
||
dc.b "both are equal",0 |
dc.b "both are equal",0 |
||
even</ |
even</syntaxhighlight> |
||
===Signed Comparison=== |
===Signed Comparison=== |
||
< |
<syntaxhighlight lang="68000devpac">Compare: |
||
;integers to compare are in D0 and D1 |
;integers to compare are in D0 and D1 |
||
CMP.L D1,D0 |
CMP.L D1,D0 |
||
Line 146: | Line 146: | ||
Equal: |
Equal: |
||
dc.b "both are equal",0 |
dc.b "both are equal",0 |
||
even</ |
even</syntaxhighlight> |
||
=={{header|8051 Assembly}}== |
=={{header|8051 Assembly}}== |
||
Input/output is specific to hardware; this code assumes the integers are in registers a and b. |
Input/output is specific to hardware; this code assumes the integers are in registers a and b. |
||
There is only one comparison instruction to use: 'not equal'. |
There is only one comparison instruction to use: 'not equal'. |
||
< |
<syntaxhighlight lang="asm">compare: |
||
push psw |
push psw |
||
cjne a, b, clt |
cjne a, b, clt |
||
Line 167: | Line 167: | ||
compare_: |
compare_: |
||
pop psw |
pop psw |
||
ret</ |
ret</syntaxhighlight> |
||
Testing for (a <= b) or (a >= b) can be performed by changing the jumps. |
Testing for (a <= b) or (a >= b) can be performed by changing the jumps. |
||
=={{header|8th}}== |
=={{header|8th}}== |
||
The user would put the numbers on the stack and then invoke 'compare': |
The user would put the numbers on the stack and then invoke 'compare': |
||
< |
<syntaxhighlight lang="forth"> |
||
: compare \ n m -- |
: compare \ n m -- |
||
2dup n:= if "They are equal" . cr then |
2dup n:= if "They are equal" . cr then |
||
2dup n:< if "First less than second" . cr then |
2dup n:< if "First less than second" . cr then |
||
n:> if "First greater than second" . cr then ; |
n:> if "First greater than second" . cr then ; |
||
</syntaxhighlight> |
|||
</lang> |
|||
Alternatively one could use the "n:cmp" word |
Alternatively one could use the "n:cmp" word |
||
Line 183: | Line 183: | ||
{{works with|aarch64-linux-gnu-as/qemu-aarch64}} |
{{works with|aarch64-linux-gnu-as/qemu-aarch64}} |
||
Compare once (<code>cmp x0, x1</code>) and use conditional branching (<code>b.eq</code> and <code>b.gt</code>). |
Compare once (<code>cmp x0, x1</code>) and use conditional branching (<code>b.eq</code> and <code>b.gt</code>). |
||
< |
<syntaxhighlight lang="arm_assembly">.equ STDOUT, 1 |
||
.equ SVC_WRITE, 64 |
.equ SVC_WRITE, 64 |
||
.equ SVC_EXIT, 93 |
.equ SVC_EXIT, 93 |
||
Line 246: | Line 246: | ||
_exit: |
_exit: |
||
mov x8, #SVC_EXIT |
mov x8, #SVC_EXIT |
||
svc #0</ |
svc #0</syntaxhighlight> |
||
=={{header|ABAP}}== |
=={{header|ABAP}}== |
||
This works in ABAP version 7.40 and above. Note that empty input is evaluated to 0. |
This works in ABAP version 7.40 and above. Note that empty input is evaluated to 0. |
||
<syntaxhighlight lang="abap"> |
|||
<lang ABAP> |
|||
report z_integer_comparison. |
report z_integer_comparison. |
||
Line 265: | Line 265: | ||
write comparison_result. |
write comparison_result. |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Action!}}== |
=={{header|Action!}}== |
||
< |
<syntaxhighlight lang="action!">PROC Main() |
||
INT a,b |
INT a,b |
||
Line 283: | Line 283: | ||
PrintF("%I is equal to %I%E",a,b) |
PrintF("%I is equal to %I%E",a,b) |
||
FI |
FI |
||
RETURN</ |
RETURN</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Integer_comparison.png Screenshot from Atari 8-bit computer] |
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Integer_comparison.png Screenshot from Atari 8-bit computer] |
||
Line 293: | Line 293: | ||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
< |
<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO; |
||
with Ada.Integer_Text_IO; use Ada.Integer_Text_Io; |
with Ada.Integer_Text_IO; use Ada.Integer_Text_Io; |
||
Line 316: | Line 316: | ||
Put_Line("A is greater than B"); |
Put_Line("A is greater than B"); |
||
end if; |
end if; |
||
end Compare_Ints;</ |
end Compare_Ints;</syntaxhighlight> |
||
=={{header|Aime}}== |
=={{header|Aime}}== |
||
< |
<syntaxhighlight lang="aime">void |
||
output(integer a, integer b, text condition) |
output(integer a, integer b, text condition) |
||
{ |
{ |
||
Line 345: | Line 345: | ||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
Run as: |
Run as: |
||
<pre>aime FILE integer a 33 integer b 133</pre> |
<pre>aime FILE integer a 33 integer b 133</pre> |
||
Line 363: | Line 363: | ||
The above distributions of both [[ALGOL 68G]] and [[ELLA ALGOL 68]] compilers only |
The above distributions of both [[ALGOL 68G]] and [[ELLA ALGOL 68]] compilers only |
||
allow [[wp:ASCII|ASCII]] characters (ASCII has neither "≤", "≥" nor "≠" characters). |
allow [[wp:ASCII|ASCII]] characters (ASCII has neither "≤", "≥" nor "≠" characters). |
||
< |
<syntaxhighlight lang="algol68">main: ( |
||
INT a, b; |
INT a, b; |
||
read((a, space, b, new line)); |
read((a, space, b, new line)); |
||
Line 383: | Line 383: | ||
print((a," is greater or equal to ", b, new line)) |
print((a," is greater or equal to ", b, new line)) |
||
FI |
FI |
||
)</ |
)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 392: | Line 392: | ||
=={{header|ALGOL W}}== |
=={{header|ALGOL W}}== |
||
< |
<syntaxhighlight lang="algolw">begin |
||
integer a, b; |
integer a, b; |
||
Line 405: | Line 405: | ||
if a > b then write( a, " is greater than ", b ); |
if a > b then write( a, " is greater than ", b ); |
||
end.</ |
end.</syntaxhighlight> |
||
=={{header|AppleScript}}== |
=={{header|AppleScript}}== |
||
< |
<syntaxhighlight lang="applescript">set n1 to text returned of (display dialog "Enter the first number:" default answer "") as integer |
||
set n2 to text returned of (display dialog "Enter the second number:" default answer "") as integer |
set n2 to text returned of (display dialog "Enter the second number:" default answer "") as integer |
||
set msg to {n1} |
set msg to {n1} |
||
Line 419: | Line 419: | ||
end if |
end if |
||
set end of msg to n2 |
set end of msg to n2 |
||
return msg as string</ |
return msg as string</syntaxhighlight> |
||
Or... |
Or... |
||
< |
<syntaxhighlight lang="applescript">set n1 to text returned of (display dialog "Enter the first number:" default answer "") as integer |
||
set n2 to text returned of (display dialog "Enter the second number:" default answer "") as integer |
set n2 to text returned of (display dialog "Enter the second number:" default answer "") as integer |
||
if n1 < n2 then return "" & n1 & " is less than " & n2 |
if n1 < n2 then return "" & n1 & " is less than " & n2 |
||
if n1 = n2 then return "" & n1 & " is equal to " & n2 |
if n1 = n2 then return "" & n1 & " is equal to " & n2 |
||
if n1 > n2 then return "" & n1 & " is greater than " & n2</ |
if n1 > n2 then return "" & n1 & " is greater than " & n2</syntaxhighlight> |
||
=={{header|ARM Assembly}}== |
=={{header|ARM Assembly}}== |
||
{{works with|as|Raspberry Pi}} |
{{works with|as|Raspberry Pi}} |
||
<syntaxhighlight lang="arm assembly"> |
|||
<lang ARM Assembly> |
|||
/* ARM assembly Raspberry PI */ |
/* ARM assembly Raspberry PI */ |
||
Line 614: | Line 614: | ||
szMessErrDep: .asciz "Too large: overflow 32 bits.\n" |
szMessErrDep: .asciz "Too large: overflow 32 bits.\n" |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Arturo}}== |
=={{header|Arturo}}== |
||
< |
<syntaxhighlight lang="rebol">a: to :integer input "enter a value for a: " |
||
b: to :integer input "enter a value for b: " |
b: to :integer input "enter a value for b: " |
||
if a<b [ print [ a "is less than" b ] ] |
if a<b [ print [ a "is less than" b ] ] |
||
if a>b [ print [ a "is greater than" b ] ] |
if a>b [ print [ a "is greater than" b ] ] |
||
if a=b [ print [ a "is equal to" b ] ]</ |
if a=b [ print [ a "is equal to" b ] ]</syntaxhighlight> |
||
=={{header|Astro}}== |
=={{header|Astro}}== |
||
< |
<syntaxhighlight lang="python">let a = input('Enter value of a: ') |
||
let b = input('Enter value of b: ') |
let b = input('Enter value of b: ') |
||
Line 633: | Line 633: | ||
print 'a is greater than b' |
print 'a is greater than b' |
||
elif a == b: |
elif a == b: |
||
print 'a is equal to b'</ |
print 'a is equal to b'</syntaxhighlight> |
||
=={{header|AutoHotkey}}== |
=={{header|AutoHotkey}}== |
||
Error checking is performed automatically by attaching UpDowns to each of the Edit controls. UpDown controls always yield an in-range number, even when the user has typed something non-numeric or out-of-range in the Edit control. |
Error checking is performed automatically by attaching UpDowns to each of the Edit controls. UpDown controls always yield an in-range number, even when the user has typed something non-numeric or out-of-range in the Edit control. |
||
The default range is 0 to 100. |
The default range is 0 to 100. |
||
< |
<syntaxhighlight lang="autohotkey">Gui, Add, Edit |
||
Gui, Add, UpDown, vVar1 |
Gui, Add, UpDown, vVar1 |
||
Gui, Add, Edit |
Gui, Add, Edit |
||
Line 657: | Line 657: | ||
GuiClose: |
GuiClose: |
||
ExitApp</ |
ExitApp</syntaxhighlight> |
||
=={{header|Avail}}== |
=={{header|Avail}}== |
||
< |
<syntaxhighlight lang="avail">// This code doesn't try to protect against any malformed input. |
||
a ::= next line from standard input→integer; |
a ::= next line from standard input→integer; |
||
b ::= next line from standard input→integer; |
b ::= next line from standard input→integer; |
||
If a > b then [Print: "a > b";] |
If a > b then [Print: "a > b";] |
||
else if a < b then [Print: "a < b";] |
else if a < b then [Print: "a < b";] |
||
else if a = b then [Print: "a = b";];</ |
else if a = b then [Print: "a = b";];</syntaxhighlight> |
||
=={{header|AWK}}== |
=={{header|AWK}}== |
||
< |
<syntaxhighlight lang="awk">/[0-9]* [0-9]*/{ |
||
if ($1 == $2) print $1, "is equal to", $2 |
if ($1 == $2) print $1, "is equal to", $2 |
||
if ($1 < $2) print $1, "is less than", $2 |
if ($1 < $2) print $1, "is less than", $2 |
||
if ($1 > $2) print $1, "is greater than", $2 |
if ($1 > $2) print $1, "is greater than", $2 |
||
}</ |
}</syntaxhighlight> |
||
In awk, a double equals symbol is required to test for equality. |
In awk, a double equals symbol is required to test for equality. |
||
A single equals sign is used for assignment, and will cause a bug if it is used within a boolean expression: |
A single equals sign is used for assignment, and will cause a bug if it is used within a boolean expression: |
||
< |
<syntaxhighlight lang="awk"># This code contains a bug |
||
IF (n=3) PRINT "n is equal to 3" # The incorrectly used equals sign will set n to a value of 3</ |
IF (n=3) PRINT "n is equal to 3" # The incorrectly used equals sign will set n to a value of 3</syntaxhighlight> |
||
=={{header|Axe}}== |
=={{header|Axe}}== |
||
< |
<syntaxhighlight lang="axe">Lbl FUNC |
||
If r₁<r₂ |
If r₁<r₂ |
||
Disp "LESS THAN",i |
Disp "LESS THAN",i |
||
Line 691: | Line 691: | ||
Disp "GREATER THAN",i |
Disp "GREATER THAN",i |
||
End |
End |
||
Return</ |
Return</syntaxhighlight> |
||
=={{header|BASIC}}== |
=={{header|BASIC}}== |
||
==={{header|Applesoft BASIC}}=== |
|||
<syntaxhighlight lang="applesoftbasic">10 INPUT "ENTER TWO INTEGERS: "; A%, B% |
|||
20 A$(0) = "NOT " |
|||
30 PRINT A% " IS " A$(A% < B%) "LESS THAN " B% |
|||
40 PRINT A% " IS " A$(A% = B%) "EQUAL TO " B% |
|||
50 PRINT A% " IS " A$(A% > B%) "GREATER THAN " B%</syntaxhighlight> |
|||
==={{header|BaCon}}=== |
==={{header|BaCon}}=== |
||
< |
<syntaxhighlight lang="freebasic"> |
||
INPUT "Enter first number " ,a |
INPUT "Enter first number " ,a |
||
INPUT "Enter second number " ,b |
INPUT "Enter second number " ,b |
||
IF a < b THEN PRINT a ," is less than ", b |
IF a < b THEN PRINT a ," is less than ", b |
||
IF a = b THEN PRINT a, " is equal to ", b |
IF a = b THEN PRINT a, " is equal to ", b |
||
IF a > b THEN PRINT a, " is greater than ", b</ |
IF a > b THEN PRINT a, " is greater than ", b</syntaxhighlight> |
||
{{works with|QuickBasic|4.5}} |
{{works with|QuickBasic|4.5}} |
||
< |
<syntaxhighlight lang="qbasic">CLS |
||
INPUT "a, b"; a, b 'remember to type the comma when you give the numbers |
INPUT "a, b"; a, b 'remember to type the comma when you give the numbers |
||
PRINT "a is "; |
PRINT "a is "; |
||
Line 711: | Line 716: | ||
IF a = b THEN PRINT "equal to "; |
IF a = b THEN PRINT "equal to "; |
||
IF a > b THEN PRINT "greater than "; |
IF a > b THEN PRINT "greater than "; |
||
PRINT "b"</ |
PRINT "b"</syntaxhighlight> |
||
==={{header| |
==={{header|BASIC256}}=== |
||
<syntaxhighlight lang="freebasic">input "Please enter one integer: ", x |
|||
<lang ApplesoftBasic>10 INPUT "ENTER TWO INTEGERS: "; A%, B% |
|||
input "and a second integer: ", y |
|||
20 A$(0) = "NOT " |
|||
if x < y then print x; " is less than "; y |
|||
if x = y then print x; " is equal to "; y |
|||
if x > y then print x; " is greater than "; y</syntaxhighlight> |
|||
==={{header|BBC BASIC}}=== |
|||
<syntaxhighlight lang="bbcbasic"> INPUT "Enter two numbers separated by a comma: " a, b |
|||
CASE TRUE OF |
|||
WHEN a < b: PRINT ;a " is less than "; b |
|||
WHEN a = b: PRINT ;a " is equal to "; b |
|||
WHEN a > b: PRINT ;a " is greater than "; b |
|||
ENDCASE</syntaxhighlight> |
|||
==={{header|FreeBASIC}}=== |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
Dim As Integer x, y |
|||
Input "Please enter two integers, separated by a comma : ", x , y |
|||
If x < y Then |
|||
Print x; " is less than "; y |
|||
End If |
|||
If x = y Then |
|||
Print x; " is equal to "; y |
|||
End If |
|||
If x > y Then |
|||
Print x; " is greater than "; y |
|||
End If |
|||
Print |
|||
Print "Press any key to exit" |
|||
Sleep</syntaxhighlight> |
|||
==={{header|FutureBasic}}=== |
|||
Note: Strictly speaking, it's preferable to use "==" when comparing integers as seen in this example. While the "=" sign will work as a comparison in most cases, technically it should be used for assignment, i.e. a = 3 when a is assigned the value of 3, as contrasted with a == 3, where the value of a is being compared with 3. FB will flag a warning when "==" is used to compare two single, doubles or floats since comparing real numbers can be inaccurate. |
|||
<syntaxhighlight lang="futurebasic">_window = 1 |
|||
begin enum 1 |
|||
_integer1Fld |
|||
_integer2Fld |
|||
_compareBtn |
|||
_messageLabel |
|||
end enum |
|||
local fn BuildWindow |
|||
window _window, @"Integer Comparison", (0,0,356,85) |
|||
textfield _integer1Fld,,, (20,44,112,21) |
|||
TextFieldSetPlaceholderString( _integer1Fld, @"Integer 1" ) |
|||
textfield _integer2Fld,,, (140,44,112,21) |
|||
TextFieldSetPlaceholderString( _integer2Fld, @"Integer 2" ) |
|||
button _compareBtn,,, @"Compare", (253,38,90,32) |
|||
textlabel _messageLabel,, (18,20,320,16) |
|||
ControlSetAlignment( _messageLabel, NSTextAlignmentCenter ) |
|||
end fn |
|||
local fn DoDialog( ev as long, tag as long ) |
|||
long int1, int2 |
|||
select ( ev ) |
|||
case _btnClick |
|||
select ( tag ) |
|||
case _compareBtn |
|||
int1 = fn ControlIntegerValue( _integer1Fld ) |
|||
int2 = fn ControlIntegerValue( _integer2Fld ) |
|||
if ( int1 < int2 ) then textlabel _messageLabel, @"The first integer is less than the second integer." |
|||
if ( int1 == int2 ) then textlabel _messageLabel, @"The first integer is equal to the second integer." |
|||
if ( int1 > int2 ) then textlabel _messageLabel, @"The first integer is greater than the second integer." |
|||
end select |
|||
case _controlTextDidChange |
|||
textlabel _messageLabel, @"" |
|||
end select |
|||
end fn |
|||
fn BuildWindow |
|||
on dialog fn DoDialog |
|||
HandleEvents</syntaxhighlight> |
|||
==={{header|Gambas}}=== |
|||
<syntaxhighlight lang="gambas">Public Sub Form_Open() |
|||
Dim sIn As String = InputBox("Enter 2 integers seperated by a comma") |
|||
Dim iFirst, iSecond As Integer |
|||
iFirst = Val(Split(sIn)[0]) |
|||
iSecond = Val(Split(sIn)[1]) |
|||
If iFirst < iSecond Then Print iFirst & " is smaller than " & iSecond & gb.NewLine |
|||
If iFirst > iSecond Then Print iFirst & " is greater than " & iSecond & gb.NewLine |
|||
If iFirst = iSecond Then Print iFirst & " is equal to " & iSecond |
|||
End</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
21 is greater than 18 |
|||
</pre> |
|||
==={{header|IS-BASIC}}=== |
==={{header|IS-BASIC}}=== |
||
< |
<syntaxhighlight lang="is-basic">100 INPUT PROMPT "Enter A: ":A |
||
110 INPUT PROMPT "Enter B: ":B |
110 INPUT PROMPT "Enter B: ":B |
||
120 IF A<B THEN |
120 IF A<B THEN |
||
Line 729: | Line 834: | ||
160 ELSE |
160 ELSE |
||
170 PRINT A;"is greater than ";B |
170 PRINT A;"is greater than ";B |
||
180 END IF</ |
180 END IF</syntaxhighlight> |
||
or |
or |
||
< |
<syntaxhighlight lang="is-basic">100 INPUT PROMPT "Enter A: ":A |
||
110 INPUT PROMPT "Enter B: ":B |
110 INPUT PROMPT "Enter B: ":B |
||
120 SELECT CASE A |
120 SELECT CASE A |
||
Line 742: | Line 847: | ||
170 CASE ELSE |
170 CASE ELSE |
||
180 PRINT A;"is greater than ";B |
180 PRINT A;"is greater than ";B |
||
190 END SELECT</ |
190 END SELECT</syntaxhighlight> |
||
==={{header| |
==={{header|Liberty BASIC}}=== |
||
Verbose version: |
|||
<lang freebasic>input "Please enter one integer: ", x |
|||
{{works with|Just BASIC}} |
|||
input "and a second integer: ", y |
|||
<syntaxhighlight lang="lb">input "Enter an integer for a. ";a |
|||
input "Enter an integer for b. ";b |
|||
'a=int(a):b=int(b) ??? |
|||
if x < y then print x; " is less than "; y |
|||
print "Conditional evaluation." |
|||
if x = y then print x; " is equal to "; y |
|||
if |
if a<b then print "a<b " ; a ; " < " ; b |
||
if a=b then print "a=b " ; a ; " = " ; b |
|||
if a>b then print "a>b " ; a ; " > " ; b |
|||
print "Select case evaluation." |
|||
select case |
|||
case (a<b) |
|||
print "a<b " ; a ; " < " ; b |
|||
case (a=b) |
|||
print "a=b " ; a ; " = " ; b |
|||
case (a>b) |
|||
print "a>b " ; a ; " > " ; b |
|||
end select |
|||
</syntaxhighlight> |
|||
Concise: |
|||
<syntaxhighlight lang="lb">input "Enter an integer for a. ";a |
|||
input "Enter an integer for b. ";b |
|||
for i = 1 to 3 |
|||
op$=word$("< = >", i) |
|||
if eval("a"+op$+"b") then print "a"+op$+"b " ; a;" ";op$;" ";b |
|||
next |
|||
</syntaxhighlight> |
|||
==={{header|OxygenBasic}}=== |
==={{header|OxygenBasic}}=== |
||
<lang> |
<syntaxhighlight lang="text"> |
||
uses console |
uses console |
||
print "Integer comparison. (press ctrl-c to exit) " cr cr |
print "Integer comparison. (press ctrl-c to exit) " cr cr |
||
Line 768: | Line 898: | ||
endif |
endif |
||
loop |
loop |
||
</syntaxhighlight> |
|||
</lang> |
|||
==={{header|PureBasic}}=== |
|||
<syntaxhighlight lang="purebasic">If OpenConsole() |
|||
Print("Enter an integer: ") |
|||
x.i = Val(Input()) |
|||
Print("Enter another integer: ") |
|||
y.i = Val(Input()) |
|||
If x < y |
|||
Print( "The first integer is less than the second integer.") |
|||
ElseIf x = y |
|||
Print("The first integer is equal to the second integer.") |
|||
ElseIf x > y |
|||
Print("The first integer is greater than the second integer.") |
|||
EndIf |
|||
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit") |
|||
Input() |
|||
CloseConsole() |
|||
EndIf</syntaxhighlight> |
|||
==={{header|QBasic}}=== |
==={{header|QBasic}}=== |
||
< |
<syntaxhighlight lang="qbasic">INPUT "Please enter two integers, separated by a comma: ", x, y |
||
IF x < y THEN PRINT x; " is less than "; y |
IF x < y THEN PRINT x; " is less than "; y |
||
IF x = y THEN PRINT x; " is equal to "; y |
IF x = y THEN PRINT x; " is equal to "; y |
||
IF x > y THEN PRINT x; " is greater than "; y</ |
IF x > y THEN PRINT x; " is greater than "; y</syntaxhighlight> |
||
==={{header|Run BASIC}}=== |
|||
<syntaxhighlight lang="runbasic">input "1st number:"; n1 |
|||
input "2nd number:"; n2 |
|||
if n1 < n2 then print "1st number ";n1;" is less than 2nd number";n2 |
|||
if n1 > n2 then print "1st number ";n1;" is greater than 2nd number";n2 |
|||
if n1 = n2 then print "1st number ";n1;" is equal to 2nd number";n2</syntaxhighlight> |
|||
==={{header|SmallBASIC}}=== |
|||
<syntaxhighlight lang="qbasic"> |
|||
PRINT "Please enter two integers, separated by a comma: "; |
|||
INPUT x, y |
|||
IF x < y THEN PRINT x; " is less than "; y |
|||
IF x == y THEN PRINT x; " is equal to "; y |
|||
IF x > y THEN PRINT x; " is greater than "; y |
|||
</syntaxhighlight> |
|||
==={{header|TI-83 BASIC}}=== |
|||
<syntaxhighlight lang="ti83b">Prompt A,B |
|||
If A<B: Disp "A SMALLER B" |
|||
If A>B: Disp "A GREATER B" |
|||
If A=B: Disp "A EQUAL B"</syntaxhighlight> |
|||
==={{header|TI-89 BASIC}}=== |
|||
<syntaxhighlight lang="ti89b">Local a, b, result |
|||
Prompt a, b |
|||
If a < b Then |
|||
"<" → result |
|||
ElseIf a = b Then |
|||
"=" → result |
|||
ElseIf a > b Then |
|||
">" → result |
|||
Else |
|||
"???" → result |
|||
EndIf |
|||
Disp string(a) & " " & result & " " & string(b)</syntaxhighlight> |
|||
==={{Header|Tiny BASIC}}=== |
|||
{{works with|TinyBasic}} |
|||
Some implementations of Tiny BASIC use <code>,</code> instead of <code>;</code> for concatenation of print items. |
|||
<syntaxhighlight lang="basic">10 REM Integer comparison |
|||
20 PRINT "Enter a number" |
|||
30 INPUT A |
|||
40 PRINT "Enter another number" |
|||
50 INPUT B |
|||
60 IF A < B THEN PRINT A;" is less than ";B |
|||
70 IF A > B THEN PRINT A;" is greater than ";B |
|||
80 IF A = B THEN PRINT A;" is equal to ";B |
|||
90 END</syntaxhighlight> |
|||
==={{header|True BASIC}}=== |
==={{header|True BASIC}}=== |
||
< |
<syntaxhighlight lang="qbasic">PRINT "Please enter two integers, separated by a comma: "; |
||
INPUT x, y |
INPUT x, y |
||
Line 784: | Line 986: | ||
IF x = y THEN PRINT x; " is equal to "; y |
IF x = y THEN PRINT x; " is equal to "; y |
||
IF x > y THEN PRINT x; " is greater than "; y |
IF x > y THEN PRINT x; " is greater than "; y |
||
END</ |
END</syntaxhighlight> |
||
==={{header|VBA}}=== |
|||
<syntaxhighlight lang="vb">Public Sub integer_comparison() |
|||
first_integer = CInt(InputBox("Give me an integer.")) |
|||
second_integer = CInt(InputBox("Give me another integer.")) |
|||
Debug.Print IIf(first_integer < second_integer, "first integer is smaller than second integer", "first integer is not smaller than second integer") |
|||
Debug.Print IIf(first_integer = second_integer, "first integer is equal to second integer", "first integer is not equal to second integer") |
|||
Debug.Print IIf(first_integer > second_integer, "first integer is bigger than second integer", "first integer is not bigger than second integer") |
|||
End Sub</syntaxhighlight> |
|||
==={{header|VBScript}}=== |
|||
<syntaxhighlight lang="vb"> |
|||
option explicit |
|||
function eef( b, r1, r2 ) |
|||
if b then |
|||
eef = r1 |
|||
else |
|||
eef = r2 |
|||
end if |
|||
end function |
|||
dim a, b |
|||
wscript.stdout.write "First integer: " |
|||
a = cint(wscript.stdin.readline) 'force to integer |
|||
wscript.stdout.write "Second integer: " |
|||
b = cint(wscript.stdin.readline) 'force to integer |
|||
wscript.stdout.write "First integer is " |
|||
if a < b then wscript.stdout.write "less than " |
|||
if a = b then wscript.stdout.write "equal to " |
|||
if a > b then wscript.stdout.write "greater than " |
|||
wscript.echo "Second integer." |
|||
wscript.stdout.write "First integer is " & _ |
|||
eef( a < b, "less than ", _ |
|||
eef( a = b, "equal to ", _ |
|||
eef( a > b, "greater than ", vbnullstring ) ) ) & "Second integer." |
|||
</syntaxhighlight> |
|||
==={{header|Visual Basic .NET}}=== |
|||
'''Platform:''' [[.NET]] |
|||
{{works with|Visual Basic .NET|9.0+}} |
|||
<syntaxhighlight lang="vbnet">Sub Main() |
|||
Dim a = CInt(Console.ReadLine) |
|||
Dim b = CInt(Console.ReadLine) |
|||
'Using if statements |
|||
If a < b Then Console.WriteLine("a is less than b") |
|||
If a = b Then Console.WriteLine("a equals b") |
|||
If a > b Then Console.WriteLine("a is greater than b") |
|||
'Using Case |
|||
Select Case a |
|||
Case Is < b |
|||
Console.WriteLine("a is less than b") |
|||
Case b |
|||
Console.WriteLine("a equals b") |
|||
Case Is > b |
|||
Console.WriteLine("a is greater than b") |
|||
End Select |
|||
End Sub</syntaxhighlight> |
|||
==={{header|Yabasic}}=== |
==={{header|Yabasic}}=== |
||
< |
<syntaxhighlight lang="yabasic">input "Please enter two integers, separated by a comma: " x, y |
||
if x < y then print x, " is less than ", y : fi |
if x < y then print x, " is less than ", y : fi |
||
if x = y then print x, " is equal to ", y : fi |
if x = y then print x, " is equal to ", y : fi |
||
if x > y then print x, " is greater than ", y : fi</ |
if x > y then print x, " is greater than ", y : fi</syntaxhighlight> |
||
==={{ |
==={{header|ZX Spectrum Basic}}=== |
||
<syntaxhighlight lang="zxbasic">10 INPUT "Enter two integers: ";a;" ";b |
|||
<lang tinybasic>PRINT "Enter a number" |
|||
20 PRINT a;" is ";("less than " AND (a<b));("equal to " AND (a=b));("greather than " AND (a>b));b</syntaxhighlight> |
|||
INPUT A |
|||
PRINT "Enter another number" |
|||
INPUT B |
|||
IF A < B THEN PRINT A," is less than ",B |
|||
IF A > B THEN PRINT A," is greater than ",B |
|||
IF A = B THEN PRINT A," is equal to ",B</lang> |
|||
=={{header|Batch File}}== |
=={{header|Batch File}}== |
||
< |
<syntaxhighlight lang="dos">@echo off |
||
setlocal EnableDelayedExpansion |
setlocal EnableDelayedExpansion |
||
set /p a="A: " |
set /p a="A: " |
||
Line 813: | Line 1,076: | ||
) else ( if %a% EQU %b% ( |
) else ( if %a% EQU %b% ( |
||
echo %a% is equal to %b% |
echo %a% is equal to %b% |
||
)))</ |
)))</syntaxhighlight> |
||
{{Out}} |
{{Out}} |
||
<pre>C:\Test>IntegerComparison.bat |
<pre>C:\Test>IntegerComparison.bat |
||
Line 819: | Line 1,082: | ||
B: 3 |
B: 3 |
||
5 is greater than 3</pre> |
5 is greater than 3</pre> |
||
=={{header|BBC BASIC}}== |
|||
<lang bbcbasic> INPUT "Enter two numbers separated by a comma: " a, b |
|||
CASE TRUE OF |
|||
WHEN a < b: PRINT ;a " is less than "; b |
|||
WHEN a = b: PRINT ;a " is equal to "; b |
|||
WHEN a > b: PRINT ;a " is greater than "; b |
|||
ENDCASE</lang> |
|||
=={{header|bc}}== |
=={{header|bc}}== |
||
{{Works with|GNU bc}} |
{{Works with|GNU bc}} |
||
(POSIX bc doesn't have I/O functions/statements (i.e. <code>read</code> and <code>print</code>) but the rest of the code would work.) |
(POSIX bc doesn't have I/O functions/statements (i.e. <code>read</code> and <code>print</code>) but the rest of the code would work.) |
||
< |
<syntaxhighlight lang="bc">a = read() |
||
b = read() |
b = read() |
||
if (a < b) print "a is smaller than b\n" |
if (a < b) print "a is smaller than b\n" |
||
if (a > b) print "a is greater than b\n" |
if (a > b) print "a is greater than b\n" |
||
if (a == b) print "a is equal to b\n" |
if (a == b) print "a is equal to b\n" |
||
quit</ |
quit</syntaxhighlight> |
||
=={{header|BCPL}}== |
|||
<syntaxhighlight lang="bcpl">get "libhdr" |
|||
let start() be |
|||
$( let a = ? and b = ? |
|||
writes("A? ") ; a := readn() |
|||
writes("B? ") ; b := readn() |
|||
writes( |
|||
a < b -> "A is less than B*N", |
|||
a = b -> "A is equal to B*N", |
|||
a > b -> "A is greater than B*N", |
|||
"Huh?!" |
|||
) |
|||
$)</syntaxhighlight> |
|||
=={{header|Befunge}}== |
=={{header|Befunge}}== |
||
Line 842: | Line 1,113: | ||
The branch commands (underline _ and pipe |) test for zero. |
The branch commands (underline _ and pipe |) test for zero. |
||
< |
<syntaxhighlight lang="befunge">v v ">" $< |
||
>&&"=A",,\:."=B ",,,\: .55+,-:0`| |
>&&"=A",,\:."=B ",,,\: .55+,-:0`| |
||
v "<" _v#< |
v "<" _v#< |
||
@,+55,," B",,,"A " < "=" <</ |
@,+55,," B",,,"A " < "=" <</syntaxhighlight> |
||
=={{header|BQN}}== |
=={{header|BQN}}== |
||
The function <code>Comp</code> compares two integers and returns the appropriate string result. |
The function <code>Comp</code> compares two integers and returns the appropriate string result. |
||
< |
<syntaxhighlight lang="bqn"> Comp ← ⊑·/⟜"Greater than"‿"Equal To"‿"Lesser Than"(>∾=∾<) |
||
⊑(/⟜⟨ "Greater than" "Equal To" "Lesser Than" ⟩>∾=∾<) |
⊑(/⟜⟨ "Greater than" "Equal To" "Lesser Than" ⟩>∾=∾<) |
||
Line 858: | Line 1,129: | ||
"Equal To" |
"Equal To" |
||
6 Comp 5 |
6 Comp 5 |
||
"Greater than"</ |
"Greater than"</syntaxhighlight> |
||
=={{header|Bracmat}}== |
=={{header|Bracmat}}== |
||
< |
<syntaxhighlight lang="bracmat"> get$:?A |
||
& get$:?B |
& get$:?B |
||
& (!A:!B&out$"A equals B"|) |
& (!A:!B&out$"A equals B"|) |
||
& (!A:<!B&out$"A is less than B"|) |
& (!A:<!B&out$"A is less than B"|) |
||
& (!A:>!B&out$"A is greater than B"|);</ |
& (!A:>!B&out$"A is greater than B"|);</syntaxhighlight> |
||
=={{header|Brat}}== |
=={{header|Brat}}== |
||
< |
<syntaxhighlight lang="brat">first = ask("First integer: ").to_i |
||
second = ask("Second integer: ").to_i |
second = ask("Second integer: ").to_i |
||
when { first > second } { p "#{first} is greater than #{second}" } |
when { first > second } { p "#{first} is greater than #{second}" } |
||
{ first < second } { p "#{first} is less than #{second}" } |
{ first < second } { p "#{first} is less than #{second}" } |
||
{ first == second } { p "#{first} is equal to #{second}" }</ |
{ first == second } { p "#{first} is equal to #{second}" }</syntaxhighlight> |
||
=={{header|Burlesque}}== |
=={{header|Burlesque}}== |
||
< |
<syntaxhighlight lang="burlesque"> |
||
blsq ) "5 6"ps^pcm+.{"The first one is less than the second one""They are both equal""The second one is less than the first one"}\/!!sh |
blsq ) "5 6"ps^pcm+.{"The first one is less than the second one""They are both equal""The second one is less than the first one"}\/!!sh |
||
The first one is less than the second one |
The first one is less than the second one |
||
Line 885: | Line 1,156: | ||
blsq ) "6 5"ps^pcm+.{"The first one is less than the second one""They are both equal""The second one is less than the first one"}\/!!sh |
blsq ) "6 5"ps^pcm+.{"The first one is less than the second one""They are both equal""The second one is less than the first one"}\/!!sh |
||
The second one is less than the first one |
The second one is less than the first one |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|C}}== |
=={{header|C}}== |
||
< |
<syntaxhighlight lang="c">#include <stdio.h> |
||
int main() |
int main() |
||
Line 905: | Line 1,176: | ||
return 0; |
return 0; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
< |
<syntaxhighlight lang="csharp">using System; |
||
class Program |
class Program |
||
Line 923: | Line 1,194: | ||
Console.WriteLine("{0} is greater than {1}", a, b); |
Console.WriteLine("{0} is greater than {1}", a, b); |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|C++}}== |
=={{header|C++}}== |
||
< |
<syntaxhighlight lang="cpp">#include <iostream> |
||
int main() |
int main() |
||
Line 948: | Line 1,219: | ||
if (a > b) |
if (a > b) |
||
std::cout << a << " is greater than " << b << "\n"; |
std::cout << a << " is greater than " << b << "\n"; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|CFEngine}}== |
=={{header|CFEngine}}== |
||
< |
<syntaxhighlight lang="cfengine3"> |
||
bundle agent __main__ |
bundle agent __main__ |
||
{ |
{ |
||
Line 967: | Line 1,238: | ||
if => isgreaterthan( "$(first_integer)", "$(second_integer)" ); |
if => isgreaterthan( "$(first_integer)", "$(second_integer)" ); |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|ChucK}}== |
=={{header|ChucK}}== |
||
<lang> |
<syntaxhighlight lang="text"> |
||
fun void intComparison (int one, int two) |
fun void intComparison (int one, int two) |
||
{ |
{ |
||
Line 979: | Line 1,250: | ||
// uncomment next line and change values to test |
// uncomment next line and change values to test |
||
// intComparison (2,4); |
// intComparison (2,4); |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Clean}}== |
=={{header|Clean}}== |
||
< |
<syntaxhighlight lang="clean">import StdEnv |
||
compare a b |
compare a b |
||
Line 993: | Line 1,264: | ||
(_, a, console) = freadi console |
(_, a, console) = freadi console |
||
(_, b, console) = freadi console |
(_, b, console) = freadi console |
||
= compare a b</ |
= compare a b</syntaxhighlight> |
||
=={{header|Clipper}}== |
=={{header|Clipper}}== |
||
< |
<syntaxhighlight lang="clipper"> Function Compare(a, b) |
||
IF a < b |
IF a < b |
||
? "A is less than B" |
? "A is less than B" |
||
Line 1,005: | Line 1,276: | ||
ENDIF |
ENDIF |
||
Return Nil |
Return Nil |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Clojure}}== |
=={{header|Clojure}}== |
||
Line 1,011: | Line 1,282: | ||
It evaluates the when/println body three times, each time with op and string bound to their corresponding entries in the list of three operator/string pairs. |
It evaluates the when/println body three times, each time with op and string bound to their corresponding entries in the list of three operator/string pairs. |
||
Note that this does no validation on input: if the user inputs a string then an exception will be thrown. |
Note that this does no validation on input: if the user inputs a string then an exception will be thrown. |
||
< |
<syntaxhighlight lang="clojure">(let [[a b] (repeatedly read)] |
||
(doseq [[op string] [[< "less than"] |
(doseq [[op string] [[< "less than"] |
||
[> "greater than"] |
[> "greater than"] |
||
[= "equal to"]]] |
[= "equal to"]]] |
||
(when (op a b) |
(when (op a b) |
||
(println (str a " is " string " " b)))))</ |
(println (str a " is " string " " b)))))</syntaxhighlight> |
||
=={{header|CMake}}== |
=={{header|CMake}}== |
||
< |
<syntaxhighlight lang="cmake"># Define A and B as integers. For example: |
||
# cmake -DA=3 -DB=5 -P compare.cmake |
# cmake -DA=3 -DB=5 -P compare.cmake |
||
Line 1,037: | Line 1,308: | ||
if(A GREATER B) |
if(A GREATER B) |
||
message(STATUS "${A} is greater than ${B}") |
message(STATUS "${A} is greater than ${B}") |
||
endif()</ |
endif()</syntaxhighlight> |
||
=={{header|COBOL}}== |
=={{header|COBOL}}== |
||
{{works with|OpenCOBOL}} |
{{works with|OpenCOBOL}} |
||
< |
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
||
PROGRAM-ID. Int-Compare. |
PROGRAM-ID. Int-Compare. |
||
Line 1,066: | Line 1,337: | ||
GOBACK |
GOBACK |
||
.</ |
.</syntaxhighlight> |
||
=={{header|ColdFusion}}== |
=={{header|ColdFusion}}== |
||
Line 1,079: | Line 1,350: | ||
===In CFML=== |
===In CFML=== |
||
< |
<syntaxhighlight lang="cfm"><cffunction name="CompareInteger"> |
||
<cfargument name="Integer1" type="numeric"> |
<cfargument name="Integer1" type="numeric"> |
||
<cfargument name="Integer2" type="numeric"> |
<cfargument name="Integer2" type="numeric"> |
||
Line 1,102: | Line 1,373: | ||
</cfif> |
</cfif> |
||
<cfreturn VARIABLES.Result > |
<cfreturn VARIABLES.Result > |
||
</cffunction></ |
</cffunction></syntaxhighlight> |
||
===In CFScript=== |
===In CFScript=== |
||
< |
<syntaxhighlight lang="cfm"><cfscript> |
||
function CompareInteger( Integer1, Integer2 ) { |
function CompareInteger( Integer1, Integer2 ) { |
||
VARIABLES.Result = ""; |
VARIABLES.Result = ""; |
||
Line 1,129: | Line 1,400: | ||
return VARIABLES.Result; |
return VARIABLES.Result; |
||
} |
} |
||
</cfscript></ |
</cfscript></syntaxhighlight> |
||
=={{header|Common Lisp}}== |
=={{header|Common Lisp}}== |
||
You can type this directly into a REPL: |
You can type this directly into a REPL: |
||
< |
<syntaxhighlight lang="lisp">(let ((a (read *standard-input*)) |
||
(b (read *standard-input*))) |
(b (read *standard-input*))) |
||
(cond |
(cond |
||
Line 1,142: | Line 1,413: | ||
((> a b) (format t "~A is greater than ~A." a b)) |
((> a b) (format t "~A is greater than ~A." a b)) |
||
((= a b) (format t "~A is equal to ~A." a b)) |
((= a b) (format t "~A is equal to ~A." a b)) |
||
(t (format t "Cannot determine relevance between ~A and ~B!" a b)))))</ |
(t (format t "Cannot determine relevance between ~A and ~B!" a b)))))</syntaxhighlight> |
||
After hitting enter, the REPL is expecting the two numbers right away. |
After hitting enter, the REPL is expecting the two numbers right away. |
||
Line 1,148: | Line 1,419: | ||
Alternatively, you can wrap this code in a function definition: |
Alternatively, you can wrap this code in a function definition: |
||
< |
<syntaxhighlight lang="lisp">(defun compare-integers () |
||
(let ((a (read *standard-input*)) |
(let ((a (read *standard-input*)) |
||
(b (read *standard-input*))) |
(b (read *standard-input*))) |
||
Line 1,157: | Line 1,428: | ||
((> a b) (format t "~A is greater than ~A." a b)) |
((> a b) (format t "~A is greater than ~A." a b)) |
||
((= a b) (format t "~A is equal to ~A." a b)) |
((= a b) (format t "~A is equal to ~A." a b)) |
||
(t (format t "Cannot determine relevance between ~A and ~B!" a b)))))</ |
(t (format t "Cannot determine relevance between ~A and ~B!" a b)))))</syntaxhighlight> |
||
Then, execute the function for better control: |
Then, execute the function for better control: |
||
Line 1,166: | Line 1,437: | ||
If you run this program, it will halt awaiting user input. Toggle in the value of <math>x</math>, then click <tt>Enter</tt>, then toggle in <math>y</math>, then <tt>Enter</tt>, and then <tt>Run</tt>. <math>x</math> and <math>y</math> must both be unsigned eight-bit integers. The computer will halt with the accumulator storing 1 if <math>x</math>><math>y</math>, 0 if <math>x</math>=<math>y</math>, or -1 if <math>x</math><<math>y</math>; and it will be ready for a fresh pair of integers to be entered. |
If you run this program, it will halt awaiting user input. Toggle in the value of <math>x</math>, then click <tt>Enter</tt>, then toggle in <math>y</math>, then <tt>Enter</tt>, and then <tt>Run</tt>. <math>x</math> and <math>y</math> must both be unsigned eight-bit integers. The computer will halt with the accumulator storing 1 if <math>x</math>><math>y</math>, 0 if <math>x</math>=<math>y</math>, or -1 if <math>x</math><<math>y</math>; and it will be ready for a fresh pair of integers to be entered. |
||
< |
<syntaxhighlight lang="czasm">start: STP ; get input |
||
x: NOP |
x: NOP |
||
Line 1,193: | Line 1,464: | ||
JMP start |
JMP start |
||
one: 1</ |
one: 1</syntaxhighlight> |
||
=={{header|D}}== |
=={{header|D}}== |
||
< |
<syntaxhighlight lang="d">void main() { |
||
import std.stdio, std.conv, std.string; |
import std.stdio, std.conv, std.string; |
||
Line 1,213: | Line 1,484: | ||
if (a > b) |
if (a > b) |
||
writeln(a, " is greater than ", b); |
writeln(a, " is greater than ", b); |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>10 is less than 20</pre> |
<pre>10 is less than 20</pre> |
||
=={{header|Dc}}== |
=={{header|Dc}}== |
||
< |
<syntaxhighlight lang="dc">[Use _ (underscore) as negative sign for numbers.]P []pP |
||
[Enter two numbers to compare: ]P |
[Enter two numbers to compare: ]P |
||
? sbsa |
? sbsa |
||
Line 1,225: | Line 1,496: | ||
[ [equal to]]sp lb la =p |
[ [equal to]]sp lb la =p |
||
la n [ is ]P P [ ]P lbn []pP |
la n [ is ]P P [ ]P lbn []pP |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
{{out}} |
||
44 is greater than 3 |
44 is greater than 3 |
||
=={{header|DCL}}== |
=={{header|DCL}}== |
||
< |
<syntaxhighlight lang="dcl">$ inquire a "Please provide an integer" |
||
$ inquire b "Please provide another" |
$ inquire b "Please provide another" |
||
$ if a .lt. b then $ write sys$output "the first integer is less" |
$ if a .lt. b then $ write sys$output "the first integer is less" |
||
$ if a .eq. b then $ write sys$output "the integers have the same value" |
$ if a .eq. b then $ write sys$output "the integers have the same value" |
||
$ if a .gt. b then $ write sys$output "the first integer is greater"</ |
$ if a .gt. b then $ write sys$output "the first integer is greater"</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>$ @integer_comparison |
<pre>$ @integer_comparison |
||
Line 1,252: | Line 1,523: | ||
:''Slightly different than the [[#Pascal|Pascal]] example'' |
:''Slightly different than the [[#Pascal|Pascal]] example'' |
||
< |
<syntaxhighlight lang="delphi">program IntegerCompare; |
||
{$APPTYPE CONSOLE} |
{$APPTYPE CONSOLE} |
||
Line 1,263: | Line 1,534: | ||
if a = b then Writeln(a, ' is equal to ', b); |
if a = b then Writeln(a, ' is equal to ', b); |
||
if a > b then Writeln(a, ' is greater than ', b); |
if a > b then Writeln(a, ' is greater than ', b); |
||
end.</ |
end.</syntaxhighlight> |
||
=={{header|Draco}}== |
=={{header|Draco}}== |
||
< |
<syntaxhighlight lang="draco">proc nonrec main() void: |
||
int a, b; |
int a, b; |
||
write("Please enter two integers: "); |
write("Please enter two integers: "); |
||
Line 1,274: | Line 1,545: | ||
elif a>b then writeln(a, " > ", b) |
elif a>b then writeln(a, " > ", b) |
||
fi |
fi |
||
corp</ |
corp</syntaxhighlight> |
||
=={{header|Dyalect}}== |
=={{header|Dyalect}}== |
||
Line 1,280: | Line 1,551: | ||
{{trans|Clipper}} |
{{trans|Clipper}} |
||
< |
<syntaxhighlight lang="dyalect">func compare(a, b) { |
||
if a < b { |
if a < b { |
||
"A is less than B" |
"A is less than B" |
||
Line 1,288: | Line 1,559: | ||
"A equals B" |
"A equals B" |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|E}}== |
=={{header|E}}== |
||
< |
<syntaxhighlight lang="e">def compare(a :int, b :int) { |
||
println(if (a < b) { `$a < $b` } \ |
println(if (a < b) { `$a < $b` } \ |
||
else if (a <=> b) { `$a = $b` } \ |
else if (a <=> b) { `$a = $b` } \ |
||
else if (a > b) { `$a > $b` } \ |
else if (a > b) { `$a > $b` } \ |
||
else { `You're calling that an integer?` }) |
else { `You're calling that an integer?` }) |
||
}</ |
}</syntaxhighlight> |
||
=={{header|EasyLang}}== |
=={{header|EasyLang}}== |
||
<lang>a = number input |
<syntaxhighlight lang="text">a = number input |
||
b = number input |
b = number input |
||
if a < b |
if a < b |
||
Line 1,309: | Line 1,580: | ||
if a > b |
if a > b |
||
print "greater" |
print "greater" |
||
.</ |
.</syntaxhighlight> |
||
=={{header|ECL}}== |
=={{header|ECL}}== |
||
<syntaxhighlight lang="ecl"> |
|||
<lang ECL> |
|||
CompareThem(INTEGER A,INTEGER B) := FUNCTION |
CompareThem(INTEGER A,INTEGER B) := FUNCTION |
||
Result := A <=> B; |
Result := A <=> B; |
||
Line 1,322: | Line 1,593: | ||
CompareThem(2,2); //Shows "2 is equal to 2" |
CompareThem(2,2); //Shows "2 is equal to 2" |
||
CompareThem(2,1); //Shows "2 is greater than 1" |
CompareThem(2,1); //Shows "2 is greater than 1" |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|EDSAC order code}}== |
=={{header|EDSAC order code}}== |
||
The EDSAC offers two conditional branching orders, <tt>E</tt> (branch if the accumulator >= 0) and <tt>G</tt> (branch if the accumulator < 0). Testing for equality thus requires two operations. |
The EDSAC offers two conditional branching orders, <tt>E</tt> (branch if the accumulator >= 0) and <tt>G</tt> (branch if the accumulator < 0). Testing for equality thus requires two operations. |
||
< |
<syntaxhighlight lang="edsac">[ Integer comparison |
||
================== |
================== |
||
Line 1,380: | Line 1,651: | ||
[ 18 ] AF [ - character ] |
[ 18 ] AF [ - character ] |
||
EZPF [ begin execution ]</ |
EZPF [ begin execution ]</syntaxhighlight> |
||
=={{header|Efene}}== |
=={{header|Efene}}== |
||
Line 1,386: | Line 1,657: | ||
since if does pattern matching the else is required to avoid the application from crashing |
since if does pattern matching the else is required to avoid the application from crashing |
||
< |
<syntaxhighlight lang="efene">compare = fn (A, B) { |
||
if A == B { |
if A == B { |
||
io.format("~p equals ~p~n", [A, B]) |
io.format("~p equals ~p~n", [A, B]) |
||
Line 1,415: | Line 1,686: | ||
compare(4, 5) |
compare(4, 5) |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Eiffel}}== |
=={{header|Eiffel}}== |
||
< |
<syntaxhighlight lang="eiffel">class |
||
APPLICATION |
APPLICATION |
||
inherit |
inherit |
||
Line 1,447: | Line 1,718: | ||
end |
end |
||
end |
end |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Elena}}== |
=={{header|Elena}}== |
||
ELENA 4.x: |
ELENA 4.x: |
||
< |
<syntaxhighlight lang="elena">import extensions; |
||
public program() |
public program() |
||
Line 1,466: | Line 1,737: | ||
if (a > b) |
if (a > b) |
||
{ console.printLine(a," is greater than ",b) } |
{ console.printLine(a," is greater than ",b) } |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Elixir}}== |
=={{header|Elixir}}== |
||
< |
<syntaxhighlight lang="elixir">{a,_} = IO.gets("Enter your first integer: ") |> Integer.parse |
||
{b,_} = IO.gets("Enter your second integer: ") |> Integer.parse |
{b,_} = IO.gets("Enter your second integer: ") |> Integer.parse |
||
Line 1,479: | Line 1,750: | ||
a == b -> |
a == b -> |
||
IO.puts "#{a} is equal to #{b}" |
IO.puts "#{a} is equal to #{b}" |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Emacs Lisp}}== |
=={{header|Emacs Lisp}}== |
||
< |
<syntaxhighlight lang="lisp">(defun integer-comparison (a b) |
||
"Compare A to B and print the outcome in the message buffer." |
"Compare A to B and print the outcome in the message buffer." |
||
(interactive "nFirst integer ⇒\nnSecond integer ⇒") |
(interactive "nFirst integer ⇒\nnSecond integer ⇒") |
||
Line 1,489: | Line 1,760: | ||
((< a b) (message "%d is less than %d." a b)) |
((< a b) (message "%d is less than %d." a b)) |
||
((> a b) (message "%d is greater than %d." a b)) |
((> a b) (message "%d is greater than %d." a b)) |
||
((= a b) (message "%d is equal to %d." a b))))</ |
((= a b) (message "%d is equal to %d." a b))))</syntaxhighlight> |
||
Invoke from within Emacs Lisp (or e.g., with <code>M-:</code>) as <code>(integer-comparison 12 42)</code> |
Invoke from within Emacs Lisp (or e.g., with <code>M-:</code>) as <code>(integer-comparison 12 42)</code> |
||
Or, use <code>M-x integer-comparison RET</code> and you'll be prompted for the two numbers. |
Or, use <code>M-x integer-comparison RET</code> and you'll be prompted for the two numbers. |
||
=={{header|EMal}}== |
|||
<syntaxhighlight lang="emal"> |
|||
fun main = int by List args |
|||
int a, b |
|||
if args.length > 1 |
|||
a = int!args[0] |
|||
b = int!args[1] |
|||
else |
|||
a = ask(int, "Enter the first integer ") |
|||
b = ask(int, "Enter the second integer ") |
|||
end |
|||
writeLine("=== a <> b is " + (a <> b) + " ===") |
|||
if a < b do writeLine(a + " < " + b) end |
|||
if a == b do writeLine(a + " == " + b) end |
|||
if a > b do writeLine(a + " > " + b) end |
|||
return 0 |
|||
end |
|||
exit main(Runtime.args) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
emal.exe Org\RosettaCode\IntegerComparison.emal |
|||
Enter the first integer 42 |
|||
Enter the second integer 64 |
|||
=== a <> b is -1 === |
|||
42 < 64 |
|||
</pre> |
|||
=={{header|Erlang}}== |
=={{header|Erlang}}== |
||
< |
<syntaxhighlight lang="erlang"> |
||
main() -> |
main() -> |
||
{ok, [N]} = io:fread("First integer: ", "~d"), |
{ok, [N]} = io:fread("First integer: ", "~d"), |
||
Line 1,514: | Line 1,813: | ||
end. |
end. |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Euphoria}}== |
=={{header|Euphoria}}== |
||
< |
<syntaxhighlight lang="euphoria">include get.e |
||
integer a,b |
integer a,b |
||
Line 1,531: | Line 1,830: | ||
puts(1,"grater then") |
puts(1,"grater then") |
||
end if |
end if |
||
puts(1," b")</ |
puts(1," b")</syntaxhighlight> |
||
=={{header|Excel}}== |
=={{header|Excel}}== |
||
Line 1,537: | Line 1,836: | ||
Let's say you type in the values in cells A1 and B1, in C1, type in the following in a MS Excel 2010 sheet: |
Let's say you type in the values in cells A1 and B1, in C1, type in the following in a MS Excel 2010 sheet: |
||
< |
<syntaxhighlight lang="excel"> |
||
=IF($A1>$B1;concatenate($A1;" is greater than ";$B1);IF($A1<$B1;concatenate($A1;" is smaller than ";$B1);concatenate($A1;" is equal to ";$B1))) |
=IF($A1>$B1;concatenate($A1;" is greater than ";$B1);IF($A1<$B1;concatenate($A1;" is smaller than ";$B1);concatenate($A1;" is equal to ";$B1))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
In a Google Docs spreadsheet, that becomes : |
In a Google Docs spreadsheet, that becomes : |
||
< |
<syntaxhighlight lang="excel"> |
||
=IF($A1>$B1,concatenate($A1," is greater than ",$B1),IF($A1<$B1,concatenate($A1," is smaller than ",$B1),concatenate($A1," is equal to ",$B1))) |
=IF($A1>$B1,concatenate($A1," is greater than ",$B1),IF($A1<$B1,concatenate($A1," is smaller than ",$B1),concatenate($A1," is equal to ",$B1))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|F_Sharp|F#}}== |
=={{header|F_Sharp|F#}}== |
||
< |
<syntaxhighlight lang="fsharp">let compare_ints a b = |
||
let r = |
let r = |
||
match a with |
match a with |
||
Line 1,555: | Line 1,854: | ||
| x when x > b -> 1, printfn "%d is greater than %d" x b |
| x when x > b -> 1, printfn "%d is greater than %d" x b |
||
| x -> 0, printf "default condition (not reached)" |
| x -> 0, printf "default condition (not reached)" |
||
fst r</ |
fst r</syntaxhighlight> |
||
=={{header|Factor}}== |
=={{header|Factor}}== |
||
< |
<syntaxhighlight lang="factor">: example ( -- ) |
||
readln readln [ string>number ] bi@ |
readln readln [ string>number ] bi@ |
||
[ > [ "A > B" print ] when ] |
[ > [ "A > B" print ] when ] |
||
[ < [ "A < B" print ] when ] |
[ < [ "A < B" print ] when ] |
||
[ = [ "A = B" print ] when ] 2tri ; |
[ = [ "A = B" print ] when ] 2tri ; |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|FALSE}}== |
=={{header|FALSE}}== |
||
Only equals and greater than are available. |
Only equals and greater than are available. |
||
< |
<syntaxhighlight lang="false">^^ \$@$@$@$@\ |
||
>[\$," is greater than "\$,]? |
>[\$," is greater than "\$,]? |
||
\>[\$," is less than "\$,]? |
\>[\$," is less than "\$,]? |
||
=["characters are equal"]?</ |
=["characters are equal"]?</syntaxhighlight> |
||
=={{header|Fantom}}== |
=={{header|Fantom}}== |
||
Line 1,576: | Line 1,875: | ||
Uses Env.cur to access stdin and stdout. |
Uses Env.cur to access stdin and stdout. |
||
< |
<syntaxhighlight lang="fantom">class Main |
||
{ |
{ |
||
public static Void main () |
public static Void main () |
||
Line 1,598: | Line 1,897: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Fermat}}== |
=={{header|Fermat}}== |
||
< |
<syntaxhighlight lang="fermat">Func Compare = |
||
?a; |
?a; |
||
?b; |
?b; |
||
Line 1,607: | Line 1,906: | ||
if a<b then !'Less than' fi; |
if a<b then !'Less than' fi; |
||
if a>b then !'Greater than' fi; |
if a>b then !'Greater than' fi; |
||
.;</ |
.;</syntaxhighlight> |
||
=={{header|Fish}}== |
=={{header|Fish}}== |
||
This example assumes you [http://www.esolangs.org/wiki/Fish#Input.2Foutput pre-populate] the stack with the two integers. |
This example assumes you [http://www.esolangs.org/wiki/Fish#Input.2Foutput pre-populate] the stack with the two integers. |
||
< |
<syntaxhighlight lang="fish">l2=?vv ~< v o< |
||
v <>l?^"Please pre-populate the stack with the two integers."ar>l?^; |
v <>l?^"Please pre-populate the stack with the two integers."ar>l?^; |
||
\$:@@:@)?v v ;oanv!!!?< |
\$:@@:@)?v v ;oanv!!!?< |
||
Line 1,623: | Line 1,922: | ||
> v |
> v |
||
/oo". "nooooo" and "n$< v o< |
/oo". "nooooo" and "n$< v o< |
||
>"They're not equal, not greater than and not smaller than eachother... strange."ar>l?^;</ |
>"They're not equal, not greater than and not smaller than eachother... strange."ar>l?^;</syntaxhighlight> |
||
The last three lines aren't really needed, because it will never become true :P but I included them to show a way to do some error checking. |
The last three lines aren't really needed, because it will never become true :P but I included them to show a way to do some error checking. |
||
Line 1,630: | Line 1,929: | ||
To keep the example simple, the word takes the two numbers from the stack. |
To keep the example simple, the word takes the two numbers from the stack. |
||
< |
<syntaxhighlight lang="forth">: compare-integers ( a b -- ) |
||
2dup < if ." a is less than b" then |
2dup < if ." a is less than b" then |
||
2dup > if ." a is greater than b" then |
2dup > if ." a is greater than b" then |
||
= if ." a is equal to b" then ;</ |
= if ." a is equal to b" then ;</syntaxhighlight> |
||
=={{header|Fortran}}== |
=={{header|Fortran}}== |
||
In ALL Fortran versions (including original 1950's era) you could use an "arithmetic IF" statement to compare using subtraction: |
In ALL Fortran versions (including original 1950's era) you could use an "arithmetic IF" statement to compare using subtraction: |
||
< |
<syntaxhighlight lang="fortran">program arithif |
||
integer a, b |
integer a, b |
||
Line 1,653: | Line 1,952: | ||
40 continue |
40 continue |
||
end</ |
end</syntaxhighlight> |
||
In ANSI FORTRAN 66 or later you could use relational operators (.lt., .gt., .eq., etc.) and unstructured IF statements: |
In ANSI FORTRAN 66 or later you could use relational operators (.lt., .gt., .eq., etc.) and unstructured IF statements: |
||
< |
<syntaxhighlight lang="fortran">program compare |
||
integer a, b |
integer a, b |
||
c fortran 77 I/O statements, for simplicity |
c fortran 77 I/O statements, for simplicity |
||
Line 1,664: | Line 1,963: | ||
if (a .eq. b) write(*, *) a, ' is equal to ', b |
if (a .eq. b) write(*, *) a, ' is equal to ', b |
||
if (a .gt. b) write(*, *) a, ' is greater than ', b |
if (a .gt. b) write(*, *) a, ' is greater than ', b |
||
end</ |
end</syntaxhighlight> |
||
In ANSI FORTRAN 77 or later you can use relational operators and structured IF statements: |
In ANSI FORTRAN 77 or later you can use relational operators and structured IF statements: |
||
< |
<syntaxhighlight lang="fortran">program compare |
||
integer a, b |
integer a, b |
||
read(*,*) a, b |
read(*,*) a, b |
||
Line 1,679: | Line 1,978: | ||
end if |
end if |
||
end</ |
end</syntaxhighlight> |
||
In ISO Fortran 90 or later you can use symbolic relational operators (<, >, ==, etc.) |
In ISO Fortran 90 or later you can use symbolic relational operators (<, >, ==, etc.) |
||
< |
<syntaxhighlight lang="fortran">program compare |
||
integer :: a, b |
integer :: a, b |
||
read(*,*) a, b |
read(*,*) a, b |
||
Line 1,694: | Line 1,993: | ||
end if |
end if |
||
end program compare</ |
end program compare</syntaxhighlight> |
||
=={{header|FreeBASIC}}== |
|||
<lang freebasic>' FB 1.05.0 Win64 |
|||
Dim As Integer x, y |
|||
Input "Please enter two integers, separated by a comma : ", x , y |
|||
If x < y Then |
|||
Print x; " is less than "; y |
|||
End If |
|||
If x = y Then |
|||
Print x; " is equal to "; y |
|||
End If |
|||
If x > y Then |
|||
Print x; " is greater than "; y |
|||
End If |
|||
Print |
|||
Print "Press any key to exit" |
|||
Sleep</lang> |
|||
=={{header|friendly interactive shell}}== |
=={{header|friendly interactive shell}}== |
||
< |
<syntaxhighlight lang="fishshell">read a |
||
read b |
read b |
||
Line 1,728: | Line 2,005: | ||
else if test $a -eq $b |
else if test $a -eq $b |
||
echo Equal |
echo Equal |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Frink}}== |
=={{header|Frink}}== |
||
All integers in Frink can be arbitrarily large. |
All integers in Frink can be arbitrarily large. |
||
< |
<syntaxhighlight lang="frink">[a,b] = eval[input["Enter numbers",["a","b"]]] |
||
if a<b |
if a<b |
||
println["$a < $b"] |
println["$a < $b"] |
||
Line 1,739: | Line 2,016: | ||
println["$a == $b"] |
println["$a == $b"] |
||
if a>b |
if a>b |
||
println["$a > $b"]</ |
println["$a > $b"]</syntaxhighlight> |
||
=={{header|FunL}}== |
=={{header|FunL}}== |
||
< |
<syntaxhighlight lang="funl">import console.readInt |
||
a = readInt() |
a = readInt() |
||
Line 1,749: | Line 2,026: | ||
val (_, c) = [((<), 'less than'), ((==), 'equal to'), ((>), 'greater than')].find( (compare, _) -> compare(a, b) ).get() |
val (_, c) = [((<), 'less than'), ((==), 'equal to'), ((>), 'greater than')].find( (compare, _) -> compare(a, b) ).get() |
||
println( "$a is $c $b." )</ |
println( "$a is $c $b." )</syntaxhighlight> |
||
=={{header| |
=={{header|Fōrmulæ}}== |
||
Note: Strictly speaking, it's preferable to use "==" when comparing integers as seen in this example. While the "=" sign will work as a comparison in most cases, technically it should be used for assignment, i.e. a = 3 when a is assigned the value of 3, as contrasted with a == 3, where the value of a is being compared with 3. FB will flag a warning when "==" is used to compare two single, doubles or floats since comparing real numbers can be inaccurate. |
|||
<lang futurebasic>_window = 1 |
|||
begin enum 1 |
|||
_integer1Fld |
|||
_integer2Fld |
|||
_compareBtn |
|||
_messageLabel |
|||
end enum |
|||
{{FormulaeEntry|page=https://formulae.org/?script=examples/Integer_comparison}} |
|||
local fn BuildWindow |
|||
window _window, @"Integer Comparison", (0,0,356,85) |
|||
'''Solution''' |
|||
textfield _integer1Fld,,, (20,44,112,21) |
|||
TextFieldSetPlaceholderString( _integer1Fld, @"Integer 1" ) |
|||
Fōrmulæ has an intrinsic expression for [[wp:Three-way_comparison|three-way comparison]] that works for integers and other types (decimal and rational numbers, strings, time expressions, etc). It returns expressions that flag one of the three possible results. |
|||
textfield _integer2Fld,,, (140,44,112,21) |
|||
TextFieldSetPlaceholderString( _integer2Fld, @"Integer 2" ) |
|||
[[File:Fōrmulæ - Integer comparison 01.png]] |
|||
button _compareBtn,,, @"Compare", (253,38,90,32) |
|||
[[File:Fōrmulæ - Integer comparison 02.png]] |
|||
textlabel _messageLabel,, (18,20,320,16) |
|||
ControlSetAlignment( _messageLabel, NSTextAlignmentCenter ) |
|||
end fn |
|||
However, a simple function can be written for the requirement: |
|||
local fn DoDialog( ev as long, tag as long ) |
|||
long int1, int2 |
|||
[[File:Fōrmulæ - Integer comparison 03.png]] |
|||
select ( ev ) |
|||
case _btnClick |
|||
select ( tag ) |
|||
case _compareBtn |
|||
int1 = fn ControlIntegerValue( _integer1Fld ) |
|||
int2 = fn ControlIntegerValue( _integer2Fld ) |
|||
[[File:Fōrmulæ - Integer comparison 04.png]] |
|||
if ( int1 < int2 ) then textlabel _messageLabel, @"The first integer is less than the second integer." |
|||
if ( int1 == int2 ) then textlabel _messageLabel, @"The first integer is equal to the second integer." |
|||
if ( int1 > int2 ) then textlabel _messageLabel, @"The first integer is greater than the second integer." |
|||
[[File:Fōrmulæ - Integer comparison 05.png]] |
|||
end select |
|||
case _controlTextDidChange |
|||
textlabel _messageLabel, @"" |
|||
end select |
|||
end fn |
|||
fn BuildWindow |
|||
on dialog fn DoDialog |
|||
HandleEvents</lang> |
|||
=={{header|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 [https://formulae.org website], However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used. |
|||
In '''[https://formulae.org/?example=Integer_comparison this]''' page you can see the program(s) related to this task and their results. |
|||
=={{header|Gambas}}== |
|||
<lang gambas>Public Sub Form_Open() |
|||
Dim sIn As String = InputBox("Enter 2 integers seperated by a comma") |
|||
Dim iFirst, iSecond As Integer |
|||
iFirst = Val(Split(sIn)[0]) |
|||
iSecond = Val(Split(sIn)[1]) |
|||
If iFirst < iSecond Then Print iFirst & " is smaller than " & iSecond & gb.NewLine |
|||
If iFirst > iSecond Then Print iFirst & " is greater than " & iSecond & gb.NewLine |
|||
If iFirst = iSecond Then Print iFirst & " is equal to " & iSecond |
|||
End</lang> |
|||
Output: |
|||
<pre> |
|||
21 is greater than 18 |
|||
</pre> |
|||
=={{header|Go}}== |
=={{header|Go}}== |
||
< |
<syntaxhighlight lang="go">package main |
||
import ( |
import ( |
||
Line 1,855: | Line 2,074: | ||
fmt.Println(n1, "greater than", n2) |
fmt.Println(n1, "greater than", n2) |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Groovy}}== |
=={{header|Groovy}}== |
||
===Relational Operators=== |
===Relational Operators=== |
||
< |
<syntaxhighlight lang="groovy">def comparison = { a, b -> |
||
println "a ? b = ${a} ? ${b} = a ${a < b ? '<' : a > b ? '>' : a == b ? '==' : '?'} b" |
println "a ? b = ${a} ? ${b} = a ${a < b ? '<' : a > b ? '>' : a == b ? '==' : '?'} b" |
||
}</ |
}</syntaxhighlight> |
||
Program: |
Program: |
||
< |
<syntaxhighlight lang="groovy">comparison(2000,3) |
||
comparison(2000,300000) |
comparison(2000,300000) |
||
comparison(2000,2000)</ |
comparison(2000,2000)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,876: | Line 2,095: | ||
==="Spaceship" (compareTo) Operator=== |
==="Spaceship" (compareTo) Operator=== |
||
Using spaceship operator and a lookup table: |
Using spaceship operator and a lookup table: |
||
< |
<syntaxhighlight lang="groovy">final rels = [ (-1) : '<', 0 : '==', 1 : '>' ].asImmutable() |
||
def comparisonSpaceship = { a, b -> |
def comparisonSpaceship = { a, b -> |
||
println "a ? b = ${a} ? ${b} = a ${rels[a <=> b]} b" |
println "a ? b = ${a} ? ${b} = a ${rels[a <=> b]} b" |
||
}</ |
}</syntaxhighlight> |
||
Program: |
Program: |
||
< |
<syntaxhighlight lang="groovy">comparison(2000,3) |
||
comparison(2000,300000) |
comparison(2000,300000) |
||
comparison(2000,2000)</ |
comparison(2000,2000)</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 1,892: | Line 2,111: | ||
=={{header|Harbour}}== |
=={{header|Harbour}}== |
||
< |
<syntaxhighlight lang="visualfoxpro">PROCEDURE Compare( a, b ) |
||
IF a < b |
IF a < b |
||
Line 1,902: | Line 2,121: | ||
ENDIF |
ENDIF |
||
RETURN</ |
RETURN</syntaxhighlight> |
||
=={{header|Haskell}}== |
=={{header|Haskell}}== |
||
< |
<syntaxhighlight lang="haskell">myCompare :: Integer -> Integer -> String |
||
myCompare a b |
myCompare a b |
||
| a < b = "A is less than B" |
| a < b = "A is less than B" |
||
Line 1,914: | Line 2,133: | ||
a <- readLn |
a <- readLn |
||
b <- readLn |
b <- readLn |
||
putStrLn $ myCompare a b</ |
putStrLn $ myCompare a b</syntaxhighlight> |
||
However, the more idiomatic and less error-prone way to do it in Haskell would be to use a compare function that returns type Ordering, which is either LT, GT, or EQ: |
However, the more idiomatic and less error-prone way to do it in Haskell would be to use a compare function that returns type Ordering, which is either LT, GT, or EQ: |
||
< |
<syntaxhighlight lang="haskell">myCompare a b = case compare a b of |
||
LT -> "A is less than B" |
LT -> "A is less than B" |
||
GT -> "A is greater than B" |
GT -> "A is greater than B" |
||
EQ -> "A equals B"</ |
EQ -> "A equals B"</syntaxhighlight> |
||
=={{header|hexiscript}}== |
=={{header|hexiscript}}== |
||
< |
<syntaxhighlight lang="hexiscript">let a scan int |
||
let b scan int |
let b scan int |
||
Line 1,935: | Line 2,154: | ||
if a = b |
if a = b |
||
println a + " is equal to " + b |
println a + " is equal to " + b |
||
endif</ |
endif</syntaxhighlight> |
||
=={{header|HicEst}}== |
=={{header|HicEst}}== |
||
< |
<syntaxhighlight lang="hicest">DLG(NameEdit=a, NameEdit=b, Button='OK') |
||
IF (a < b) THEN |
IF (a < b) THEN |
||
Line 1,946: | Line 2,165: | ||
ELSEIF(a > b) THEN |
ELSEIF(a > b) THEN |
||
WRITE(Messagebox) a, ' is greater than ', b |
WRITE(Messagebox) a, ' is greater than ', b |
||
ENDIF</ |
ENDIF</syntaxhighlight> |
||
=={{header|HolyC}}== |
=={{header|HolyC}}== |
||
< |
<syntaxhighlight lang="holyc">I64 *a, *b; |
||
a = Str2I64(GetStr("Enter your first number: ")); |
a = Str2I64(GetStr("Enter your first number: ")); |
||
b = Str2I64(GetStr("Enter your second number: ")); |
b = Str2I64(GetStr("Enter your second number: ")); |
||
Line 1,960: | Line 2,179: | ||
if (a > b) |
if (a > b) |
||
Print("%d is greater than %d\n", a, b);</ |
Print("%d is greater than %d\n", a, b);</syntaxhighlight> |
||
=={{header|Hy}}== |
=={{header|Hy}}== |
||
< |
<syntaxhighlight lang="clojure">(def a (int (input "Enter value of a: "))) |
||
(def b (int (input "Enter value of b: "))) |
(def b (int (input "Enter value of b: "))) |
||
(print (cond [(< a b) "a is less than b"] |
(print (cond [(< a b) "a is less than b"] |
||
[(> a b) "a is greater than b"] |
[(> a b) "a is greater than b"] |
||
[(= a b) "a is equal to b"]))</ |
[(= a b) "a is equal to b"]))</syntaxhighlight> |
||
=={{header|i}}== |
=={{header|i}}== |
||
< |
<syntaxhighlight lang="i">software { |
||
a = number(read(' ')) |
a = number(read(' ')) |
||
b = number(read()) |
b = number(read()) |
||
Line 1,986: | Line 2,205: | ||
print(a, " is greater than ", b) |
print(a, " is greater than ", b) |
||
end |
end |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Icon}} and {{header|Unicon}}== |
=={{header|Icon}} and {{header|Unicon}}== |
||
< |
<syntaxhighlight lang="icon">procedure main() |
||
until integer(a) do { |
until integer(a) do { |
||
Line 2,004: | Line 2,223: | ||
write(a," = ", a = b) |
write(a," = ", a = b) |
||
write(a," > ", a > b) |
write(a," > ", a > b) |
||
end</ |
end</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 2,014: | Line 2,233: | ||
=={{header|J}}== |
=={{header|J}}== |
||
Comparison is accomplished by the verb <code>compare</code>, which provides logical-numeric output.<br>Text elaborating the output of <code>compare</code> is provided by <code>cti</code>: |
Comparison is accomplished by the verb <code>compare</code>, which provides logical-numeric output.<br>Text elaborating the output of <code>compare</code> is provided by <code>cti</code>: |
||
< |
<syntaxhighlight lang="j">compare=: < , = , > |
||
cti=: dyad define |
cti=: dyad define |
||
Line 2,020: | Line 2,239: | ||
English =. ' is less than ';' is equal to ';' is greater than ' |
English =. ' is less than ';' is equal to ';' is greater than ' |
||
x (":@[, (compare select English"_), ":@]) y |
x (":@[, (compare select English"_), ":@]) y |
||
)</ |
)</syntaxhighlight> |
||
Examples of use: |
Examples of use: |
||
< |
<syntaxhighlight lang="j"> 4 compare 4 |
||
0 1 0 |
0 1 0 |
||
4 cti 3 |
4 cti 3 |
||
4 is greater than 3</ |
4 is greater than 3</syntaxhighlight> |
||
=={{header|Java}}== |
=={{header|Java}}== |
||
< |
<syntaxhighlight lang="java">import java.io.*; |
||
public class compInt { |
public class compInt { |
||
Line 2,048: | Line 2,267: | ||
} catch(IOException e) { } |
} catch(IOException e) { } |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|JavaScript}}== |
=={{header|JavaScript}}== |
||
< |
<syntaxhighlight lang="javascript"> |
||
// Using type coercion |
// Using type coercion |
||
function compare(a, b) { |
function compare(a, b) { |
||
Line 2,078: | Line 2,297: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Joy}}== |
=={{header|Joy}}== |
||
<syntaxhighlight lang= |
<syntaxhighlight lang="joy">#!/usr/local/bin/joy.exe |
||
DEFINE |
DEFINE |
||
prompt == "Please enter a number and <Enter>: " putchars; |
prompt == "Please enter a number and <Enter>: " putchars; |
||
Line 2,104: | Line 2,323: | ||
=={{header|jq}}== |
=={{header|jq}}== |
||
< |
<syntaxhighlight lang="jq"># compare/0 compares the first two items if they are numbers, |
||
# otherwise an "uncomparable" message is emitted. |
# otherwise an "uncomparable" message is emitted. |
||
Line 2,119: | Line 2,338: | ||
end ; |
end ; |
||
compare</ |
compare</syntaxhighlight> |
||
Examples; |
Examples; |
||
<syntaxhighlight lang="jq"> |
|||
<lang jq> |
|||
$ jq -s -r -f Integer_comparison.jq |
$ jq -s -r -f Integer_comparison.jq |
||
1 2 |
1 2 |
||
Line 2,130: | Line 2,349: | ||
1 "a" |
1 "a" |
||
1 is uncomparable to a |
1 is uncomparable to a |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Julia}}== |
=={{header|Julia}}== |
||
< |
<syntaxhighlight lang="julia">function compare() |
||
int1 = readline(stdin) |
int1 = readline(stdin) |
||
int2 = readline(stdin) |
int2 = readline(stdin) |
||
Line 2,143: | Line 2,362: | ||
int2) |
int2) |
||
end |
end |
||
</ |
</syntaxhighlight>{{out}} |
||
<pre>julia> compare() |
<pre>julia> compare() |
||
3 |
3 |
||
Line 2,151: | Line 2,370: | ||
=={{header|Kotlin}}== |
=={{header|Kotlin}}== |
||
<lang |
<syntaxhighlight lang="kotlin">fun main() { |
||
val n1 = readLine()!!.toLong() |
val n1 = readLine()!!.toLong() |
||
val n2 = readLine()!!.toLong() |
val n2 = readLine()!!.toLong() |
||
Line 2,160: | Line 2,379: | ||
else -> "" |
else -> "" |
||
}) |
}) |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Lambdatalk}}== |
=={{header|Lambdatalk}}== |
||
<syntaxhighlight lang="scheme"> |
|||
<lang Scheme> |
|||
{def compare |
{def compare |
||
{lambda {:a :b} |
{lambda {:a :b} |
||
Line 2,180: | Line 2,399: | ||
{compare 1 1} |
{compare 1 1} |
||
-> 1 is equal to 1 |
-> 1 is equal to 1 |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Lang}}== |
|||
<syntaxhighlight lang="lang"> |
|||
fn.print(Enter a:\s) |
|||
$a = fn.int(fn.input()) |
|||
fn.print(Enter b:\s) |
|||
$b = fn.int(fn.input()) |
|||
if($a < $b) { |
|||
fn.println($a is less than $b) |
|||
}elif($a > $b) { |
|||
fn.println($a is greater than $b) |
|||
}elif($a === $b) { |
|||
fn.println($a is equals to $b) |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Lasso}}== |
=={{header|Lasso}}== |
||
< |
<syntaxhighlight lang="lasso">local( |
||
number1 = integer(web_request -> param('number1')), |
number1 = integer(web_request -> param('number1')), |
||
number2 = integer(web_request -> param('number2')) |
number2 = integer(web_request -> param('number2')) |
||
Line 2,192: | Line 2,428: | ||
#number1 == #number2 ? 'Number 1 is the same as Number 2' | 'Number 1 is not the same as Number 2' |
#number1 == #number2 ? 'Number 1 is the same as Number 2' | 'Number 1 is not the same as Number 2' |
||
'<br />' |
'<br />' |
||
#number1 > #number2 ? 'Number 1 is greater than Number 2' | 'Number 1 is not greater than Number 2'</ |
#number1 > #number2 ? 'Number 1 is greater than Number 2' | 'Number 1 is not greater than Number 2'</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 2,199: | Line 2,435: | ||
Number 1 is the same as Number 2 |
Number 1 is the same as Number 2 |
||
Number 1 is not greater than Number 2</pre> |
Number 1 is not greater than Number 2</pre> |
||
=={{header|Liberty BASIC}}== |
|||
Verbose version: |
|||
<lang lb>input "Enter an integer for a. ";a |
|||
input "Enter an integer for b. ";b |
|||
'a=int(a):b=int(b) ??? |
|||
print "Conditional evaluation." |
|||
if a<b then print "a<b " ; a ; " < " ; b |
|||
if a=b then print "a=b " ; a ; " = " ; b |
|||
if a>b then print "a>b " ; a ; " > " ; b |
|||
print "Select case evaluation." |
|||
select case |
|||
case (a<b) |
|||
print "a<b " ; a ; " < " ; b |
|||
case (a=b) |
|||
print "a=b " ; a ; " = " ; b |
|||
case (a>b) |
|||
print "a>b " ; a ; " > " ; b |
|||
end select |
|||
</lang> |
|||
Concise: |
|||
<lang lb>input "Enter an integer for a. ";a |
|||
input "Enter an integer for b. ";b |
|||
for i = 1 to 3 |
|||
op$=word$("< = >", i) |
|||
if eval("a"+op$+"b") then print "a"+op$+"b " ; a;" ";op$;" ";b |
|||
next |
|||
</lang> |
|||
=={{header|LIL}}== |
=={{header|LIL}}== |
||
< |
<syntaxhighlight lang="tcl">print "Enter two numbers separated by space" |
||
set rc [readline] |
set rc [readline] |
||
set a [index $rc 0] |
set a [index $rc 0] |
||
Line 2,241: | Line 2,444: | ||
if {$a < $b} {print "$a is less than $b"} |
if {$a < $b} {print "$a is less than $b"} |
||
if {$a == $b} {print "$a is equal to $b"} |
if {$a == $b} {print "$a is equal to $b"} |
||
if {$a > $b} {print "$a is greater than $b"}</ |
if {$a > $b} {print "$a is greater than $b"}</syntaxhighlight> |
||
=={{header|Lingo}}== |
=={{header|Lingo}}== |
||
Lingo programs are normally not run in the console, so interactive user input is handled via GUI. To not clutter this page with GUI creation code, here only the comparison part of the task: |
Lingo programs are normally not run in the console, so interactive user input is handled via GUI. To not clutter this page with GUI creation code, here only the comparison part of the task: |
||
< |
<syntaxhighlight lang="lingo">on compare (a, b) |
||
if a < b then put a&" is less than "&b |
if a < b then put a&" is less than "&b |
||
if a = b then put a&" is equal to "&b |
if a = b then put a&" is equal to "&b |
||
if a > b then put a&" is greater than "&b |
if a > b then put a&" is greater than "&b |
||
end</ |
end</syntaxhighlight> |
||
=={{header|LiveCode}}== |
=={{header|LiveCode}}== |
||
< |
<syntaxhighlight lang="livecode">ask question "Enter 2 numbers (comma separated)" with empty titled "Enter 2 numbers" |
||
if it is not empty then |
if it is not empty then |
||
put item 1 of it into num1 |
put item 1 of it into num1 |
||
Line 2,271: | Line 2,474: | ||
end switch |
end switch |
||
end if |
end if |
||
end if</ |
end if</syntaxhighlight> |
||
=={{header|LLVM}}== |
=={{header|LLVM}}== |
||
Line 2,278: | Line 2,481: | ||
{{libheader|cstdlib}} |
{{libheader|cstdlib}} |
||
< |
<syntaxhighlight lang="llvm">; ModuleID = 'test.o' |
||
;e means little endian |
;e means little endian |
||
;p: { pointer size : pointer abi : preferred alignment for pointers } |
;p: { pointer size : pointer abi : preferred alignment for pointers } |
||
Line 2,369: | Line 2,572: | ||
declare i32 @printf(i8* nocapture, ...) nounwind |
declare i32 @printf(i8* nocapture, ...) nounwind |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Logo}}== |
=={{header|Logo}}== |
||
< |
<syntaxhighlight lang="logo">to compare :a :b |
||
if :a = :b [(print :a [equals] :b)] |
if :a = :b [(print :a [equals] :b)] |
||
if :a < :b [(print :a [is less than] :b)] |
if :a < :b [(print :a [is less than] :b)] |
||
if :a > :b [(print :a [is greater than] :b)] |
if :a > :b [(print :a [is greater than] :b)] |
||
end</ |
end</syntaxhighlight> |
||
Each infix operator has prefix synonyms (equalp, equal?, lessp, less?, greaterp, greater?), where the 'p' stands for "predicate" as in [[Lisp]]. |
Each infix operator has prefix synonyms (equalp, equal?, lessp, less?, greaterp, greater?), where the 'p' stands for "predicate" as in [[Lisp]]. |
||
Line 2,383: | Line 2,586: | ||
==={{header|avec SI}}=== |
==={{header|avec SI}}=== |
||
< |
<syntaxhighlight lang="lse">(* Comparaison de deux entiers en LSE (LSE-2000) *) |
||
ENTIER A, B |
ENTIER A, B |
||
LIRE ['Entrez un premier entier:',U] A |
LIRE ['Entrez un premier entier:',U] A |
||
Line 2,395: | Line 2,598: | ||
SI A > B ALORS |
SI A > B ALORS |
||
AFFICHER [U,' est plus grand que ',U,/] A, B |
AFFICHER [U,' est plus grand que ',U,/] A, B |
||
FIN SI</ |
FIN SI</syntaxhighlight> |
||
==={{header|avec ÉVALUER}}=== |
==={{header|avec ÉVALUER}}=== |
||
< |
<syntaxhighlight lang="lse">(* Comparaison de deux entiers en LSE (LSE-2000) *) |
||
ENTIER A, B |
ENTIER A, B |
||
LIRE ['Entrez un premier entier:',U] A |
LIRE ['Entrez un premier entier:',U] A |
||
Line 2,409: | Line 2,612: | ||
QUAND AUTRE |
QUAND AUTRE |
||
AFFICHER [U,' est plus grand que ',U,/] A, B |
AFFICHER [U,' est plus grand que ',U,/] A, B |
||
FIN EVALUER</ |
FIN EVALUER</syntaxhighlight> |
||
==={{header|avec SI..IS}}=== |
==={{header|avec SI..IS}}=== |
||
< |
<syntaxhighlight lang="lse">(* Comparaison de deux entiers en LSE (LSE-2000) *) |
||
ENTIER A, B |
ENTIER A, B |
||
LIRE ['Entrez un premier entier:',U] A |
LIRE ['Entrez un premier entier:',U] A |
||
Line 2,420: | Line 2,623: | ||
SI A = B ALORS ' est égale à ' SINON \ |
SI A = B ALORS ' est égale à ' SINON \ |
||
SI A > B ALORS ' est plus grand que ' SINON '?' IS IS IS, B |
SI A > B ALORS ' est plus grand que ' SINON '?' IS IS IS, B |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|LSE64}}== |
=={{header|LSE64}}== |
||
< |
<syntaxhighlight lang="lse64">over : 2 pick |
||
2dup : over over |
2dup : over over |
||
Line 2,430: | Line 2,633: | ||
compare : 2dup > then " is more than" |
compare : 2dup > then " is more than" |
||
show : compare rot , sp ,t sp , nl</ |
show : compare rot , sp ,t sp , nl</syntaxhighlight> |
||
=={{header|Lua}}== |
=={{header|Lua}}== |
||
< |
<syntaxhighlight lang="lua">print('Enter the first number: ') |
||
a = tonumber(io.stdin:read()) |
a = tonumber(io.stdin:read()) |
||
print('Enter the second number: ') |
print('Enter the second number: ') |
||
Line 2,440: | Line 2,643: | ||
if a < b then print(a .. " is less than " .. b) end |
if a < b then print(a .. " is less than " .. b) end |
||
if a > b then print(a .. " is greater than " .. b) end |
if a > b then print(a .. " is greater than " .. b) end |
||
if a == b then print(a .. " is equal to " .. b) end</ |
if a == b then print(a .. " is equal to " .. b) end</syntaxhighlight> |
||
In lua, a double equals symbol is required to test for equality. A single equals sign is used for assignment, and will cause an error during jit precompilation, if it is used within a boolean expression: |
In lua, a double equals symbol is required to test for equality. A single equals sign is used for assignment, and will cause an error during jit precompilation, if it is used within a boolean expression: |
||
< |
<syntaxhighlight lang="lua">-- if a = b then print("This will not work")</syntaxhighlight> |
||
=={{header|Maple}}== |
=={{header|Maple}}== |
||
< |
<syntaxhighlight lang="maple">CompareNumbers := proc( ) |
||
local a, b; |
local a, b; |
||
printf( "Enter a number:> " ); |
printf( "Enter a number:> " ); |
||
Line 2,462: | Line 2,665: | ||
end proc: |
end proc: |
||
CompareNumbers();</ |
CompareNumbers();</syntaxhighlight> |
||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
||
< |
<syntaxhighlight lang="mathematica">a=Input["Give me the value for a please!"]; |
||
b=Input["Give me the value for b please!"]; |
b=Input["Give me the value for b please!"]; |
||
If[a==b,Print["a equals b"]] |
If[a==b,Print["a equals b"]] |
||
If[a>b,Print["a is bigger than b"]] |
If[a>b,Print["a is bigger than b"]] |
||
If[a<b,Print["b is bigger than a"]]</ |
If[a<b,Print["b is bigger than a"]]</syntaxhighlight> |
||
=={{header|Maxima}}== |
=={{header|Maxima}}== |
||
< |
<syntaxhighlight lang="maxima">/* all 6 comparison operators (last is "not equal") */ |
||
block( |
block( |
||
[a: read("a?"), b: read("b?")], |
[a: read("a?"), b: read("b?")], |
||
Line 2,480: | Line 2,683: | ||
if a >= b then print(a, ">=", b), |
if a >= b then print(a, ">=", b), |
||
if a = b then print(a, "=", b), |
if a = b then print(a, "=", b), |
||
if a # b then print(a, "#", b))$</ |
if a # b then print(a, "#", b))$</syntaxhighlight> |
||
=={{header|MAXScript}}== |
=={{header|MAXScript}}== |
||
< |
<syntaxhighlight lang="maxscript">a = getKBValue prompt:"Enter value of a:" |
||
b = getKBValue prompt:"Enter value of b:" |
b = getKBValue prompt:"Enter value of b:" |
||
if a < b then print "a is less then b" |
if a < b then print "a is less then b" |
||
else if a > b then print "a is greater then b" |
else if a > b then print "a is greater then b" |
||
else if a == b then print "a is equal to b"</ |
else if a == b then print "a is equal to b"</syntaxhighlight> |
||
=={{header|Metafont}}== |
=={{header|Metafont}}== |
||
< |
<syntaxhighlight lang="metafont">message "integer 1: "; |
||
a1 := scantokens readstring; |
a1 := scantokens readstring; |
||
message "integer 2: "; |
message "integer 2: "; |
||
Line 2,501: | Line 2,704: | ||
message decimal a1 & " is equal to " & decimal a2 |
message decimal a1 & " is equal to " & decimal a2 |
||
fi; |
fi; |
||
end</ |
end</syntaxhighlight> |
||
=={{header|min}}== |
=={{header|min}}== |
||
{{works with|min|0.19.3}} |
{{works with|min|0.19.3}} |
||
< |
<syntaxhighlight lang="min">"$1 is $2 $3." |
||
("Enter an integer" ask) 2 times over over |
("Enter an integer" ask) 2 times over over |
||
( |
( |
||
Line 2,512: | Line 2,715: | ||
((==) ("equal to")) |
((==) ("equal to")) |
||
) case |
) case |
||
' append prepend % print</ |
' append prepend % print</syntaxhighlight> |
||
=={{header|MiniScript}}== |
=={{header|MiniScript}}== |
||
< |
<syntaxhighlight lang="miniscript">integer1 = input("Please Input Integer 1:").val |
||
integer2 = input("Please Input Integer 2:").val |
integer2 = input("Please Input Integer 2:").val |
||
if integer1 < integer2 then print integer1 + " is less than " + integer2 |
if integer1 < integer2 then print integer1 + " is less than " + integer2 |
||
if integer1 == integer2 then print integer1 + " is equal to " + integer2 |
if integer1 == integer2 then print integer1 + " is equal to " + integer2 |
||
if integer1 > integer2 then print integer1 + " is greater than " + integer2</ |
if integer1 > integer2 then print integer1 + " is greater than " + integer2</syntaxhighlight> |
||
=={{header|МК-61/52}}== |
=={{header|МК-61/52}}== |
||
<lang>- ЗН С/П</ |
<syntaxhighlight lang="text">- ЗН С/П</syntaxhighlight> |
||
''Input:'' a ^ b |
''Input:'' a ^ b |
||
Line 2,532: | Line 2,735: | ||
Note that ML/I only has tests for ''equality'', ''greater-than'', and ''greater-than-or-equal''. |
Note that ML/I only has tests for ''equality'', ''greater-than'', and ''greater-than-or-equal''. |
||
< |
<syntaxhighlight lang="ml/i">"" Integer comparison |
||
"" assumes macros on input stream 1, terminal on stream 2 |
"" assumes macros on input stream 1, terminal on stream 2 |
||
MCSKIP MT,<> |
MCSKIP MT,<> |
||
Line 2,549: | Line 2,752: | ||
> |
> |
||
MCSET S1=1 |
MCSET S1=1 |
||
~MCSET S10=2</ |
~MCSET S10=2</syntaxhighlight> |
||
=={{header|MMIX}}== |
=={{header|MMIX}}== |
||
Some simple error checking is included. |
Some simple error checking is included. |
||
< |
<syntaxhighlight lang="mmix">// main registers |
||
p IS $255 % pointer |
p IS $255 % pointer |
||
pp GREG % backup for p |
pp GREG % backup for p |
||
Line 2,637: | Line 2,840: | ||
LDA p,GT % _ : print 'GT' |
LDA p,GT % _ : print 'GT' |
||
2H TRAP 0,Fputs,StdOut % print result |
2H TRAP 0,Fputs,StdOut % print result |
||
TRAP 0,Halt,0</ |
TRAP 0,Halt,0</syntaxhighlight> |
||
Example of use: |
Example of use: |
||
<pre>~/MIX/MMIX/Progs> mmix compare2ints 121 122 |
<pre>~/MIX/MMIX/Progs> mmix compare2ints 121 122 |
||
Line 2,658: | Line 2,861: | ||
=={{header|Modula-2}}== |
=={{header|Modula-2}}== |
||
< |
<syntaxhighlight lang="modula2">MODULE IntCompare; |
||
IMPORT InOut; |
IMPORT InOut; |
||
Line 2,679: | Line 2,882: | ||
InOut.WriteInt(B, 1); |
InOut.WriteInt(B, 1); |
||
InOut.WriteLn |
InOut.WriteLn |
||
END IntCompare.</ |
END IntCompare.</syntaxhighlight> |
||
=={{header|Modula-3}}== |
=={{header|Modula-3}}== |
||
< |
<syntaxhighlight lang="modula3">MODULE Main; |
||
FROM IO IMPORT Put, GetInt; |
FROM IO IMPORT Put, GetInt; |
||
Line 2,699: | Line 2,902: | ||
Put(Int(a) & " is greater than " & Int(b) & "\n"); |
Put(Int(a) & " is greater than " & Int(b) & "\n"); |
||
END; |
END; |
||
END Main.</ |
END Main.</syntaxhighlight> |
||
=={{header|MUMPS}}== |
=={{header|MUMPS}}== |
||
<lang>INTCOMP |
<syntaxhighlight lang="text">INTCOMP |
||
NEW A,B |
NEW A,B |
||
INTCOMPREAD |
INTCOMPREAD |
||
Line 2,712: | Line 2,915: | ||
IF A>B WRITE !,A," is greater than ",B |
IF A>B WRITE !,A," is greater than ",B |
||
KILL A,B |
KILL A,B |
||
QUIT</ |
QUIT</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>USER>d INTCOMP^ROSETTA |
<pre>USER>d INTCOMP^ROSETTA |
||
Line 2,731: | Line 2,934: | ||
=={{header|Nanoquery}}== |
=={{header|Nanoquery}}== |
||
< |
<syntaxhighlight lang="nanoquery">print "enter first integer: " |
||
first = int(input()) |
first = int(input()) |
||
print "enter second integer: " |
print "enter second integer: " |
||
Line 2,742: | Line 2,945: | ||
else if first > second |
else if first > second |
||
println first + " is greater than " + second |
println first + " is greater than " + second |
||
end</ |
end</syntaxhighlight> |
||
=={{header|Nemerle}}== |
=={{header|Nemerle}}== |
||
Showing both the use of comparison operators and the .Net Int32.CompareTo() method. |
Showing both the use of comparison operators and the .Net Int32.CompareTo() method. |
||
< |
<syntaxhighlight lang="nemerle">using System; |
||
using System.Console; |
using System.Console; |
||
Line 2,776: | Line 2,979: | ||
} |
} |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|NetRexx}}== |
=={{header|NetRexx}}== |
||
< |
<syntaxhighlight lang="netrexx">/* NetRexx */ |
||
options replace format comments java crossref symbols nobinary |
options replace format comments java crossref symbols nobinary |
||
Line 2,794: | Line 2,997: | ||
return |
return |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|NewLISP}}== |
=={{header|NewLISP}}== |
||
<syntaxhighlight lang="newlisp"> |
|||
<lang NewLISP> |
|||
(print "Please enter the first number: ") |
(print "Please enter the first number: ") |
||
(set 'A (int (read-line))) |
(set 'A (int (read-line))) |
||
Line 2,809: | Line 3,012: | ||
(true "less than")) |
(true "less than")) |
||
" the second.") |
" the second.") |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Nim}}== |
=={{header|Nim}}== |
||
< |
<syntaxhighlight lang="nim">import rdstdin, strutils |
||
var a = parseInt(readLineFromStdin "Enter value of a: ") |
var a = parseInt(readLineFromStdin "Enter value of a: ") |
||
var b = parseInt(readLineFromStdin "Enter value of b: ") |
var b = parseInt(readLineFromStdin "Enter value of b: ") |
||
Line 2,821: | Line 3,024: | ||
echo "a is greater than b" |
echo "a is greater than b" |
||
elif a == b: |
elif a == b: |
||
echo "a is equal to b"</ |
echo "a is equal to b"</syntaxhighlight> |
||
=={{header|NSIS}}== |
=={{header|NSIS}}== |
||
===Pure NSIS (Using [http://nsis.sourceforge.net/Docs/Chapter4.html#4.9.4.13 IntCmp] directly)=== |
===Pure NSIS (Using [http://nsis.sourceforge.net/Docs/Chapter4.html#4.9.4.13 IntCmp] directly)=== |
||
< |
<syntaxhighlight lang="nsis"> |
||
Function IntergerComparison |
Function IntergerComparison |
||
Push $0 |
Push $0 |
||
Line 2,848: | Line 3,051: | ||
Pop $0 |
Pop $0 |
||
FunctionEnd |
FunctionEnd |
||
</syntaxhighlight> |
|||
</lang> |
|||
=== Using [http://nsis.sourceforge.net/LogicLib LogicLib] (bundled library) === |
=== Using [http://nsis.sourceforge.net/LogicLib LogicLib] (bundled library) === |
||
{{libheader|LogicLib}} |
{{libheader|LogicLib}} |
||
< |
<syntaxhighlight lang="nsis"> |
||
Function IntegerComparison |
Function IntegerComparison |
||
Push $0 |
Push $0 |
||
Line 2,870: | Line 3,073: | ||
Pop $0 |
Pop $0 |
||
FunctionEnd |
FunctionEnd |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Nu}}== |
|||
<syntaxhighlight lang="nu"> |
|||
[First Second] | each {input $"($in) integer: "| into int} | [ |
|||
[($in.0 < $in.1) "less than"] |
|||
[($in.0 == $in.1) "equal to"] |
|||
[($in.0 > $in.1) "greater than"] |
|||
] | each {if $in.0 {$"The first integer is ($in.1) the second integer."}} | str join "\n" |
|||
</syntaxhighlight> |
|||
=={{header|Oberon-2}}== |
=={{header|Oberon-2}}== |
||
< |
<syntaxhighlight lang="oberon2">MODULE Compare; |
||
IMPORT In, Out; |
IMPORT In, Out; |
||
Line 2,898: | Line 3,110: | ||
Out.Ln; |
Out.Ln; |
||
END; |
END; |
||
END Compare.</ |
END Compare.</syntaxhighlight> |
||
=={{header|Objeck}}== |
=={{header|Objeck}}== |
||
< |
<syntaxhighlight lang="objeck"> |
||
bundle Default { |
bundle Default { |
||
class IntCompare { |
class IntCompare { |
||
Line 2,922: | Line 3,134: | ||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|OCaml}}== |
=={{header|OCaml}}== |
||
< |
<syntaxhighlight lang="ocaml">let my_compare a b = |
||
if a < b then "A is less than B" |
if a < b then "A is less than B" |
||
else if a > b then "A is greater than B" |
else if a > b then "A is greater than B" |
||
Line 2,934: | Line 3,146: | ||
let a = read_int () |
let a = read_int () |
||
and b = read_int () in |
and b = read_int () in |
||
print_endline (my_compare a b)</ |
print_endline (my_compare a b)</syntaxhighlight> |
||
=={{header|Octave}}== |
=={{header|Octave}}== |
||
< |
<syntaxhighlight lang="octave">printf("Enter a: "); |
||
a = scanf("%d", "C"); |
a = scanf("%d", "C"); |
||
printf("Enter b: "); |
printf("Enter b: "); |
||
Line 2,947: | Line 3,159: | ||
elseif (a < b) |
elseif (a < b) |
||
disp("a less than b"); |
disp("a less than b"); |
||
endif</ |
endif</syntaxhighlight> |
||
=={{header|Oforth}}== |
=={{header|Oforth}}== |
||
< |
<syntaxhighlight lang="oforth">import: console |
||
: cmpInt |
: cmpInt |
||
Line 2,960: | Line 3,172: | ||
a b < ifTrue: [ System.Out a << " is less than " << b << cr ] |
a b < ifTrue: [ System.Out a << " is less than " << b << cr ] |
||
a b == ifTrue: [ System.Out a << " is equal to " << b << cr ] |
a b == ifTrue: [ System.Out a << " is equal to " << b << cr ] |
||
a b > ifTrue: [ System.Out a << " is greater than " << b << cr ] ;</ |
a b > ifTrue: [ System.Out a << " is greater than " << b << cr ] ;</syntaxhighlight> |
||
=={{header|Ol}}== |
=={{header|Ol}}== |
||
< |
<syntaxhighlight lang="scheme"> |
||
(define (compare a b) |
(define (compare a b) |
||
(cond ((< a b) "A is less than B") |
(cond ((< a b) "A is less than B") |
||
Line 2,980: | Line 3,192: | ||
; manual user input: |
; manual user input: |
||
(print (compare (read) (read))) |
(print (compare (read) (read))) |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Oz}}== |
=={{header|Oz}}== |
||
< |
<syntaxhighlight lang="oz">functor |
||
import |
import |
||
Application(exit) |
Application(exit) |
||
Line 3,010: | Line 3,222: | ||
{Application.exit 0} |
{Application.exit 0} |
||
end</ |
end</syntaxhighlight> |
||
=={{header|PARI/GP}}== |
=={{header|PARI/GP}}== |
||
< |
<syntaxhighlight lang="parigp">a=input(); |
||
b=input(); |
b=input(); |
||
if(a<b, print(a" < "b)); |
if(a<b, print(a" < "b)); |
||
if(a==b, print(a" = "b)); |
if(a==b, print(a" = "b)); |
||
if(a>b, print(a" > "b));</ |
if(a>b, print(a" > "b));</syntaxhighlight> |
||
=={{header|Pascal}}== |
=={{header|Pascal}}== |
||
< |
<syntaxhighlight lang="pascal">program compare(input, output); |
||
var |
var |
||
Line 3,033: | Line 3,245: | ||
if (a = b) then writeln(a, ' is equal to ', b); |
if (a = b) then writeln(a, ' is equal to ', b); |
||
if (a > b) then writeln(a, ' is greater than ', b); |
if (a > b) then writeln(a, ' is greater than ', b); |
||
end.</ |
end.</syntaxhighlight> |
||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="delphi"> |
|||
begin |
|||
var (a,b) := ReadInteger2('Enter a,b:'); |
|||
if a < b then |
|||
Println($'{a} is less then {b}') |
|||
else if a > b then |
|||
Println($'{a} is greater then {b}') |
|||
else Println($'{a} is equal to then {b}') |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
Line 3,040: | Line 3,265: | ||
Separate tests for less than, greater than, and equals |
Separate tests for less than, greater than, and equals |
||
< |
<syntaxhighlight lang="perl">sub test_num { |
||
my $f = shift; |
my $f = shift; |
||
my $s = shift; |
my $s = shift; |
||
Line 3,052: | Line 3,277: | ||
return 0; # returns 0 $f is equal to $s |
return 0; # returns 0 $f is equal to $s |
||
}; |
}; |
||
};</ |
};</syntaxhighlight> |
||
All three tests in one. If $f is less than $s return -1, greater than return 1, equal to return 0 |
All three tests in one. If $f is less than $s return -1, greater than return 1, equal to return 0 |
||
< |
<syntaxhighlight lang="perl">sub test_num { |
||
return $_[0] <=> $_[1]; |
return $_[0] <=> $_[1]; |
||
};</ |
};</syntaxhighlight> |
||
Note: In Perl, $a and $b are (kind of) reserved identifiers for the built-in ''sort'' function. It's good style to use more meaningful names, anyway. |
Note: In Perl, $a and $b are (kind of) reserved identifiers for the built-in ''sort'' function. It's good style to use more meaningful names, anyway. |
||
< |
<syntaxhighlight lang="perl"># Get input, test and display |
||
print "Enter two integers: "; |
print "Enter two integers: "; |
||
($x, $y) = split ' ', <>; |
($x, $y) = split ' ', <>; |
||
print $x, (" is less than ", " is equal to ", |
print $x, (" is less than ", " is equal to ", |
||
" is greater than ")[test_num($x, $y) + 1], $y, "\n";</ |
" is greater than ")[test_num($x, $y) + 1], $y, "\n";</syntaxhighlight> |
||
=={{header|Phix}}== |
=={{header|Phix}}== |
||
{{libheader|Phix/basics}} |
{{libheader|Phix/basics}} |
||
<!--< |
<!--<syntaxhighlight lang="phix">--> |
||
<span style="color: #004080;">atom</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prompt_number</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"first number:"</span><span style="color: #0000FF;">,{}),</span> |
<span style="color: #004080;">atom</span> <span style="color: #000000;">a</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prompt_number</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"first number:"</span><span style="color: #0000FF;">,{}),</span> |
||
<span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prompt_number</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"second number:"</span><span style="color: #0000FF;">,{})</span> |
<span style="color: #000000;">b</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prompt_number</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"second number:"</span><span style="color: #0000FF;">,{})</span> |
||
Line 3,082: | Line 3,307: | ||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
<span style="color: #008080;">end</span> <span style="color: #008080;">if</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;">" %g"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</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;">" %g"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">)</span> |
||
<!--</ |
<!--</syntaxhighlight>--> |
||
=={{header|Phixmonti}}== |
|||
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: http://rosettacode.org/wiki/Integer_comparison |
|||
by Galileo, 10/2022 #/ |
|||
"Enter first number: " input tonum nl |
|||
"Enter second number: " input tonum nl |
|||
over over - |
|||
rot print " is " print |
|||
/# dup 0 < if drop "less" else 0 > if "greater" else "equal" endif endif #/ |
|||
dup 0 < if drop "less" else dup 0 > if drop "greater" else dup 0 == if drop "equal" endif endif endif |
|||
print " than " print print |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Enter first number: 5 |
|||
Enter second number: 1 |
|||
5 is greater than 1 |
|||
=== Press any key to exit ===</pre> |
|||
=={{header|PHL}}== |
=={{header|PHL}}== |
||
< |
<syntaxhighlight lang="phl">module intergertest; |
||
extern printf; |
extern printf; |
||
Line 3,106: | Line 3,350: | ||
return 0; |
return 0; |
||
]</ |
]</syntaxhighlight> |
||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
< |
<syntaxhighlight lang="php"><?php |
||
echo "Enter an integer [int1]: "; |
echo "Enter an integer [int1]: "; |
||
Line 3,135: | Line 3,379: | ||
echo "int1 > int2\n"; |
echo "int1 > int2\n"; |
||
?></ |
?></syntaxhighlight> |
||
Note that this works from the command-line interface only, whereas [http://www.php.net PHP] is usually executed as [[wp:Common_Gateway_Interface CGI]]. |
Note that this works from the command-line interface only, whereas [http://www.php.net PHP] is usually executed as [[wp:Common_Gateway_Interface CGI]]. |
||
=={{header|PicoLisp}}== |
=={{header|PicoLisp}}== |
||
< |
<syntaxhighlight lang="picolisp">(prin "Please enter two values: ") |
||
(in NIL # Read from standard input |
(in NIL # Read from standard input |
||
Line 3,149: | Line 3,393: | ||
((= A B) "equal to") |
((= A B) "equal to") |
||
(T "less than") ) |
(T "less than") ) |
||
" the second." ) ) )</ |
" the second." ) ) )</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre>Please enter two values: 4 3 |
<pre>Please enter two values: 4 3 |
||
Line 3,155: | Line 3,399: | ||
=={{header|Pike}}== |
=={{header|Pike}}== |
||
< |
<syntaxhighlight lang="pike">int main(int argc, array(int) argv){ |
||
if(argc != 3){ |
if(argc != 3){ |
||
write("usage: `pike compare-two-ints.pike <x> <y>` where x and y are integers.\n"); |
write("usage: `pike compare-two-ints.pike <x> <y>` where x and y are integers.\n"); |
||
Line 3,171: | Line 3,415: | ||
write(a + " is equal to " + b + "\n"); |
write(a + " is equal to " + b + "\n"); |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|PL/I}}== |
=={{header|PL/I}}== |
||
<syntaxhighlight lang="pl/i"> |
|||
<lang PL/I> |
|||
declare (a, b) fixed binary; |
declare (a, b) fixed binary; |
||
Line 3,184: | Line 3,428: | ||
if a < b then |
if a < b then |
||
put skip list ('The second number is greater than the first'); |
put skip list ('The second number is greater than the first'); |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Plain English}}== |
=={{header|Plain English}}== |
||
< |
<syntaxhighlight lang="plainenglish">To run: |
||
Start up. |
Start up. |
||
Write "Enter the first number: " to the console without advancing. |
Write "Enter the first number: " to the console without advancing. |
||
Line 3,197: | Line 3,441: | ||
If the first number is greater than the second number, write "Greater than!" to the console. |
If the first number is greater than the second number, write "Greater than!" to the console. |
||
Wait for the escape key. |
Wait for the escape key. |
||
Shut down.</ |
Shut down.</syntaxhighlight> |
||
=={{header|Pop11}}== |
=={{header|Pop11}}== |
||
< |
<syntaxhighlight lang="pop11">;;; Comparison procedure |
||
define compare_integers(x, y); |
define compare_integers(x, y); |
||
if x > y then |
if x > y then |
||
Line 3,216: | Line 3,460: | ||
;;; Read numbers and call comparison procedure |
;;; Read numbers and call comparison procedure |
||
compare_integers(itemrep(), itemrep());</ |
compare_integers(itemrep(), itemrep());</syntaxhighlight> |
||
=={{header|PowerShell}}== |
=={{header|PowerShell}}== |
||
< |
<syntaxhighlight lang="powershell">$a = [int] (Read-Host a) |
||
$b = [int] (Read-Host b) |
$b = [int] (Read-Host b) |
||
Line 3,228: | Line 3,472: | ||
} elseif ($a -gt $b) { |
} elseif ($a -gt $b) { |
||
Write-Host $a is greater than $b`. |
Write-Host $a is greater than $b`. |
||
}</ |
}</syntaxhighlight> |
||
=={{header|PureBasic}}== |
|||
<lang PureBasic>If OpenConsole() |
|||
Print("Enter an integer: ") |
|||
x.i = Val(Input()) |
|||
Print("Enter another integer: ") |
|||
y.i = Val(Input()) |
|||
If x < y |
|||
Print( "The first integer is less than the second integer.") |
|||
ElseIf x = y |
|||
Print("The first integer is equal to the second integer.") |
|||
ElseIf x > y |
|||
Print("The first integer is greater than the second integer.") |
|||
EndIf |
|||
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit") |
|||
Input() |
|||
CloseConsole() |
|||
EndIf</lang> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
< |
<syntaxhighlight lang="python">#!/usr/bin/env python |
||
a = input('Enter value of a: ') |
a = input('Enter value of a: ') |
||
b = input('Enter value of b: ') |
b = input('Enter value of b: ') |
||
Line 3,261: | Line 3,484: | ||
print 'a is greater than b' |
print 'a is greater than b' |
||
elif a == b: |
elif a == b: |
||
print 'a is equal to b'</ |
print 'a is equal to b'</syntaxhighlight> |
||
(Note: in Python3 ''input()'' will become ''int(input())'') |
(Note: in Python3 ''input()'' will become ''int(input())'') |
||
Line 3,268: | Line 3,491: | ||
{{works with|Python|2.x only, not 3.x}} |
{{works with|Python|2.x only, not 3.x}} |
||
< |
<syntaxhighlight lang="python">#!/usr/bin/env python |
||
import sys |
import sys |
||
try: |
try: |
||
Line 3,282: | Line 3,505: | ||
1: 'is greater than' |
1: 'is greater than' |
||
} |
} |
||
print a, dispatch[cmp(a,b)], b</ |
print a, dispatch[cmp(a,b)], b</syntaxhighlight> |
||
In this case the use of a dispatch table is silly. However, more generally in Python the use of dispatch dictionaries or tables is often preferable to long chains of '''''elif'''' clauses in a condition statement. Python's support of classes and functions (including [[currying]], partial function support, and lambda expressions) as first class objects obviates the need for a "case" or "switch" statement. |
In this case the use of a dispatch table is silly. However, more generally in Python the use of dispatch dictionaries or tables is often preferable to long chains of '''''elif'''' clauses in a condition statement. Python's support of classes and functions (including [[currying]], partial function support, and lambda expressions) as first class objects obviates the need for a "case" or "switch" statement. |
||
Line 3,288: | Line 3,511: | ||
=={{header|Quackery}}== |
=={{header|Quackery}}== |
||
< |
<syntaxhighlight lang="quackery">$ "Please enter two numbers separated by a space; " |
||
input quackery cr |
input quackery cr |
||
say "The first number is " |
say "The first number is " |
||
Line 3,295: | Line 3,518: | ||
2dup < if [ say "smaller than" ] ] |
2dup < if [ say "smaller than" ] ] |
||
2drop |
2drop |
||
say " the second number." cr</ |
say " the second number." cr</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 3,317: | Line 3,540: | ||
=={{header|R}}== |
=={{header|R}}== |
||
< |
<syntaxhighlight lang="r">print("insert number a") |
||
a <- scan(what=numeric(0), nmax=1) |
a <- scan(what=numeric(0), nmax=1) |
||
print("insert number b") |
print("insert number b") |
||
Line 3,327: | Line 3,550: | ||
} else if ( a == b ) { # could be simply else of course... |
} else if ( a == b ) { # could be simply else of course... |
||
print("a and b are the same") |
print("a and b are the same") |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Racket}}== |
=={{header|Racket}}== |
||
< |
<syntaxhighlight lang="racket">#lang racket |
||
(define (compare-two-ints a b) |
(define (compare-two-ints a b) |
||
(define compared |
(define compared |
||
Line 3,338: | Line 3,561: | ||
(format "~a ~a ~a" a compared b)) |
(format "~a ~a ~a" a compared b)) |
||
(compare-two-ints (read) (read))</ |
(compare-two-ints (read) (read))</syntaxhighlight> |
||
=={{header|Raku}}== |
=={{header|Raku}}== |
||
(formerly Perl 6) |
(formerly Perl 6) |
||
<lang |
<syntaxhighlight lang="raku" line>my $a = prompt("1st int: ").floor; |
||
my $b = prompt("2nd int: ").floor; |
my $b = prompt("2nd int: ").floor; |
||
Line 3,353: | Line 3,576: | ||
elsif $a == $b { |
elsif $a == $b { |
||
say 'Equal'; |
say 'Equal'; |
||
}</ |
}</syntaxhighlight> |
||
With <code><=></code>: |
With <code><=></code>: |
||
<lang |
<syntaxhighlight lang="raku" line>say <Less Equal Greater>[($a <=> $b) + 1];</syntaxhighlight> |
||
A three-way comparison such as <tt><=></tt> actually returns an <code>Order</code> enum which stringifies into 'Decrease', 'Increase' or 'Same'. So if it's ok to use this particular vocabulary, you could say that this task is actually a built in: |
A three-way comparison such as <tt><=></tt> actually returns an <code>Order</code> enum which stringifies into 'Decrease', 'Increase' or 'Same'. So if it's ok to use this particular vocabulary, you could say that this task is actually a built in: |
||
<lang |
<syntaxhighlight lang="raku" line>say prompt("1st int: ") <=> prompt("2nd int: ");</syntaxhighlight> |
||
=={{header|Rapira}}== |
=={{header|Rapira}}== |
||
< |
<syntaxhighlight lang="rapira">output: "Enter two integers, a and b" |
||
input: a |
input: a |
||
input: b |
input: b |
||
Line 3,375: | Line 3,598: | ||
when a = b: |
when a = b: |
||
output: "a is equal to b" |
output: "a is equal to b" |
||
esac</ |
esac</syntaxhighlight> |
||
=={{header|Raven}}== |
=={{header|Raven}}== |
||
< |
<syntaxhighlight lang="raven">"Enter the first number: " print |
||
expect trim 1.1 prefer as $a |
expect trim 1.1 prefer as $a |
||
"Enter the second number: " print |
"Enter the second number: " print |
||
Line 3,385: | Line 3,608: | ||
$a $b < if $b $a "%g is less than %g\n" print |
$a $b < if $b $a "%g is less than %g\n" print |
||
$a $b > if $b $a "%g is greater than %g\n" print |
$a $b > if $b $a "%g is greater than %g\n" print |
||
$a $b = if $b $a "%g is equal to %g\n" print</ |
$a $b = if $b $a "%g is equal to %g\n" print</syntaxhighlight> |
||
=={{header|REBOL}}== |
=={{header|REBOL}}== |
||
<syntaxhighlight lang="rebol"> |
|||
<lang REBOL> |
|||
REBOL [ |
REBOL [ |
||
Title: "Comparing Two Integers" |
Title: "Comparing Two Integers" |
||
Line 3,402: | Line 3,625: | ||
] |
] |
||
print [a "is" case relation b] |
print [a "is" case relation b] |
||
</syntaxhighlight> |
|||
</lang> |
|||
==={{header|Relation}}=== |
==={{header|Relation}}=== |
||
There is no input, so numbers have to be given in code |
There is no input, so numbers have to be given in code |
||
<syntaxhighlight lang="relation"> |
|||
<lang Relation> |
|||
set a = 15 |
set a = 15 |
||
set b = 21 |
set b = 21 |
||
Line 3,418: | Line 3,641: | ||
end if |
end if |
||
end if |
end if |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Red}}== |
=={{header|Red}}== |
||
{{trans|REBOL}} |
{{trans|REBOL}} |
||
< |
<syntaxhighlight lang="rebol">Red [ |
||
Title: "Comparing Two Integers" |
Title: "Comparing Two Integers" |
||
URL: http://rosettacode.org/wiki/Comparing_two_integers |
URL: http://rosettacode.org/wiki/Comparing_two_integers |
||
Line 3,435: | Line 3,658: | ||
a > b "greater than" |
a > b "greater than" |
||
] |
] |
||
print [a "is" case relation b]</ |
print [a "is" case relation b]</syntaxhighlight> |
||
=={{header|ReScript}}== |
=={{header|ReScript}}== |
||
< |
<syntaxhighlight lang="rescript">let my_compare = (a, b) => { |
||
if a < b { "A is less than B" } else |
if a < b { "A is less than B" } else |
||
if a > b { "A is greater than B" } else |
if a > b { "A is greater than B" } else |
||
Line 3,449: | Line 3,672: | ||
let b = int_of_string(Sys.argv[3]) |
let b = int_of_string(Sys.argv[3]) |
||
Js.log(my_compare(a, b))</ |
Js.log(my_compare(a, b))</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 3,464: | Line 3,687: | ||
Taking the numbers from the stack: |
Taking the numbers from the stack: |
||
< |
<syntaxhighlight lang="retro">:example (ab-) |
||
dup-pair gt? [ 'A>B s:put nl ] if |
dup-pair gt? [ 'A>B s:put nl ] if |
||
dup-pair lt? [ 'A<B s:put nl ] if |
dup-pair lt? [ 'A<B s:put nl ] if |
||
eq? [ 'A=B s:put nl ] if ;</ |
eq? [ 'A=B s:put nl ] if ;</syntaxhighlight> |
||
=={{header|REXX}}== |
=={{header|REXX}}== |
||
< |
<syntaxhighlight lang="rexx">/*REXX program prompts for two integers, compares them, and displays the results.*/ |
||
numeric digits 2000 /*for the users that really go ka─razy.*/ |
numeric digits 2000 /*for the users that really go ka─razy.*/ |
||
@=copies('─', 20) /*eyeball catcher for the user's eyen. */ |
@=copies('─', 20) /*eyeball catcher for the user's eyen. */ |
||
Line 3,493: | Line 3,716: | ||
end /*forever*/ |
end /*forever*/ |
||
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
/*──────────────────────────────────────────────────────────────────────────────────────*/ |
||
serr: say @ '***error*** ' arg(1); say @ "Please try again."; return</ |
serr: say @ '***error*** ' arg(1); say @ "Please try again."; return</syntaxhighlight> |
||
{{out|output|text= (shows user input and computer program output together):}} |
{{out|output|text= (shows user input and computer program output together):}} |
||
<pre> |
<pre> |
||
Line 3,521: | Line 3,744: | ||
=={{header|Ring}}== |
=={{header|Ring}}== |
||
< |
<syntaxhighlight lang="ring"> |
||
Func Compare a,b |
Func Compare a,b |
||
if a < b |
if a < b |
||
Line 3,530: | Line 3,753: | ||
See "A equals B" |
See "A equals B" |
||
ok |
ok |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|Rockstar}}== |
=={{header|Rockstar}}== |
||
Line 3,536: | Line 3,759: | ||
Minimized Rockstar: |
Minimized Rockstar: |
||
<syntaxhighlight lang="rockstar"> |
|||
<lang Rockstar> |
|||
(Get two numbers from user) |
(Get two numbers from user) |
||
Listen to Number One |
Listen to Number One |
||
Line 3,551: | Line 3,774: | ||
If Number One is less than Number Two |
If Number One is less than Number Two |
||
Say "The first is less than the second" |
Say "The first is less than the second" |
||
</syntaxhighlight> |
|||
</lang> |
|||
Idiomatic version: |
Idiomatic version: |
||
<syntaxhighlight lang="rockstar"> |
|||
<lang Rockstar> |
|||
Listen to your soul |
Listen to your soul |
||
Listen to my words |
Listen to my words |
||
Line 3,566: | Line 3,789: | ||
If your soul is smaller than my words, |
If your soul is smaller than my words, |
||
Say "The second was bigger". |
Say "The second was bigger". |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|RPG}}== |
=={{header|RPG}}== |
||
Line 3,573: | Line 3,796: | ||
CALL rc_intcmp (x'00000000' x'00000001') |
CALL rc_intcmp (x'00000000' x'00000001') |
||
<syntaxhighlight lang="rpg"> |
|||
<lang RPG> |
|||
h dftactgrp(*no) |
h dftactgrp(*no) |
||
Line 3,596: | Line 3,819: | ||
dsply message; |
dsply message; |
||
*inlr = *on; |
*inlr = *on; |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|RPL}}== |
|||
≪ '''IF''' DUP2 < '''THEN''' "a < b" ROT ROT '''END''' |
|||
'''IF''' DUP2 == '''THEN''' "a = b" ROT ROT '''END''' |
|||
'''IF''' > '''THEN''' "a > b" '''END''' |
|||
≫ 'COMPR' STO |
|||
{{in}} |
|||
<pre> |
|||
3 5 COMPR |
|||
</pre> |
|||
{{out}} |
|||
<pre> |
|||
1: "a < b" |
|||
</pre> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
This uses Kernel#gets to get input from STDIN, and String#to_i to convert the string into an integer. (Without this conversion, Ruby would compare strings: 5 < 10 but "5" > "10".) |
This uses Kernel#gets to get input from STDIN, and String#to_i to convert the string into an integer. (Without this conversion, Ruby would compare strings: 5 < 10 but "5" > "10".) |
||
< |
<syntaxhighlight lang="ruby">a = (print "enter a value for a: "; gets).to_i |
||
b = (print "enter a value for b: "; gets).to_i |
b = (print "enter a value for b: "; gets).to_i |
||
puts "#{a} is less than #{b}" if a < b |
puts "#{a} is less than #{b}" if a < b |
||
puts "#{a} is greater than #{b}" if a > b |
puts "#{a} is greater than #{b}" if a > b |
||
puts "#{a} is equal to #{b}" if a == b</ |
puts "#{a} is equal to #{b}" if a == b</syntaxhighlight> |
||
Another way: |
Another way: |
||
< |
<syntaxhighlight lang="ruby">a = (print "enter a value for a: "; gets).to_i |
||
b = (print "enter a value for b: "; gets).to_i |
b = (print "enter a value for b: "; gets).to_i |
||
Line 3,617: | Line 3,854: | ||
when 0; puts "#{a} is equal to #{b}" |
when 0; puts "#{a} is equal to #{b}" |
||
when +1; puts "#{a} is greater than #{b}" |
when +1; puts "#{a} is greater than #{b}" |
||
end</ |
end</syntaxhighlight> |
||
Example '''input''' and output: |
Example '''input''' and output: |
||
Line 3,635: | Line 3,872: | ||
An alternative method, which is similar to the python version mentioned above (at the time of writing this) is: |
An alternative method, which is similar to the python version mentioned above (at the time of writing this) is: |
||
< |
<syntaxhighlight lang="ruby"># Function to make prompts nice and simple to abuse |
||
def prompt str |
def prompt str |
||
print str, ": " |
print str, ": " |
||
Line 3,658: | Line 3,895: | ||
# I hope you can figure this out |
# I hope you can figure this out |
||
puts "#{a} is #{dispatch[a<=>b]} #{b}"</ |
puts "#{a} is #{dispatch[a<=>b]} #{b}"</syntaxhighlight> |
||
=={{header|Run BASIC}}== |
|||
<lang runbasic>input "1st number:"; n1 |
|||
input "2nd number:"; n2 |
|||
if n1 < n2 then print "1st number ";n1;" is less than 2nd number";n2 |
|||
if n1 > n2 then print "1st number ";n1;" is greater than 2nd number";n2 |
|||
if n1 = n2 then print "1st number ";n1;" is equal to 2nd number";n2</lang> |
|||
=={{header|Rust}}== |
=={{header|Rust}}== |
||
Reading from stdin into a string is cumbersome at the moment, but convenience functions will be implemented in the future. |
Reading from stdin into a string is cumbersome at the moment, but convenience functions will be implemented in the future. |
||
< |
<syntaxhighlight lang="rust">use std::io::{self, BufRead}; |
||
fn main() { |
fn main() { |
||
Line 3,688: | Line 3,917: | ||
println!("{} is greater than {}" , a , b) |
println!("{} is greater than {}" , a , b) |
||
}; |
}; |
||
}</ |
}</syntaxhighlight> |
||
=={{header|SAS}}== |
=={{header|SAS}}== |
||
< |
<syntaxhighlight lang="sas">/* Showing operators and their fortran-like equivalents. Note that ~= and ^= both mean "different" */ |
||
data _null_; |
data _null_; |
||
input a b; |
input a b; |
||
Line 3,713: | Line 3,942: | ||
1 1 |
1 1 |
||
; |
; |
||
run;</ |
run;</syntaxhighlight> |
||
=={{header|Scala}}== |
=={{header|Scala}}== |
||
< |
<syntaxhighlight lang="scala">object IntCompare { |
||
def main(args: Array[String]): Unit = { |
def main(args: Array[String]): Unit = { |
||
val a=Console.readInt |
val a=Console.readInt |
||
Line 3,727: | Line 3,956: | ||
printf("%d is greater than %d\n", a, b) |
printf("%d is greater than %d\n", a, b) |
||
} |
} |
||
}</ |
}</syntaxhighlight> |
||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
< |
<syntaxhighlight lang="scheme">(define (my-compare a b) |
||
(cond ((< a b) "A is less than B") |
(cond ((< a b) "A is less than B") |
||
((> a b) "A is greater than B") |
((> a b) "A is greater than B") |
||
((= a b) "A equals B"))) |
((= a b) "A equals B"))) |
||
(my-compare (read) (read))</ |
(my-compare (read) (read))</syntaxhighlight> |
||
=={{header|Seed7}}== |
=={{header|Seed7}}== |
||
< |
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
||
const proc: main is func |
const proc: main is func |
||
Line 3,759: | Line 3,988: | ||
writeln(a <& " is greater than " <& b); |
writeln(a <& " is greater than " <& b); |
||
end if; |
end if; |
||
end func;</ |
end func;</syntaxhighlight> |
||
=={{header|SenseTalk}}== |
=={{header|SenseTalk}}== |
||
< |
<syntaxhighlight lang="sensetalk">Ask "Provide Any Number" |
||
Put It into A |
Put It into A |
||
Line 3,781: | Line 4,010: | ||
If A is Equal to B |
If A is Equal to B |
||
Put A& " is Equal to " &B |
Put A& " is Equal to " &B |
||
End If</ |
End If</syntaxhighlight> |
||
=={{header|Sidef}}== |
=={{header|Sidef}}== |
||
< |
<syntaxhighlight lang="ruby">var a = read("a: ", Number); |
||
var b = read("b: ", Number); |
var b = read("b: ", Number); |
||
Line 3,795: | Line 4,024: | ||
elsif (a > b) { |
elsif (a > b) { |
||
say 'Greater'; |
say 'Greater'; |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 3,805: | Line 4,034: | ||
=={{header|Slate}}== |
=={{header|Slate}}== |
||
< |
<syntaxhighlight lang="slate">[ |:a :b | |
||
( a > b ) ifTrue: [ inform: 'a greater than b\n' ]. |
( a > b ) ifTrue: [ inform: 'a greater than b\n' ]. |
||
Line 3,811: | Line 4,040: | ||
( a = b ) ifTrue: [ inform: 'a is equal to b\n' ]. |
( a = b ) ifTrue: [ inform: 'a is equal to b\n' ]. |
||
] applyTo: {Integer readFrom: (query: 'Enter a: '). Integer readFrom: (query: 'Enter b: ')}.</ |
] applyTo: {Integer readFrom: (query: 'Enter a: '). Integer readFrom: (query: 'Enter b: ')}.</syntaxhighlight> |
||
=={{header|Smalltalk}}== |
=={{header|Smalltalk}}== |
||
< |
<syntaxhighlight lang="smalltalk">| a b | |
||
'a = ' display. a := (stdin nextLine asInteger). |
'a = ' display. a := (stdin nextLine asInteger). |
||
'b = ' display. b := (stdin nextLine asInteger). |
'b = ' display. b := (stdin nextLine asInteger). |
||
( a > b ) ifTrue: [ 'a greater than b' displayNl ]. |
( a > b ) ifTrue: [ 'a greater than b' displayNl ]. |
||
( a < b ) ifTrue: [ 'a less than b' displayNl ]. |
( a < b ) ifTrue: [ 'a less than b' displayNl ]. |
||
( a = b ) ifTrue: [ 'a is equal to b' displayNl ].</ |
( a = b ) ifTrue: [ 'a is equal to b' displayNl ].</syntaxhighlight> |
||
=={{header|SNOBOL4}}== |
=={{header|SNOBOL4}}== |
||
Line 3,826: | Line 4,055: | ||
Comparisons in Snobol are not operators, but predicate functions that return a null string and generate a success or failure value which allows or blocks statement execution, and which can be tested for branching. Other numeric comparisons are ge (>=), le (<=) and ne (!= ). There is also a parallel set of L-prefixed predicates in modern Snobols for lexical string comparison. |
Comparisons in Snobol are not operators, but predicate functions that return a null string and generate a success or failure value which allows or blocks statement execution, and which can be tested for branching. Other numeric comparisons are ge (>=), le (<=) and ne (!= ). There is also a parallel set of L-prefixed predicates in modern Snobols for lexical string comparison. |
||
< |
<syntaxhighlight lang="snobol4">* # Get user input |
||
output = 'Enter X,Y:' |
output = 'Enter X,Y:' |
||
trim(input) break(',') . x ',' rem . y |
trim(input) break(',') . x ',' rem . y |
||
Line 3,833: | Line 4,062: | ||
output = eq(x,y) x ' is equal to ' y :s(end) |
output = eq(x,y) x ' is equal to ' y :s(end) |
||
output = gt(x,y) x ' is greater than ' y |
output = gt(x,y) x ' is greater than ' y |
||
end</ |
end</syntaxhighlight> |
||
=={{header|SNUSP}}== |
=={{header|SNUSP}}== |
||
There are no built-in comparison operators, but you can (destructively) check which of two adjacent cells is most positive. |
There are no built-in comparison operators, but you can (destructively) check which of two adjacent cells is most positive. |
||
< |
<syntaxhighlight lang="snusp">++++>++++ a b !/?\<?\# a=b |
||
> - \# a>b |
> - \# a>b |
||
- < |
- < |
||
a<b #\?/</ |
a<b #\?/</syntaxhighlight> |
||
=={{header|Sparkling}}== |
=={{header|Sparkling}}== |
||
< |
<syntaxhighlight lang="sparkling">let a = 13, b = 37; |
||
if a < b { |
if a < b { |
||
print("a < b"); |
print("a < b"); |
||
Line 3,852: | Line 4,081: | ||
} else { |
} else { |
||
print("either a or b or both are NaN"); |
print("either a or b or both are NaN"); |
||
}</ |
}</syntaxhighlight> |
||
=={{header|SQL}}== |
=={{header|SQL}}== |
||
{{works with|Oracle}} |
{{works with|Oracle}} |
||
< |
<syntaxhighlight lang="sql"> |
||
drop table test; |
drop table test; |
||
Line 3,878: | Line 4,107: | ||
from test |
from test |
||
where a > b; |
where a > b; |
||
</syntaxhighlight> |
|||
</lang> |
|||
<pre> |
<pre> |
||
Line 3,900: | Line 4,129: | ||
{{works with|Db2 LUW}} |
{{works with|Db2 LUW}} |
||
With SQL only: |
With SQL only: |
||
< |
<syntaxhighlight lang="sql pl"> |
||
CREATE TABLE TEST ( |
CREATE TABLE TEST ( |
||
VAL1 INT, |
VAL1 INT, |
||
Line 3,916: | Line 4,145: | ||
END COMPARISON |
END COMPARISON |
||
FROM TEST; |
FROM TEST; |
||
</syntaxhighlight> |
|||
</lang> |
|||
Output: |
Output: |
||
<pre> |
<pre> |
||
Line 3,948: | Line 4,177: | ||
{{works with|Db2 LUW}} version 9.7 or higher. |
{{works with|Db2 LUW}} version 9.7 or higher. |
||
With SQL PL: |
With SQL PL: |
||
< |
<syntaxhighlight lang="sql pl"> |
||
--#SET TERMINATOR @ |
--#SET TERMINATOR @ |
||
Line 3,966: | Line 4,195: | ||
CALL COMPARISON(2, 2) @ |
CALL COMPARISON(2, 2) @ |
||
CALL COMPARISON(2, 1) @ |
CALL COMPARISON(2, 1) @ |
||
</syntaxhighlight> |
|||
</lang> |
|||
Output: |
Output: |
||
<pre> |
<pre> |
||
Line 4,018: | Line 4,247: | ||
halt</pre> |
halt</pre> |
||
To run the SSEM program, load A into storage address 21 and B into storage address 22. No additional space is used. Like the pseudocode version, the program halts with the accumulator holding 1 if A>B, 0 if A=B, or -1 if A<B. |
To run the SSEM program, load A into storage address 21 and B into storage address 22. No additional space is used. Like the pseudocode version, the program halts with the accumulator holding 1 if A>B, 0 if A=B, or -1 if A<B. |
||
< |
<syntaxhighlight lang="ssem">10101000000000100000000000000000 0. -21 to c |
||
10101000000001100000000000000000 1. c to 21 |
10101000000001100000000000000000 1. c to 21 |
||
10101000000000100000000000000000 2. -21 to c |
10101000000000100000000000000000 2. -21 to c |
||
Line 4,038: | Line 4,267: | ||
11111111111111111111111111111111 18. -1 |
11111111111111111111111111111111 18. -1 |
||
11010000000000000000000000000000 19. 11 |
11010000000000000000000000000000 19. 11 |
||
10110000000000000000000000000000 20. 13</ |
10110000000000000000000000000000 20. 13</syntaxhighlight> |
||
=={{header|Standard ML}}== |
=={{header|Standard ML}}== |
||
< |
<syntaxhighlight lang="sml">fun compare_integers(a, b) = |
||
if a < b then print "A is less than B\n" |
if a < b then print "A is less than B\n" |
||
if a > b then print "A is greater than B\n" |
if a > b then print "A is greater than B\n" |
||
Line 4,054: | Line 4,283: | ||
compare_integers (a, b) |
compare_integers (a, b) |
||
end |
end |
||
handle Bind => print "Invalid number entered!\n"</ |
handle Bind => print "Invalid number entered!\n"</syntaxhighlight> |
||
A more idiomatic and less error-prone way to do it in SML would be to use a compare function that returns type <tt>order</tt>, which is either LESS, GREATER, or EQUAL: |
A more idiomatic and less error-prone way to do it in SML would be to use a compare function that returns type <tt>order</tt>, which is either LESS, GREATER, or EQUAL: |
||
< |
<syntaxhighlight lang="sml">fun myCompare (a, b) = case Int.compare (a, b) of |
||
LESS => "A is less than B" |
LESS => "A is less than B" |
||
| GREATER => "A is greater than B" |
| GREATER => "A is greater than B" |
||
| EQUAL => "A equals B"</ |
| EQUAL => "A equals B"</syntaxhighlight> |
||
=={{header|Swift}}== |
=={{header|Swift}}== |
||
< |
<syntaxhighlight lang="swift">import Cocoa |
||
var input = NSFileHandle.fileHandleWithStandardInput() |
var input = NSFileHandle.fileHandleWithStandardInput() |
||
Line 4,078: | Line 4,307: | ||
if (a==b) {println("\(a) equals \(b)")} |
if (a==b) {println("\(a) equals \(b)")} |
||
if (a < b) {println("\(a) is less than \(b)")} |
if (a < b) {println("\(a) is less than \(b)")} |
||
if (a > b) {println("\(a) is greater than \(b)")}</ |
if (a > b) {println("\(a) is greater than \(b)")}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 4,089: | Line 4,318: | ||
This is not how one would write this in Tcl, but for the sake of clarity: |
This is not how one would write this in Tcl, but for the sake of clarity: |
||
< |
<syntaxhighlight lang="tcl">puts "Please enter two numbers:" |
||
gets stdin x |
gets stdin x |
||
Line 4,096: | Line 4,325: | ||
if { $x > $y } { puts "$x is greater than $y" } |
if { $x > $y } { puts "$x is greater than $y" } |
||
if { $x < $y } { puts "$x is less than $y" } |
if { $x < $y } { puts "$x is less than $y" } |
||
if { $x == $y } { puts "$x equals $y" }</ |
if { $x == $y } { puts "$x equals $y" }</syntaxhighlight> |
||
Other comparison operators are "<=", ">=" and "!=". |
Other comparison operators are "<=", ">=" and "!=". |
||
Line 4,102: | Line 4,331: | ||
Note that Tcl doesn't really have a notion of a variable "type" - all variables are just strings of bytes and notions like "integer" only ever enter at interpretation time. Thus the above code will work correctly for "5" and "6", but "5" and "5.5" will also be compared correctly. It will not be an error to enter "hello" for one of the numbers ("hello" is greater than any integer). If this is a problem, the type can be expressly cast |
Note that Tcl doesn't really have a notion of a variable "type" - all variables are just strings of bytes and notions like "integer" only ever enter at interpretation time. Thus the above code will work correctly for "5" and "6", but "5" and "5.5" will also be compared correctly. It will not be an error to enter "hello" for one of the numbers ("hello" is greater than any integer). If this is a problem, the type can be expressly cast |
||
< |
<syntaxhighlight lang="tcl">if {int($x) > int($y)} { puts "$x is greater than $y" }</syntaxhighlight> |
||
or otherwise [[IsNumeric | type can be checked]] with "<tt>if { string is integer $x }...</tt>" |
or otherwise [[IsNumeric | type can be checked]] with "<tt>if { string is integer $x }...</tt>" |
||
Line 4,109: | Line 4,338: | ||
A variant that iterates over comparison operators, demonstrated in an interactive [[tclsh]]: |
A variant that iterates over comparison operators, demonstrated in an interactive [[tclsh]]: |
||
< |
<syntaxhighlight lang="tcl">% set i 5;set j 6 |
||
% foreach {o s} {< "less than" > "greater than" == equal} {if [list $i $o $j] {puts "$i is $s $j"}} |
% foreach {o s} {< "less than" > "greater than" == equal} {if [list $i $o $j] {puts "$i is $s $j"}} |
||
5 is less than 6 |
5 is less than 6 |
||
Line 4,117: | Line 4,346: | ||
% set j 4 |
% set j 4 |
||
% foreach {o s} {< "less than" > "greater than" == equal} {if [list $i $o $j] {puts "$i is $s $j"}} |
% foreach {o s} {< "less than" > "greater than" == equal} {if [list $i $o $j] {puts "$i is $s $j"}} |
||
5 is greater than 4</ |
5 is greater than 4</syntaxhighlight> |
||
=={{header|TI-83 BASIC}}== |
|||
<lang ti83b>Prompt A,B |
|||
If A<B: Disp "A SMALLER B" |
|||
If A>B: Disp "A GREATER B" |
|||
If A=B: Disp "A EQUAL B"</lang> |
|||
=={{header|TI-89 BASIC}}== |
|||
<lang ti89b>Local a, b, result |
|||
Prompt a, b |
|||
If a < b Then |
|||
"<" → result |
|||
ElseIf a = b Then |
|||
"=" → result |
|||
ElseIf a > b Then |
|||
">" → result |
|||
Else |
|||
"???" → result |
|||
EndIf |
|||
Disp string(a) & " " & result & " " & string(b)</lang> |
|||
=={{header|Toka}}== |
=={{header|Toka}}== |
||
< |
<syntaxhighlight lang="toka">[ ( a b -- ) |
||
2dup < [ ." a is less than b\n" ] ifTrue |
2dup < [ ." a is less than b\n" ] ifTrue |
||
2dup > [ ." a is greater than b\n" ] ifTrue |
2dup > [ ." a is greater than b\n" ] ifTrue |
||
Line 4,149: | Line 4,357: | ||
1 1 compare-integers |
1 1 compare-integers |
||
2 1 compare-integers |
2 1 compare-integers |
||
1 2 compare-integers</ |
1 2 compare-integers</syntaxhighlight> |
||
=={{header|TUSCRIPT}}== |
=={{header|TUSCRIPT}}== |
||
< |
<syntaxhighlight lang="tuscript"> |
||
$$ MODE TUSCRIPT |
$$ MODE TUSCRIPT |
||
Line 4,163: | Line 4,371: | ||
IF (i1<i2) PRINT i1," is less than ",i2 |
IF (i1<i2) PRINT i1," is less than ",i2 |
||
IF (i1>i2) PRINT i1," is greater than ",i2 |
IF (i1>i2) PRINT i1," is greater than ",i2 |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|UNIX Shell}}== |
=={{header|UNIX Shell}}== |
||
Line 4,170: | Line 4,378: | ||
{{works with|ksh93}} |
{{works with|ksh93}} |
||
< |
<syntaxhighlight lang="bash">#!/bin/ksh |
||
# tested with ksh93s+ |
# tested with ksh93s+ |
||
Line 4,191: | Line 4,399: | ||
fi |
fi |
||
exit 0</ |
exit 0</syntaxhighlight> |
||
One can backport the previous code to pdksh, which has no builtin printf, but can call /usr/bin/printf as an external program. |
One can backport the previous code to pdksh, which has no builtin printf, but can call /usr/bin/printf as an external program. |
||
Line 4,197: | Line 4,405: | ||
{{works with|pdksh}} |
{{works with|pdksh}} |
||
< |
<syntaxhighlight lang="bash">#!/bin/ksh |
||
# tested with pdksh |
# tested with pdksh |
||
Line 4,216: | Line 4,424: | ||
fi |
fi |
||
exit 0</ |
exit 0</syntaxhighlight> |
||
---- |
---- |
||
Line 4,222: | Line 4,430: | ||
{{works with|Bash}} |
{{works with|Bash}} |
||
< |
<syntaxhighlight lang="bash">read -p "Enter two integers: " a b |
||
if [ $a -gt $b ]; then comparison="greater than" |
if [ $a -gt $b ]; then comparison="greater than" |
||
Line 4,230: | Line 4,438: | ||
fi |
fi |
||
echo "${a} is ${comparison} ${b}"</ |
echo "${a} is ${comparison} ${b}"</syntaxhighlight> |
||
=={{header|Ursa}}== |
=={{header|Ursa}}== |
||
< |
<syntaxhighlight lang="ursa">decl int first second |
||
out "enter first integer: " console |
out "enter first integer: " console |
||
set first (in int console) |
set first (in int console) |
||
Line 4,247: | Line 4,455: | ||
if (> first second) |
if (> first second) |
||
out first " is greater than " second endl console |
out first " is greater than " second endl console |
||
end if</ |
end if</syntaxhighlight> |
||
=={{header|V}}== |
=={{header|V}}== |
||
< |
<syntaxhighlight lang="v">[compare |
||
[ [>] ['less than' puts] |
[ [>] ['less than' puts] |
||
[<] ['greater than' puts] |
[<] ['greater than' puts] |
||
Line 4,261: | Line 4,469: | ||
less than |
less than |
||
|2 2 compare |
|2 2 compare |
||
is equal</ |
is equal</syntaxhighlight> |
||
=={{header|Vala}}== |
=={{header|Vala}}== |
||
< |
<syntaxhighlight lang="vala"> |
||
void main(){ |
void main(){ |
||
int a; |
int a; |
||
Line 4,282: | Line 4,490: | ||
stdout.printf("%d is greater than %d\n", a, b); |
stdout.printf("%d is greater than %d\n", a, b); |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
=={{header|VBA}}== |
|||
<lang vb>Public Sub integer_comparison() |
|||
first_integer = CInt(InputBox("Give me an integer.")) |
|||
second_integer = CInt(InputBox("Give me another integer.")) |
|||
Debug.Print IIf(first_integer < second_integer, "first integer is smaller than second integer", "first integer is not smaller than second integer") |
|||
Debug.Print IIf(first_integer = second_integer, "first integer is equal to second integer", "first integer is not equal to second integer") |
|||
Debug.Print IIf(first_integer > second_integer, "first integer is bigger than second integer", "first integer is not bigger than second integer") |
|||
End Sub</lang> |
|||
=={{header|VBScript}}== |
|||
Based on the BASIC |
|||
=====Implementation===== |
|||
<lang vb> |
|||
option explicit |
|||
function eef( b, r1, r2 ) |
|||
if b then |
|||
eef = r1 |
|||
else |
|||
eef = r2 |
|||
end if |
|||
end function |
|||
dim a, b |
|||
wscript.stdout.write "First integer: " |
|||
a = cint(wscript.stdin.readline) 'force to integer |
|||
wscript.stdout.write "Second integer: " |
|||
b = cint(wscript.stdin.readline) 'force to integer |
|||
wscript.stdout.write "First integer is " |
|||
if a < b then wscript.stdout.write "less than " |
|||
if a = b then wscript.stdout.write "equal to " |
|||
if a > b then wscript.stdout.write "greater than " |
|||
wscript.echo "Second integer." |
|||
wscript.stdout.write "First integer is " & _ |
|||
eef( a < b, "less than ", _ |
|||
eef( a = b, "equal to ", _ |
|||
eef( a > b, "greater than ", vbnullstring ) ) ) & "Second integer." |
|||
</lang> |
|||
=={{header|Visual Basic .NET}}== |
|||
'''Platform:''' [[.NET]] |
|||
{{works with|Visual Basic .NET|9.0+}} |
|||
<lang vbnet>Sub Main() |
|||
Dim a = CInt(Console.ReadLine) |
|||
Dim b = CInt(Console.ReadLine) |
|||
'Using if statements |
|||
If a < b Then Console.WriteLine("a is less than b") |
|||
If a = b Then Console.WriteLine("a equals b") |
|||
If a > b Then Console.WriteLine("a is greater than b") |
|||
'Using Case |
|||
Select Case a |
|||
Case Is < b |
|||
Console.WriteLine("a is less than b") |
|||
Case b |
|||
Console.WriteLine("a equals b") |
|||
Case Is > b |
|||
Console.WriteLine("a is greater than b") |
|||
End Select |
|||
End Sub</lang> |
|||
=={{header|Wart}}== |
=={{header|Wart}}== |
||
< |
<syntaxhighlight lang="wart">a <- (read) |
||
b <- (read) |
b <- (read) |
||
prn (if (a < b) |
prn (if (a < b) |
||
Line 4,360: | Line 4,500: | ||
: "a is greater than b" |
: "a is greater than b" |
||
:else |
:else |
||
: "a equals b")</ |
: "a equals b")</syntaxhighlight> |
||
=={{header|Wren}}== |
=={{header|Wren}}== |
||
< |
<syntaxhighlight lang="wren">import "io" for Stdin, Stdout |
||
System.print("Enter anything other than a number to quit at any time.\n") |
System.print("Enter anything other than a number to quit at any time.\n") |
||
Line 4,384: | Line 4,524: | ||
} |
} |
||
System.print() |
System.print() |
||
}</ |
}</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
Line 4,407: | Line 4,547: | ||
=={{header|XLISP}}== |
=={{header|XLISP}}== |
||
< |
<syntaxhighlight lang="xlisp">(DEFUN COMPARE-INTEGERS () |
||
(DISPLAY "Enter two integers separated by a space.") |
(DISPLAY "Enter two integers separated by a space.") |
||
(NEWLINE) |
(NEWLINE) |
||
Line 4,416: | Line 4,556: | ||
((> A B) (DISPLAY "The first number is larger.")) |
((> A B) (DISPLAY "The first number is larger.")) |
||
((= A B) (DISPLAY "They are equal.")) |
((= A B) (DISPLAY "They are equal.")) |
||
((< A B) (DISPLAY "The first number is smaller."))))</ |
((< A B) (DISPLAY "The first number is smaller."))))</syntaxhighlight> |
||
=={{header|XPL0}}== |
=={{header|XPL0}}== |
||
< |
<syntaxhighlight lang="xpl0">code IntIn=10, Text=12; |
||
int A, B; |
int A, B; |
||
[A:= IntIn(0); |
[A:= IntIn(0); |
||
Line 4,427: | Line 4,567: | ||
if A>B then Text(0, "A>B"); |
if A>B then Text(0, "A>B"); |
||
CrLf(0); |
CrLf(0); |
||
]</ |
]</syntaxhighlight> |
||
=={{header|XSLT}}== |
=={{header|XSLT}}== |
||
Because XSLT uses XML syntax, the less than and greater than operators which would normally be written '<' and '>' must be escaped using character entities, even inside of XPath expressions. |
Because XSLT uses XML syntax, the less than and greater than operators which would normally be written '<' and '>' must be escaped using character entities, even inside of XPath expressions. |
||
< |
<syntaxhighlight lang="xml"><xsl:template name="compare"> |
||
<xsl:param name="a" select="1"/> |
<xsl:param name="a" select="1"/> |
||
<xsl:param name="b" select="2"/> |
<xsl:param name="b" select="2"/> |
||
Line 4,442: | Line 4,582: | ||
</xsl:choose> |
</xsl:choose> |
||
</fo:block> |
</fo:block> |
||
</xsl:template></ |
</xsl:template></syntaxhighlight> |
||
=={{header|zkl}}== |
=={{header|zkl}}== |
||
< |
<syntaxhighlight lang="zkl">var x,y; x,y=ask("Two ints: ").split(" ").apply("toInt") |
||
(if (x==y) "equal" else if (x<y) "less" else if(x>y) "greater").println()</ |
(if (x==y) "equal" else if (x<y) "less" else if(x>y) "greater").println()</syntaxhighlight> |
||
{{out}} |
{{out}} |
||
<pre> |
<pre> |
||
Line 4,452: | Line 4,592: | ||
greater |
greater |
||
</pre> |
</pre> |
||
=={{header|ZX Spectrum Basic}}== |
|||
<lang zxbasic>10 INPUT "Enter two integers: ";a;" ";b |
|||
20 PRINT a;" is ";("less than " AND (a<b));("equal to " AND (a=b));("greather than " AND (a>b));b</lang> |
Latest revision as of 06:59, 28 June 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.
Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.
You may see other such operations in the Basic Data Operations category, or:
Integer Operations
Arithmetic |
Comparison
Boolean Operations
Bitwise |
Logical
String Operations
Concatenation |
Interpolation |
Comparison |
Matching
Memory Operations
Pointers & references |
Addresses
Get two integers from the user.
Then, display a message if the first integer is:
- less than,
- equal to, or
- greater than
the second integer.
Test the condition for each case separately, so that all three comparison operators are used in the code.
- Related task
11l
V a = Int(input(‘Enter value of a: ’))
V b = Int(input(‘Enter value of b: ’))
I a < b
print(‘a is less than b’)
I a > b
print(‘a is greater than b’)
I a == b
print(‘a is equal to b’)
360 Assembly
Input is done by a standard register 1 pointed parameter list.
INTCOMP PROLOG
* Reg1=Addr(Addr(argA),Addr(argB))
L 2,0(1) Reg2=Addr(argA)
L 3,4(1) Reg3=Addr(argB)
L 4,0(2) Reg4=argA
L 5,0(3) Reg5=argA
ST 4,A Store R4 in A
ST 5,B Store R5 in B
* if (A < B)
L 0,A load R0
C 0,B compare
BL LOWER branch if lower
* if (A = B)
L 0,A load R0
C 0,B compare
BE EQUAL branch if equal
* if (A < B)
L 0,A load R0
C 0,B compare
BH GREATER branch if higher
* other case ?
B RETURN
LOWER WTO 'A<B'
B RETURN
EQUAL WTO 'A=B'
B RETURN
GREATER WTO 'A>B'
B RETURN
*
RETURN EPILOG
A DS F 31-bit signed integer
B DS F 31-bit signed integer
END
6502 Assembly
Code is called as a subroutine (i.e. JSR Compare). Specific OS/hardware routines for user input and printing are left unimplemented. It should be noted that this is strictly an unsigned comparison.
Compare PHA ;push Accumulator onto stack
JSR GetUserInput ;routine not implemented
;integers to compare now in memory locations A and B
LDA A
CMP B ;sets flags as if a subtraction (a - b) had been carried out
BCC A_less_than_B ;branch if carry clear
BEQ A_equals_B ;branch if equal
;else A greater than B
JSR DisplayAGreaterThanB;routine not implemented
JMP Done
A_less_than_B: JSR DisplayALessThanB ;routine not implemented
JMP Done
A_equals_B: JSR DisplayAEqualsB ;routine not implemented
Done: PLA ;restore Accumulator from stack
RTS ;return from subroutine
68000 Assembly
The task of getting input from the user is much more difficult in assembly since it hasn't been done for you unlike nearly all other languages. So that part will be omitted to focus on the actual comparison.
In assembly, the only difference between a signed integer and an unsigned integer is the comparator(s) used to evaluate it. Therefore we have two different versions of this task.
Unsigned Comparison
Compare:
;integers to compare are in D0 and D1
CMP.L D1,D0
BCS .less ;D1 < D0
;else, carry clear, which implies greater than or equal to.
BNE .greater ;D1 > D0
;else, d1 = d0
LEA Equal,A0
JMP PrintString ;and use its RTS to return
.greater:
LEA GreaterThan,A0
JMP PrintString ;and use its RTS to return
.less:
LEA LessThan,A0
JMP PrintString ;and use its RTS to return
LessThan:
dc.b "second integer less than first",0
even
GreaterThan:
dc.b "second integer greater than first",0
even
Equal:
dc.b "both are equal",0
even
Signed Comparison
Compare:
;integers to compare are in D0 and D1
CMP.L D1,D0
BLT .less ;D1 < D0
;else, carry clear, which implies greater than or equal to.
BNE .greater ;D1 > D0
;else, d1 = d0
LEA Equal,A0
JMP PrintString ;and use its RTS to return
.greater:
LEA GreaterThan,A0
JMP PrintString ;and use its RTS to return
.less:
LEA LessThan,A0
JMP PrintString ;and use its RTS to return
LessThan:
dc.b "second integer less than first",0
even
GreaterThan:
dc.b "second integer greater than first",0
even
Equal:
dc.b "both are equal",0
even
8051 Assembly
Input/output is specific to hardware; this code assumes the integers are in registers a and b. There is only one comparison instruction to use: 'not equal'.
compare:
push psw
cjne a, b, clt
; a == b
; implement code here
jmp compare_
clt:
jc lt
; a > b
; implement code here
jmp compare_
lt:
; a < b
; implement code here
compare_:
pop psw
ret
Testing for (a <= b) or (a >= b) can be performed by changing the jumps.
8th
The user would put the numbers on the stack and then invoke 'compare':
: compare \ n m --
2dup n:= if "They are equal" . cr then
2dup n:< if "First less than second" . cr then
n:> if "First greater than second" . cr then ;
Alternatively one could use the "n:cmp" word
AArch64 Assembly
Compare once (cmp x0, x1
) and use conditional branching (b.eq
and b.gt
).
.equ STDOUT, 1
.equ SVC_WRITE, 64
.equ SVC_EXIT, 93
.text
.global _start
_start:
stp x29, x30, [sp, -16]!
mov x0, #123
mov x1, #456
mov x29, sp
bl integer_compare // integer_compare(123, 456);
mov x0, #-123
mov x1, #-456
bl integer_compare // integer_compare(-123, -456);
mov x0, #123
mov x1, #123
bl integer_compare // integer_compare(123, 123);
ldp x29, x30, [sp], 16
mov x0, #0
b _exit // exit(0);
// void integer_compare(long long x, long long y) - compare two signed integers and print a message
integer_compare:
cmp x0, x1
mov x0, #STDOUT
b.eq 1f
b.gt 2f
// x < y
ldr x1, =msg_lt
mov x2, #17
b _write
1: // x == y
ldr x1, =msg_eq
mov x2, #16
b _write
2: // x > y
ldr x1, =msg_gt
mov x2, #20
b _write
msg_lt:
.ascii "x is less than y\n"
msg_eq:
.ascii "x is equal to y\n"
msg_gt:
.ascii "x is greater than y\n"
.align 4
//////////////// system call wrappers
// ssize_t _write(int fd, void *buf, size_t count)
_write:
stp x29, x30, [sp, -16]!
mov x8, #SVC_WRITE
mov x29, sp
svc #0
ldp x29, x30, [sp], 16
ret
// void _exit(int retval)
_exit:
mov x8, #SVC_EXIT
svc #0
ABAP
This works in ABAP version 7.40 and above. Note that empty input is evaluated to 0.
report z_integer_comparison.
parameters: a type int4, b type int4.
data(comparison_result) = cond string(
when a < b " can be replaced by a lt b
then |{ a } is less than { b }|
when a = b " can be replaced by a eq b
then |{ a } is equal to { b }|
when a > b " can be replaced by a gt b
then |{ a } is greater than { b }| ).
write comparison_result.
Action!
PROC Main()
INT a,b
Print("Input value of a:") a=InputI()
Print("Input value of b:") b=InputI()
IF a<b THEN
PrintF("%I is less than %I%E",a,b)
FI
IF a>b THEN
PrintF("%I is greater than %I%E",a,b)
FI
IF a=b THEN
PrintF("%I is equal to %I%E",a,b)
FI
RETURN
- Output:
Screenshot from Atari 8-bit computer
Input value of a:123 Input value of b:4712 123 is less than 4712
Ada
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_Io;
procedure Compare_Ints is
A, B : Integer;
begin
Get(Item => A);
Get(Item => B);
-- Test for equality
if A = B then
Put_Line("A equals B");
end if;
-- Test For Less Than
if A < B then
Put_Line("A is less than B");
end if;
-- Test For Greater Than
if A > B then
Put_Line("A is greater than B");
end if;
end Compare_Ints;
Aime
void
output(integer a, integer b, text condition)
{
o_integer(a);
o_text(condition);
o_integer(b);
o_byte('\n');
}
integer
main(void)
{
if (a < b) {
output(a, b, " is less then ");
}
if (a == b) {
output(a, b, " is equal to ");
}
if (a > b) {
output(a, b, " is greater than ");
}
return 0;
}
Run as:
aime FILE integer a 33 integer b 133
ALGOL 68
Note: the standard includes the characters "≤", "≥" and "≠". These appear in the character sets GOST 10859, ISOtech and IBM's EBCDIC e.g. code page 293, and in extended ASCII code pages 910 & 910
The above distributions of both ALGOL 68G and ELLA ALGOL 68 compilers only allow ASCII characters (ASCII has neither "≤", "≥" nor "≠" characters).
main: (
INT a, b;
read((a, space, b, new line));
IF a <= b OR a LE b # OR a ≤ b # THEN
print((a," is less or equal to ", b, new line))
FI;
IF a < b OR a LT b THEN
print((a," is less than ", b, new line))
ELIF a = b OR a EQ b THEN
print((a," is equal to ", b, new line))
ELIF a > b OR a GT b THEN
print((a," is greater than ", b, new line))
FI;
IF a /= b OR a NE b # OR a ≠ b # THEN
print((a," is not equal to ", b, new line))
FI;
IF a >= b OR a GE b # OR a ≥ b # THEN
print((a," is greater or equal to ", b, new line))
FI
)
- Output:
+3 is less or equal to +4 +3 is less than +4 +3 is not equal to +4
ALGOL W
begin
integer a, b;
write( "first number: " );
read( a );
write( "second number: " );
read( b );
if a < b then write( a, " is less than ", b );
if a = b then write( a, " is equal to ", b );
if a > b then write( a, " is greater than ", b );
end.
AppleScript
set n1 to text returned of (display dialog "Enter the first number:" default answer "") as integer
set n2 to text returned of (display dialog "Enter the second number:" default answer "") as integer
set msg to {n1}
if n1 < n2 then
set end of msg to " is less than "
else if n1 = n2 then
set end of msg to " is equal to "
else if n1 > n2 then
set end of msg to " is greater than "
end if
set end of msg to n2
return msg as string
Or...
set n1 to text returned of (display dialog "Enter the first number:" default answer "") as integer
set n2 to text returned of (display dialog "Enter the second number:" default answer "") as integer
if n1 < n2 then return "" & n1 & " is less than " & n2
if n1 = n2 then return "" & n1 & " is equal to " & n2
if n1 > n2 then return "" & n1 & " is greater than " & n2
ARM Assembly
/* ARM assembly Raspberry PI */
/* program comparNumber.s */
/* Constantes */
.equ BUFFERSIZE, 100
.equ STDIN, 0 @ Linux input console
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ READ, 3 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
/* Initialized data */
.data
szMessNum1: .asciz "Enter number 1 : \n"
szMessNum2: .asciz "Enter number 2: \n"
szMessEqual: .asciz "Number 1 and number 2 are equals.\n"
szMessSmall: .asciz "Number 1 smaller than number 2.\n"
szMessLarge: .asciz "Number 1 larger than number 2.\n"
szCarriageReturn: .asciz "\n"
/* UnInitialized data */
.bss
sBuffer: .skip BUFFERSIZE
/* code section */
.text
.global main
main: /* entry of program */
push {fp,lr} /* saves 2 registers */
ldr r0,iAdrszMessNum1 @ message address
ldr r1,iAdrsBuffer @ buffer address
mov r2,#BUFFERSIZE
bl numberEntry
mov r5,r0 @ save number 1 -> r5
ldr r0,iAdrszMessNum2 @ message address
ldr r1,iAdrsBuffer @ buffer address
mov r2,#BUFFERSIZE
bl numberEntry
cmp r5,r0 @ compar number 1 and number 2
beq equal
blt small
bgt large
@ never !!
b 100f
equal:
ldr r0,iAdrszMessEqual @ message address
b aff
small:
ldr r0,iAdrszMessSmall @ message address
b aff
large:
ldr r0,iAdrszMessLarge @ message address
b aff
aff:
bl affichageMess @ display message
100: /* standard end of the program */
mov r0, #0 @ return code
pop {fp,lr} @restaur 2 registers
mov r7, #EXIT @ request to exit program
swi 0 @ perform the system call
iAdrszMessNum1: .int szMessNum1
iAdrszMessNum2: .int szMessNum2
iAdrszMessEqual: .int szMessEqual
iAdrszMessSmall: .int szMessSmall
iAdrszMessLarge: .int szMessLarge
iAdrsBuffer: .int sBuffer
iAdrszCarriageReturn: .int szCarriageReturn
/******************************************************************/
/* Number entry with display message and conversion number */
/******************************************************************/
/* r0 contains message address */
/* r1 contains buffer address
/* r2 contains buffersize */
/* r0 return a number */
numberEntry:
push {fp,lr} @ save registres */
push {r4,r6,r7} @ save others registers
mov r4,r1 @ save buffer address -> r4
bl affichageMess
mov r0,#STDIN @ Linux input console
//ldr r1,iAdrsBuffer @ buffer address
//mov r2,#BUFFERSIZE @ buffer size
mov r7, #READ @ request to read datas
swi 0 @ call system
mov r1,r4 @ buffer address
mov r2,#0 @ end of string
strb r2,[r1,r0] @ store byte at the end of input string (r0
@
mov r0,r4 @ buffer address
bl conversionAtoD @ conversion string in number in r0
100:
pop {r4,r6,r7} /* restaur others registers */
pop {fp,lr} /* restaur des 2 registres */
bx lr /* return */
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {fp,lr} /* save registres */
push {r0,r1,r2,r7} /* save others registers */
mov r2,#0 /* counter length */
1: /* loop length calculation */
ldrb r1,[r0,r2] /* read octet start position + index */
cmp r1,#0 /* if 0 its over */
addne r2,r2,#1 /* else add 1 in the length */
bne 1b /* and loop */
/* so here r2 contains the length of the message */
mov r1,r0 /* address message in r1 */
mov r0,#STDOUT /* code to write to the standard output Linux */
mov r7, #WRITE /* code call system "write" */
swi #0 /* call systeme */
pop {r0,r1,r2,r7} /* restaur others registers */
pop {fp,lr} /* restaur des 2 registres */
bx lr /* return */
/******************************************************************/
/* Convert a string to a number stored in a registry */
/******************************************************************/
/* r0 contains the address of the area terminated by 0 or 0A */
/* r0 returns a number */
conversionAtoD:
push {fp,lr} @ save 2 registers
push {r1-r7} @ save others registers
mov r1,#0
mov r2,#10 @ factor
mov r3,#0 @ counter
mov r4,r0 @ save address string -> r4
mov r6,#0 @ positive sign by default
mov r0,#0 @ initialization to 0
1: /* early space elimination loop */
ldrb r5,[r4,r3] @ loading in r5 of the byte located at the beginning + the position
cmp r5,#0 @ end of string -> end routine
beq 100f
cmp r5,#0x0A @ end of string -> end routine
beq 100f
cmp r5,#' ' @ space ?
addeq r3,r3,#1 @ yes we loop by moving one byte
beq 1b
cmp r5,#'-' @ first character is -
moveq r6,#1 @ 1 -> r6
beq 3f @ then move on to the next position
2: /* beginning of digit processing loop */
cmp r5,#'0' @ character is not a number
blt 3f
cmp r5,#'9' @ character is not a number
bgt 3f
/* character is a number */
sub r5,#48
ldr r1,iMaxi @ check the overflow of the register
cmp r0,r1
bgt 99f @ overflow error
mul r0,r2,r0 @ multiply par factor 10
add r0,r5 @ add to r0
3:
add r3,r3,#1 @ advance to the next position
ldrb r5,[r4,r3] @ load byte
cmp r5,#0 @ end of string -> end routine
beq 4f
cmp r5,#0x0A @ end of string -> end routine
beq 4f
b 2b @ loop
4:
cmp r6,#1 @ test r6 for sign
moveq r1,#-1
muleq r0,r1,r0 @ if negatif, multiply par -1
b 100f
99: /* overflow error */
ldr r0,=szMessErrDep
bl affichageMess
mov r0,#0 @ return zero if error
100:
pop {r1-r7} @ restaur other registers
pop {fp,lr} @ restaur 2 registers
bx lr @return procedure
/* constante program */
iMaxi: .int 1073741824
szMessErrDep: .asciz "Too large: overflow 32 bits.\n"
Arturo
a: to :integer input "enter a value for a: "
b: to :integer input "enter a value for b: "
if a<b [ print [ a "is less than" b ] ]
if a>b [ print [ a "is greater than" b ] ]
if a=b [ print [ a "is equal to" b ] ]
Astro
let a = input('Enter value of a: ')
let b = input('Enter value of b: ')
if a < b:
print 'a is less than b'
elif a > b:
print 'a is greater than b'
elif a == b:
print 'a is equal to b'
AutoHotkey
Error checking is performed automatically by attaching UpDowns to each of the Edit controls. UpDown controls always yield an in-range number, even when the user has typed something non-numeric or out-of-range in the Edit control. The default range is 0 to 100.
Gui, Add, Edit
Gui, Add, UpDown, vVar1
Gui, Add, Edit
Gui, Add, UpDown, vVar2
Gui, Add, Button, Default, Submit
Gui, Show
Return
ButtonSubmit:
Gui, Submit, NoHide
If (Var1 = Var2)
MsgBox, % Var1 "=" Var2
Else If (Var1 < Var2)
MsgBox, % Var1 "<" Var2
Else If (Var1 > Var2)
MsgBox, % Var1 ">" Var2
Return
GuiClose:
ExitApp
Avail
// This code doesn't try to protect against any malformed input.
a ::= next line from standard input→integer;
b ::= next line from standard input→integer;
If a > b then [Print: "a > b";]
else if a < b then [Print: "a < b";]
else if a = b then [Print: "a = b";];
AWK
/[0-9]* [0-9]*/{
if ($1 == $2) print $1, "is equal to", $2
if ($1 < $2) print $1, "is less than", $2
if ($1 > $2) print $1, "is greater than", $2
}
In awk, a double equals symbol is required to test for equality. A single equals sign is used for assignment, and will cause a bug if it is used within a boolean expression:
# This code contains a bug
IF (n=3) PRINT "n is equal to 3" # The incorrectly used equals sign will set n to a value of 3
Axe
Lbl FUNC
If r₁<r₂
Disp "LESS THAN",i
End
If r₁=r₂
Disp "EQUAL TO",i
End
If r₁>r₂
Disp "GREATER THAN",i
End
Return
BASIC
Applesoft BASIC
10 INPUT "ENTER TWO INTEGERS: "; A%, B%
20 A$(0) = "NOT "
30 PRINT A% " IS " A$(A% < B%) "LESS THAN " B%
40 PRINT A% " IS " A$(A% = B%) "EQUAL TO " B%
50 PRINT A% " IS " A$(A% > B%) "GREATER THAN " B%
BaCon
INPUT "Enter first number " ,a
INPUT "Enter second number " ,b
IF a < b THEN PRINT a ," is less than ", b
IF a = b THEN PRINT a, " is equal to ", b
IF a > b THEN PRINT a, " is greater than ", b
CLS
INPUT "a, b"; a, b 'remember to type the comma when you give the numbers
PRINT "a is ";
IF a < b THEN PRINT "less than ";
IF a = b THEN PRINT "equal to ";
IF a > b THEN PRINT "greater than ";
PRINT "b"
BASIC256
input "Please enter one integer: ", x
input "and a second integer: ", y
if x < y then print x; " is less than "; y
if x = y then print x; " is equal to "; y
if x > y then print x; " is greater than "; y
BBC BASIC
INPUT "Enter two numbers separated by a comma: " a, b
CASE TRUE OF
WHEN a < b: PRINT ;a " is less than "; b
WHEN a = b: PRINT ;a " is equal to "; b
WHEN a > b: PRINT ;a " is greater than "; b
ENDCASE
FreeBASIC
' FB 1.05.0 Win64
Dim As Integer x, y
Input "Please enter two integers, separated by a comma : ", x , y
If x < y Then
Print x; " is less than "; y
End If
If x = y Then
Print x; " is equal to "; y
End If
If x > y Then
Print x; " is greater than "; y
End If
Print
Print "Press any key to exit"
Sleep
FutureBasic
Note: Strictly speaking, it's preferable to use "==" when comparing integers as seen in this example. While the "=" sign will work as a comparison in most cases, technically it should be used for assignment, i.e. a = 3 when a is assigned the value of 3, as contrasted with a == 3, where the value of a is being compared with 3. FB will flag a warning when "==" is used to compare two single, doubles or floats since comparing real numbers can be inaccurate.
_window = 1
begin enum 1
_integer1Fld
_integer2Fld
_compareBtn
_messageLabel
end enum
local fn BuildWindow
window _window, @"Integer Comparison", (0,0,356,85)
textfield _integer1Fld,,, (20,44,112,21)
TextFieldSetPlaceholderString( _integer1Fld, @"Integer 1" )
textfield _integer2Fld,,, (140,44,112,21)
TextFieldSetPlaceholderString( _integer2Fld, @"Integer 2" )
button _compareBtn,,, @"Compare", (253,38,90,32)
textlabel _messageLabel,, (18,20,320,16)
ControlSetAlignment( _messageLabel, NSTextAlignmentCenter )
end fn
local fn DoDialog( ev as long, tag as long )
long int1, int2
select ( ev )
case _btnClick
select ( tag )
case _compareBtn
int1 = fn ControlIntegerValue( _integer1Fld )
int2 = fn ControlIntegerValue( _integer2Fld )
if ( int1 < int2 ) then textlabel _messageLabel, @"The first integer is less than the second integer."
if ( int1 == int2 ) then textlabel _messageLabel, @"The first integer is equal to the second integer."
if ( int1 > int2 ) then textlabel _messageLabel, @"The first integer is greater than the second integer."
end select
case _controlTextDidChange
textlabel _messageLabel, @""
end select
end fn
fn BuildWindow
on dialog fn DoDialog
HandleEvents
Gambas
Public Sub Form_Open()
Dim sIn As String = InputBox("Enter 2 integers seperated by a comma")
Dim iFirst, iSecond As Integer
iFirst = Val(Split(sIn)[0])
iSecond = Val(Split(sIn)[1])
If iFirst < iSecond Then Print iFirst & " is smaller than " & iSecond & gb.NewLine
If iFirst > iSecond Then Print iFirst & " is greater than " & iSecond & gb.NewLine
If iFirst = iSecond Then Print iFirst & " is equal to " & iSecond
End
Output:
21 is greater than 18
IS-BASIC
100 INPUT PROMPT "Enter A: ":A
110 INPUT PROMPT "Enter B: ":B
120 IF A<B THEN
130 PRINT A;"is lesss than ";B
140 ELSE IF A=B THEN
150 PRINT A;"is equal to ";B
160 ELSE
170 PRINT A;"is greater than ";B
180 END IF
or
100 INPUT PROMPT "Enter A: ":A
110 INPUT PROMPT "Enter B: ":B
120 SELECT CASE A
130 CASE IS<B
140 PRINT A;"is lesss than ";B
150 CASE IS=B
160 PRINT A;"is equal to ";B
170 CASE ELSE
180 PRINT A;"is greater than ";B
190 END SELECT
Liberty BASIC
Verbose version:
input "Enter an integer for a. ";a
input "Enter an integer for b. ";b
'a=int(a):b=int(b) ???
print "Conditional evaluation."
if a<b then print "a<b " ; a ; " < " ; b
if a=b then print "a=b " ; a ; " = " ; b
if a>b then print "a>b " ; a ; " > " ; b
print "Select case evaluation."
select case
case (a<b)
print "a<b " ; a ; " < " ; b
case (a=b)
print "a=b " ; a ; " = " ; b
case (a>b)
print "a>b " ; a ; " > " ; b
end select
Concise:
input "Enter an integer for a. ";a
input "Enter an integer for b. ";b
for i = 1 to 3
op$=word$("< = >", i)
if eval("a"+op$+"b") then print "a"+op$+"b " ; a;" ";op$;" ";b
next
OxygenBasic
uses console
print "Integer comparison. (press ctrl-c to exit) " cr cr
int n1,n2
do
print "Enter 1st integer " : n1=input
print "Enter 2nd integer " : n2=input
if n1=n2
print "number1 = number2" cr cr
elseif n1>n2
print "number1 > number2" cr cr
elseif n1<n2
print "number1 < number2" cr cr
endif
loop
PureBasic
If OpenConsole()
Print("Enter an integer: ")
x.i = Val(Input())
Print("Enter another integer: ")
y.i = Val(Input())
If x < y
Print( "The first integer is less than the second integer.")
ElseIf x = y
Print("The first integer is equal to the second integer.")
ElseIf x > y
Print("The first integer is greater than the second integer.")
EndIf
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
Input()
CloseConsole()
EndIf
QBasic
INPUT "Please enter two integers, separated by a comma: ", x, y
IF x < y THEN PRINT x; " is less than "; y
IF x = y THEN PRINT x; " is equal to "; y
IF x > y THEN PRINT x; " is greater than "; y
Run BASIC
input "1st number:"; n1
input "2nd number:"; n2
if n1 < n2 then print "1st number ";n1;" is less than 2nd number";n2
if n1 > n2 then print "1st number ";n1;" is greater than 2nd number";n2
if n1 = n2 then print "1st number ";n1;" is equal to 2nd number";n2
SmallBASIC
PRINT "Please enter two integers, separated by a comma: ";
INPUT x, y
IF x < y THEN PRINT x; " is less than "; y
IF x == y THEN PRINT x; " is equal to "; y
IF x > y THEN PRINT x; " is greater than "; y
TI-83 BASIC
Prompt A,B
If A<B: Disp "A SMALLER B"
If A>B: Disp "A GREATER B"
If A=B: Disp "A EQUAL B"
TI-89 BASIC
Local a, b, result
Prompt a, b
If a < b Then
"<" → result
ElseIf a = b Then
"=" → result
ElseIf a > b Then
">" → result
Else
"???" → result
EndIf
Disp string(a) & " " & result & " " & string(b)
Tiny BASIC
Some implementations of Tiny BASIC use ,
instead of ;
for concatenation of print items.
10 REM Integer comparison
20 PRINT "Enter a number"
30 INPUT A
40 PRINT "Enter another number"
50 INPUT B
60 IF A < B THEN PRINT A;" is less than ";B
70 IF A > B THEN PRINT A;" is greater than ";B
80 IF A = B THEN PRINT A;" is equal to ";B
90 END
True BASIC
PRINT "Please enter two integers, separated by a comma: ";
INPUT x, y
IF x < y THEN PRINT x; " is less than "; y
IF x = y THEN PRINT x; " is equal to "; y
IF x > y THEN PRINT x; " is greater than "; y
END
VBA
Public Sub integer_comparison()
first_integer = CInt(InputBox("Give me an integer."))
second_integer = CInt(InputBox("Give me another integer."))
Debug.Print IIf(first_integer < second_integer, "first integer is smaller than second integer", "first integer is not smaller than second integer")
Debug.Print IIf(first_integer = second_integer, "first integer is equal to second integer", "first integer is not equal to second integer")
Debug.Print IIf(first_integer > second_integer, "first integer is bigger than second integer", "first integer is not bigger than second integer")
End Sub
VBScript
option explicit
function eef( b, r1, r2 )
if b then
eef = r1
else
eef = r2
end if
end function
dim a, b
wscript.stdout.write "First integer: "
a = cint(wscript.stdin.readline) 'force to integer
wscript.stdout.write "Second integer: "
b = cint(wscript.stdin.readline) 'force to integer
wscript.stdout.write "First integer is "
if a < b then wscript.stdout.write "less than "
if a = b then wscript.stdout.write "equal to "
if a > b then wscript.stdout.write "greater than "
wscript.echo "Second integer."
wscript.stdout.write "First integer is " & _
eef( a < b, "less than ", _
eef( a = b, "equal to ", _
eef( a > b, "greater than ", vbnullstring ) ) ) & "Second integer."
Visual Basic .NET
Platform: .NET
Sub Main()
Dim a = CInt(Console.ReadLine)
Dim b = CInt(Console.ReadLine)
'Using if statements
If a < b Then Console.WriteLine("a is less than b")
If a = b Then Console.WriteLine("a equals b")
If a > b Then Console.WriteLine("a is greater than b")
'Using Case
Select Case a
Case Is < b
Console.WriteLine("a is less than b")
Case b
Console.WriteLine("a equals b")
Case Is > b
Console.WriteLine("a is greater than b")
End Select
End Sub
Yabasic
input "Please enter two integers, separated by a comma: " x, y
if x < y then print x, " is less than ", y : fi
if x = y then print x, " is equal to ", y : fi
if x > y then print x, " is greater than ", y : fi
ZX Spectrum Basic
10 INPUT "Enter two integers: ";a;" ";b
20 PRINT a;" is ";("less than " AND (a<b));("equal to " AND (a=b));("greather than " AND (a>b));b
Batch File
@echo off
setlocal EnableDelayedExpansion
set /p a="A: "
set /p b="B: "
if %a% LSS %b% (
echo %a% is less than %b%
) else ( if %a% GTR %b% (
echo %a% is greater than %b%
) else ( if %a% EQU %b% (
echo %a% is equal to %b%
)))
- Output:
C:\Test>IntegerComparison.bat A: 5 B: 3 5 is greater than 3
bc
(POSIX bc doesn't have I/O functions/statements (i.e. read
and print
) but the rest of the code would work.)
a = read()
b = read()
if (a < b) print "a is smaller than b\n"
if (a > b) print "a is greater than b\n"
if (a == b) print "a is equal to b\n"
quit
BCPL
get "libhdr"
let start() be
$( let a = ? and b = ?
writes("A? ") ; a := readn()
writes("B? ") ; b := readn()
writes(
a < b -> "A is less than B*N",
a = b -> "A is equal to B*N",
a > b -> "A is greater than B*N",
"Huh?!"
)
$)
Befunge
Befunge only has the greater-than operator (backtick `). The branch commands (underline _ and pipe |) test for zero.
v v ">" $<
>&&"=A",,\:."=B ",,,\: .55+,-:0`|
v "<" _v#<
@,+55,," B",,,"A " < "=" <
BQN
The function Comp
compares two integers and returns the appropriate string result.
Comp ← ⊑·/⟜"Greater than"‿"Equal To"‿"Lesser Than"(>∾=∾<)
⊑(/⟜⟨ "Greater than" "Equal To" "Lesser Than" ⟩>∾=∾<)
4 Comp 5
"Lesser Than"
5 Comp 5
"Equal To"
6 Comp 5
"Greater than"
Bracmat
get$:?A
& get$:?B
& (!A:!B&out$"A equals B"|)
& (!A:<!B&out$"A is less than B"|)
& (!A:>!B&out$"A is greater than B"|);
Brat
first = ask("First integer: ").to_i
second = ask("Second integer: ").to_i
when { first > second } { p "#{first} is greater than #{second}" }
{ first < second } { p "#{first} is less than #{second}" }
{ first == second } { p "#{first} is equal to #{second}" }
Burlesque
blsq ) "5 6"ps^pcm+.{"The first one is less than the second one""They are both equal""The second one is less than the first one"}\/!!sh
The first one is less than the second one
blsq ) "6 6"ps^pcm+.{"The first one is less than the second one""They are both equal""The second one is less than the first one"}\/!!sh
They are both equal
blsq ) "6 5"ps^pcm+.{"The first one is less than the second one""They are both equal""The second one is less than the first one"}\/!!sh
The second one is less than the first one
C
#include <stdio.h>
int main()
{
int a, b;
scanf("%d %d", &a, &b);
if (a < b)
printf("%d is less than %d\n", a, b);
if (a == b)
printf("%d is equal to %d\n", a, b);
if (a > b)
printf("%d is greater than %d\n", a, b);
return 0;
}
C#
using System;
class Program
{
static void Main()
{
int a = int.Parse(Console.ReadLine());
int b = int.Parse(Console.ReadLine());
if (a < b)
Console.WriteLine("{0} is less than {1}", a, b);
if (a == b)
Console.WriteLine("{0} equals {1}", a, b);
if (a > b)
Console.WriteLine("{0} is greater than {1}", a, b);
}
}
C++
#include <iostream>
int main()
{
int a, b;
if (!(std::cin >> a >> b)) {
std::cerr << "could not read the numbers\n";
return 1;
}
// test for less-than
if (a < b)
std::cout << a << " is less than " << b << "\n";
// test for equality
if (a == b)
std::cout << a << " is equal to " << b << "\n";
// test for greater-than
if (a > b)
std::cout << a << " is greater than " << b << "\n";
}
CFEngine
bundle agent __main__
{
vars:
# Change the values to test:
"first_integer" int => "10";
"second_integer" int => "9";
reports:
"The first integer ($(first_integer)) is less than the second integer ($(second_integer))."
if => islessthan( "$(first_integer)", "$(second_integer)" );
"The first integer ($(first_integer)) is equal to the second integer ($(second_integer))."
if => eval( "$(first_integer)==$(second_integer)", "class", "infix" );
"The first integer ($(first_integer)) is greater than the second integer ($(second_integer))."
if => isgreaterthan( "$(first_integer)", "$(second_integer)" );
}
ChucK
fun void intComparison (int one, int two)
{
if(one < two) <<< one, " is less than ", two >>>;
if(one == two) <<< one, " is equal than ", two >>>;
if(one > two) <<< one, " is greater than ", two >>>;
}
// uncomment next line and change values to test
// intComparison (2,4);
Clean
import StdEnv
compare a b
| a < b = "A is less than B"
| a > b = "A is more than B"
| a == b = "A equals B"
Start world
# (console, world) = stdio world
(_, a, console) = freadi console
(_, b, console) = freadi console
= compare a b
Clipper
Function Compare(a, b)
IF a < b
? "A is less than B"
ELSEIF a > b
? "A is more than B"
ELSE
? "A equals B"
ENDIF
Return Nil
Clojure
Creates an infinite sequence of calls to "read an object from the user", and assigns the first two elements to a and b, without evaluating the rest. It evaluates the when/println body three times, each time with op and string bound to their corresponding entries in the list of three operator/string pairs. Note that this does no validation on input: if the user inputs a string then an exception will be thrown.
(let [[a b] (repeatedly read)]
(doseq [[op string] [[< "less than"]
[> "greater than"]
[= "equal to"]]]
(when (op a b)
(println (str a " is " string " " b)))))
CMake
# Define A and B as integers. For example:
# cmake -DA=3 -DB=5 -P compare.cmake
# The comparisons can take variable names, or they can take numbers.
# So these act all the same:
# A LESS B
# ${A} LESS ${B}
# A LESS ${B}
# ${A} LESS B
if(A LESS B)
message(STATUS "${A} is less than ${B}")
endif()
if(A EQUAL B)
message(STATUS "${A} is equal to ${B}")
endif()
if(A GREATER B)
message(STATUS "${A} is greater than ${B}")
endif()
COBOL
IDENTIFICATION DIVISION.
PROGRAM-ID. Int-Compare.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 A PIC 9(10).
01 B PIC 9(10).
PROCEDURE DIVISION.
DISPLAY "First number: " WITH NO ADVANCING
ACCEPT A
DISPLAY "Second number: " WITH NO ADVANCING
ACCEPT B
* *> Note: Longer verbal forms may be used instead of symbols
* *> e.g. 'IS GREATER THAN' instead '<'
IF A < B
DISPLAY A " is less than " B
ELSE IF A = B
DISPLAY A " is equal to " B
ELSE IF A > B
DISPLAY A " is larger than " B
END-IF.
GOBACK
.
ColdFusion
- Less than: LT
- Less than or equal to: LTE
- Greater than: GT
- Greater than or equal to: GTE
- Equal to: EQ
- Not equal to: NEQ
In CFML
<cffunction name="CompareInteger">
<cfargument name="Integer1" type="numeric">
<cfargument name="Integer2" type="numeric">
<cfset VARIABLES.Result = "" >
<cfif ARGUMENTS.Integer1 LT ARGUMENTS.Integer2 >
<cfset VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is less than " & ARGUMENTS.Integer2 & ")" >
</cfif>
<cfif ARGUMENTS.Integer1 LTE ARGUMENTS.Integer2 >
<cfset VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is less than or equal to " & ARGUMENTS.Integer2 & ")" >
</cfif>
<cfif ARGUMENTS.Integer1 GT ARGUMENTS.Integer2 >
<cfset VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is greater than " & ARGUMENTS.Integer2 & ")" >
</cfif>
<cfif ARGUMENTS.Integer1 GTE ARGUMENTS.Integer2 >
<cfset VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is greater than or equal to " & ARGUMENTS.Integer2 & ")" >
</cfif>
<cfif ARGUMENTS.Integer1 EQ ARGUMENTS.Integer2 >
<cfset VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is equal to " & ARGUMENTS.Integer2 & ")" >
</cfif>
<cfif ARGUMENTS.Integer1 NEQ ARGUMENTS.Integer2 >
<cfset VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is not equal to " & ARGUMENTS.Integer2 & ")" >
</cfif>
<cfreturn VARIABLES.Result >
</cffunction>
In CFScript
<cfscript>
function CompareInteger( Integer1, Integer2 ) {
VARIABLES.Result = "";
if ( ARGUMENTS.Integer1 LT ARGUMENTS.Integer2 ) {
VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is less than " & ARGUMENTS.Integer2 & ")";
}
if ( ARGUMENTS.Integer1 LTE ARGUMENTS.Integer2 ) {
VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is less than or equal to " & ARGUMENTS.Integer2 & ")";
}
if ( ARGUMENTS.Integer1 GT ARGUMENTS.Integer2 ) {
VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is greater than " & ARGUMENTS.Integer2 & ")";
}
if ( ARGUMENTS.Integer1 GTE ARGUMENTS.Integer2 ) {
VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is greater than or equal to " & ARGUMENTS.Integer2 & ")";
}
if ( ARGUMENTS.Integer1 EQ ARGUMENTS.Integer2 ) {
VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is equal to " & ARGUMENTS.Integer2 & ")";
}
if ( ARGUMENTS.Integer1 NEQ ARGUMENTS.Integer2 ) {
VARIABLES.Result = VARIABLES.Result & "(" & ARGUMENTS.Integer1 & " is not equal to " & ARGUMENTS.Integer2 & ")";
}
return VARIABLES.Result;
}
</cfscript>
Common Lisp
You can type this directly into a REPL:
(let ((a (read *standard-input*))
(b (read *standard-input*)))
(cond
((not (numberp a)) (format t "~A is not a number." a))
((not (numberp b)) (format t "~A is not a number." b))
((< a b) (format t "~A is less than ~A." a b))
((> a b) (format t "~A is greater than ~A." a b))
((= a b) (format t "~A is equal to ~A." a b))
(t (format t "Cannot determine relevance between ~A and ~B!" a b)))))
After hitting enter, the REPL is expecting the two numbers right away. You can enter the two numbers, and the result will print immediately. Alternatively, you can wrap this code in a function definition:
(defun compare-integers ()
(let ((a (read *standard-input*))
(b (read *standard-input*)))
(cond
((not (numberp a)) (format t "~A is not a number." a))
((not (numberp b)) (format t "~A is not a number." b))
((< a b) (format t "~A is less than ~A." a b))
((> a b) (format t "~A is greater than ~A." a b))
((= a b) (format t "~A is equal to ~A." a b))
(t (format t "Cannot determine relevance between ~A and ~B!" a b)))))
Then, execute the function for better control:
(compare-integers)
Computer/zero Assembly
The only conditional instruction we have is BRZ (branch on accumulator zero). We can therefore test for equality very quickly. To test for "greater than" or "less than", however, requires a loop.
If you run this program, it will halt awaiting user input. Toggle in the value of , then click Enter, then toggle in , then Enter, and then Run. and must both be unsigned eight-bit integers. The computer will halt with the accumulator storing 1 if >, 0 if =, or -1 if <; and it will be ready for a fresh pair of integers to be entered.
start: STP ; get input
x: NOP
y: NOP
LDA x
SUB y
BRZ start ; x=y, A=0
loop: LDA x
SUB one
BRZ x<y
STA x
LDA y
SUB one
BRZ x>y
STA y
JMP loop
x>y: LDA one ; A := 1
JMP start
x<y: SUB one ; A := 0-1
JMP start
one: 1
D
void main() {
import std.stdio, std.conv, std.string;
int a = 10, b = 20;
try {
a = readln.strip.to!int;
b = readln.strip.to!int;
} catch (StdioException) {}
if (a < b)
writeln(a, " is less than ", b);
if (a == b)
writeln(a, " is equal to ", b);
if (a > b)
writeln(a, " is greater than ", b);
}
- Output:
10 is less than 20
Dc
[Use _ (underscore) as negative sign for numbers.]P []pP
[Enter two numbers to compare: ]P
? sbsa
[[greater than]]sp lb la >p
[ [less than]]sp lb la <p
[ [equal to]]sp lb la =p
la n [ is ]P P [ ]P lbn []pP
- Output:
44 is greater than 3
DCL
$ inquire a "Please provide an integer"
$ inquire b "Please provide another"
$ if a .lt. b then $ write sys$output "the first integer is less"
$ if a .eq. b then $ write sys$output "the integers have the same value"
$ if a .gt. b then $ write sys$output "the first integer is greater"
- Output:
$ @integer_comparison Please provide an integer: 0 Please provide another: -3 the first integer is greater $ @integer_comparison Please provide an integer: -2000 Please provide another: 12355 the first integer is less $ @integer_comparison Please provide an integer: 314 Please provide another: 314 the integers have the same value
Delphi
- Slightly different than the Pascal example
program IntegerCompare;
{$APPTYPE CONSOLE}
var
a, b: Integer;
begin
Readln(a, b);
if a < b then Writeln(a, ' is less than ', b);
if a = b then Writeln(a, ' is equal to ', b);
if a > b then Writeln(a, ' is greater than ', b);
end.
Draco
proc nonrec main() void:
int a, b;
write("Please enter two integers: ");
read(a, b);
if a<b then writeln(a, " < ", b)
elif a=b then writeln(a, " = ", b)
elif a>b then writeln(a, " > ", b)
fi
corp
Dyalect
func compare(a, b) {
if a < b {
"A is less than B"
} else if a > b {
"A is more than B"
} else {
"A equals B"
}
}
E
def compare(a :int, b :int) {
println(if (a < b) { `$a < $b` } \
else if (a <=> b) { `$a = $b` } \
else if (a > b) { `$a > $b` } \
else { `You're calling that an integer?` })
}
EasyLang
a = number input
b = number input
if a < b
print "less"
.
if a = b
print "equal"
.
if a > b
print "greater"
.
ECL
CompareThem(INTEGER A,INTEGER B) := FUNCTION
Result := A <=> B;
STRING ResultText := CASE (Result,1 => 'is greater than', 0 => 'is equal to','is less than');
RETURN A + ' ' + TRIM(ResultText) + ' ' + B;
END;
CompareThem(1,2); //Shows "1 is less than 2"
CompareThem(2,2); //Shows "2 is equal to 2"
CompareThem(2,1); //Shows "2 is greater than 1"
EDSAC order code
The EDSAC offers two conditional branching orders, E (branch if the accumulator >= 0) and G (branch if the accumulator < 0). Testing for equality thus requires two operations.
[ Integer comparison
==================
A program for the EDSAC
Illustrates the use of the E
(branch on accumulator sign
bit clear) and G (branch on
accumulator sign bit set)
orders
The integers to be tested, x
and y, should be stored in
addresses 13@ and 14@
Output: the program causes the
machine to print
'+' if x > y,
'=' if x = y,
'-' if x < y.
Works with Initial Orders 2 ]
T56K [ load point ]
GK [ base address ]
O15@ [ figure shift ]
A13@ [ a = x ]
S14@ [ a -= y ]
G10@ [ if a<0 go to 10 ]
S12@ [ a -= 1 ]
E8@ [ if a>=0 go to 8 ]
O17@ [ write '=' ]
ZF [ halt ]
[ 8 ] O16@ [ write '+' ]
ZF [ halt ]
[ 10 ] O18@ [ write '-' ]
ZF [ halt ]
[ 12 ] P0D [ const: 1 ]
[ 13 ] P16D [ x = 37 ]
[ 14 ] P14F [ y = 28 ]
[ 15 ] #F [ figure shift ]
[ 16 ] ZF [ + character ]
[ 17 ] VF [ = character ]
[ 18 ] AF [ - character ]
EZPF [ begin execution ]
Efene
since if does pattern matching the else is required to avoid the application from crashing
compare = fn (A, B) {
if A == B {
io.format("~p equals ~p~n", [A, B])
}
else {
ok
}
if A < B {
io.format("~p is less than ~p~n", [A, B])
}
else {
ok
}
if A > B {
io.format("~p is greater than ~p~n", [A, B])
}
else {
ok
}
}
@public
run = fn () {
compare(5, 5)
compare(6, 5)
compare(4, 5)
}
Eiffel
class
APPLICATION
inherit
ARGUMENTS
create
make
feature {NONE} -- Initialization
make
local
i, j: INTEGER_32
do
io.read_integer_32
i := io.last_integer_32
io.read_integer_32
j := io.last_integer_32
if i < j then
print("first is less than second%N")
end
if i = j then
print("first is equal to the second%N")
end
if i > j then
print("first is greater than second%N")
end
end
end
Elena
ELENA 4.x:
import extensions;
public program()
{
var a := console.readLine().toInt();
var b := console.readLine().toInt();
if (a < b)
{ console.printLine(a," is less than ",b) };
if (a == b)
{ console.printLine(a," equals ",b) };
if (a > b)
{ console.printLine(a," is greater than ",b) }
}
Elixir
{a,_} = IO.gets("Enter your first integer: ") |> Integer.parse
{b,_} = IO.gets("Enter your second integer: ") |> Integer.parse
cond do
a < b ->
IO.puts "#{a} is less than #{b}"
a > b ->
IO.puts "#{a} is greater than #{b}"
a == b ->
IO.puts "#{a} is equal to #{b}"
end
Emacs Lisp
(defun integer-comparison (a b)
"Compare A to B and print the outcome in the message buffer."
(interactive "nFirst integer ⇒\nnSecond integer ⇒")
(cond
((< a b) (message "%d is less than %d." a b))
((> a b) (message "%d is greater than %d." a b))
((= a b) (message "%d is equal to %d." a b))))
Invoke from within Emacs Lisp (or e.g., with M-:
) as (integer-comparison 12 42)
Or, use M-x integer-comparison RET
and you'll be prompted for the two numbers.
EMal
fun main = int by List args
int a, b
if args.length > 1
a = int!args[0]
b = int!args[1]
else
a = ask(int, "Enter the first integer ")
b = ask(int, "Enter the second integer ")
end
writeLine("=== a <> b is " + (a <> b) + " ===")
if a < b do writeLine(a + " < " + b) end
if a == b do writeLine(a + " == " + b) end
if a > b do writeLine(a + " > " + b) end
return 0
end
exit main(Runtime.args)
- Output:
emal.exe Org\RosettaCode\IntegerComparison.emal Enter the first integer 42 Enter the second integer 64 === a <> b is -1 === 42 < 64
Erlang
main() ->
{ok, [N]} = io:fread("First integer: ", "~d"),
{ok, [M]} = io:fread("First integer: ", "~d"),
if
N < M ->
io:format("~b is less than ~b~n",[N,M]);
N > M ->
io:format("~b is greater than ~b~n",[N,M]);
N == M ->
io:format("~b is equal to ~b~n",[N,M])
end.
if
N =< M ->
io:format("~b is less than or equal to ~b~n",[N,M]);
N >= M ->
io:format("~b is greater than or equal to ~b~n",[N,M])
end.
Euphoria
include get.e
integer a,b
a = floor(prompt_number("a = ",{}))
b = floor(prompt_number("b = ",{}))
puts(1,"a is ")
if a < b then
puts(1,"less then")
elsif a = b then
puts(1,"equal to")
elsif a > b then
puts(1,"grater then")
end if
puts(1," b")
Excel
Let's say you type in the values in cells A1 and B1, in C1, type in the following in a MS Excel 2010 sheet:
=IF($A1>$B1;concatenate($A1;" is greater than ";$B1);IF($A1<$B1;concatenate($A1;" is smaller than ";$B1);concatenate($A1;" is equal to ";$B1)))
In a Google Docs spreadsheet, that becomes :
=IF($A1>$B1,concatenate($A1," is greater than ",$B1),IF($A1<$B1,concatenate($A1," is smaller than ",$B1),concatenate($A1," is equal to ",$B1)))
F#
let compare_ints a b =
let r =
match a with
| x when x < b -> -1, printfn "%d is less than %d" x b
| x when x = b -> 0, printfn "%d is equal to %d" x b
| x when x > b -> 1, printfn "%d is greater than %d" x b
| x -> 0, printf "default condition (not reached)"
fst r
Factor
: example ( -- )
readln readln [ string>number ] bi@
[ > [ "A > B" print ] when ]
[ < [ "A < B" print ] when ]
[ = [ "A = B" print ] when ] 2tri ;
FALSE
Only equals and greater than are available.
^^ \$@$@$@$@\
>[\$," is greater than "\$,]?
\>[\$," is less than "\$,]?
=["characters are equal"]?
Fantom
Uses Env.cur to access stdin and stdout.
class Main
{
public static Void main ()
{
try
{
Env.cur.out.print ("Enter number 1: ").flush
num1 := Env.cur.in.readLine.toInt
Env.cur.out.print ("Enter number 2: ").flush
num2 := Env.cur.in.readLine.toInt
if (num1 < num2)
echo ("$num1 is smaller than $num2")
else if (num1 == num2)
echo ("$num1 is equal to $num2")
else if (num1 > num2)
echo ("$num1 is greater than $num2")
}
catch (Err e)
echo ("You must enter two integers")
}
}
Fermat
Func Compare =
?a;
?b;
if a=b then !'Equal' fi;
if a<b then !'Less than' fi;
if a>b then !'Greater than' fi;
.;
Fish
This example assumes you pre-populate the stack with the two integers.
l2=?vv ~< v o<
v <>l?^"Please pre-populate the stack with the two integers."ar>l?^;
\$:@@:@)?v v ;oanv!!!?<
>$n" is greater than "{r>ol1=^
/ <
\$:@@:@=?v v ;oanv!!!?<
>$n" is equal to "{r>ol1=^
/ <
\$:@@:@(?v v ;oanv!!!?<
>$n" is smaller than "{r>ol1=^
> v
/oo". "nooooo" and "n$< v o<
>"They're not equal, not greater than and not smaller than eachother... strange."ar>l?^;
The last three lines aren't really needed, because it will never become true :P but I included them to show a way to do some error checking.
Forth
To keep the example simple, the word takes the two numbers from the stack.
: compare-integers ( a b -- )
2dup < if ." a is less than b" then
2dup > if ." a is greater than b" then
= if ." a is equal to b" then ;
Fortran
In ALL Fortran versions (including original 1950's era) you could use an "arithmetic IF" statement to compare using subtraction:
program arithif
integer a, b
c fortran 77 I/O statements, for simplicity
read(*,*) a, b
if ( a - b ) 10, 20, 30
10 write(*,*) a, ' is less than ', b
goto 40
20 write(*,*) a, ' is equal to ', b
goto 40
30 write(*,*) a, ' is greater than ', b
40 continue
end
In ANSI FORTRAN 66 or later you could use relational operators (.lt., .gt., .eq., etc.) and unstructured IF statements:
program compare
integer a, b
c fortran 77 I/O statements, for simplicity
read(*,*) a, b
if (a .lt. b) write(*, *) a, ' is less than ', b
if (a .eq. b) write(*, *) a, ' is equal to ', b
if (a .gt. b) write(*, *) a, ' is greater than ', b
end
In ANSI FORTRAN 77 or later you can use relational operators and structured IF statements:
program compare
integer a, b
read(*,*) a, b
if (a .lt. b) then
write(*, *) a, ' is less than ', b
else if (a .eq. b) then
write(*, *) a, ' is equal to ', b
else if (a .gt. b) then
write(*, *) a, ' is greater than ', b
end if
end
In ISO Fortran 90 or later you can use symbolic relational operators (<, >, ==, etc.)
program compare
integer :: a, b
read(*,*) a, b
if (a < b) then
write(*, *) a, ' is less than ', b
else if (a == b) then
write(*, *) a, ' is equal to ', b
else if (a > b) then
write(*, *) a, ' is greater than ', b
end if
end program compare
friendly interactive shell
read a
read b
if test $a -gt $b
echo Greater
else if test $a -lt $b
echo Less
else if test $a -eq $b
echo Equal
end
Frink
All integers in Frink can be arbitrarily large.
[a,b] = eval[input["Enter numbers",["a","b"]]]
if a<b
println["$a < $b"]
if a==b
println["$a == $b"]
if a>b
println["$a > $b"]
FunL
import console.readInt
a = readInt()
b = readInt()
val (_, c) = [((<), 'less than'), ((==), 'equal to'), ((>), 'greater than')].find( (compare, _) -> compare(a, b) ).get()
println( "$a is $c $b." )
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.
Solution
Fōrmulæ has an intrinsic expression for three-way comparison that works for integers and other types (decimal and rational numbers, strings, time expressions, etc). It returns expressions that flag one of the three possible results.
However, a simple function can be written for the requirement:
Go
package main
import (
"fmt"
"log"
)
func main() {
var n1, n2 int
fmt.Print("enter number: ")
if _, err := fmt.Scan(&n1); err != nil {
log.Fatal(err)
}
fmt.Print("enter number: ")
if _, err := fmt.Scan(&n2); err != nil {
log.Fatal(err)
}
switch {
case n1 < n2:
fmt.Println(n1, "less than", n2)
case n1 == n2:
fmt.Println(n1, "equal to", n2)
case n1 > n2:
fmt.Println(n1, "greater than", n2)
}
}
Groovy
Relational Operators
def comparison = { a, b ->
println "a ? b = ${a} ? ${b} = a ${a < b ? '<' : a > b ? '>' : a == b ? '==' : '?'} b"
}
Program:
comparison(2000,3)
comparison(2000,300000)
comparison(2000,2000)
- Output:
a ? b = 2000 ? 3 = a > b a ? b = 2000 ? 300000 = a < b a ? b = 2000 ? 2000 = a == b
"Spaceship" (compareTo) Operator
Using spaceship operator and a lookup table:
final rels = [ (-1) : '<', 0 : '==', 1 : '>' ].asImmutable()
def comparisonSpaceship = { a, b ->
println "a ? b = ${a} ? ${b} = a ${rels[a <=> b]} b"
}
Program:
comparison(2000,3)
comparison(2000,300000)
comparison(2000,2000)
- Output:
a ? b = 2000 ? 3 = a > b a ? b = 2000 ? 300000 = a < b a ? b = 2000 ? 2000 = a == b
Harbour
PROCEDURE Compare( a, b )
IF a < b
? "A is less than B"
ELSEIF a > b
? "A is more than B"
ELSE
? "A equals B"
ENDIF
RETURN
Haskell
myCompare :: Integer -> Integer -> String
myCompare a b
| a < b = "A is less than B"
| a > b = "A is greater than B"
| a == b = "A equals B"
main = do
a <- readLn
b <- readLn
putStrLn $ myCompare a b
However, the more idiomatic and less error-prone way to do it in Haskell would be to use a compare function that returns type Ordering, which is either LT, GT, or EQ:
myCompare a b = case compare a b of
LT -> "A is less than B"
GT -> "A is greater than B"
EQ -> "A equals B"
hexiscript
let a scan int
let b scan int
if a < b
println a + " is less than " + b
endif
if a > b
println a + " is greater than " + b
endif
if a = b
println a + " is equal to " + b
endif
HicEst
DLG(NameEdit=a, NameEdit=b, Button='OK')
IF (a < b) THEN
WRITE(Messagebox) a, ' is less than ', b
ELSEIF(a == b) THEN
WRITE(Messagebox) a, ' is equal to ', b
ELSEIF(a > b) THEN
WRITE(Messagebox) a, ' is greater than ', b
ENDIF
HolyC
I64 *a, *b;
a = Str2I64(GetStr("Enter your first number: "));
b = Str2I64(GetStr("Enter your second number: "));
if (a < b)
Print("%d is less than %d\n", a, b);
if (a == b)
Print("%d is equal to %d\n", a, b);
if (a > b)
Print("%d is greater than %d\n", a, b);
Hy
(def a (int (input "Enter value of a: ")))
(def b (int (input "Enter value of b: ")))
(print (cond [(< a b) "a is less than b"]
[(> a b) "a is greater than b"]
[(= a b) "a is equal to b"]))
i
software {
a = number(read(' '))
b = number(read())
if a < b
print(a, " is less than ", b)
end
if a = b
print(a, " is equal to ", b)
end
if a > b
print(a, " is greater than ", b)
end
}
Icon and Unicon
- Output:
#int_compare.exe Enter the first integer a := 7 Enter the second integer b := 7 Then 7 = 7
J
Comparison is accomplished by the verb compare
, which provides logical-numeric output.
Text elaborating the output of compare
is provided by cti
:
compare=: < , = , >
cti=: dyad define
select =. ;@#
English =. ' is less than ';' is equal to ';' is greater than '
x (":@[, (compare select English"_), ":@]) y
)
Examples of use:
4 compare 4
0 1 0
4 cti 3
4 is greater than 3
Java
import java.io.*;
public class compInt {
public static void main(String[] args) {
try {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int nbr1 = Integer.parseInt(in.readLine());
int nbr2 = Integer.parseInt(in.readLine());
if(nbr1<nbr2)
System.out.println(nbr1 + " is less than " + nbr2);
if(nbr1>nbr2)
System.out.println(nbr1 + " is greater than " + nbr2);
if(nbr1==nbr2)
System.out.println(nbr1 + " is equal to " + nbr2);
} catch(IOException e) { }
}
}
JavaScript
// Using type coercion
function compare(a, b) {
if (a==b) print(a + " equals " + b);
if (a < b) print(a + " is less than " + b);
if (a > b) print(a + " is greater than " + b);
}
// Without using type coercion and using standards
// Written for browsers
// assumption of a and b are both integers if typeof test passes
function compare (a, b) {
if (typeof a === typeof b) {
if (a === b) {
document.writeln(a + " equals " + b);
}
if (a < b) {
document.writeln(a + " is less than " + b);
}
if (a > b) {
document.writeln(a + " is greater than " + b);
}
} else {
// "1" and 1 are an example of this as the first is type string and the second is type number
print(a + "{" + (typeof a) + "} and " + b + "{" + (typeof b) + "} are not of the same type and cannot be compared.");
}
}
Joy
#!/usr/local/bin/joy.exe
DEFINE
prompt == "Please enter a number and <Enter>: " putchars;
newline == '\n putch;
putln == put newline.
stdin # F
prompt fgets # S F
10 strtol # A F
swap # F A
dupd # F A A
prompt fgets # S F A A
10 strtol # B F A A
popd # B A A
dup # B B A A
rollup # B A B A
[<] [swap put "is less than " putchars putln] [] ifte
[=] [swap put "is equal to " putchars putln] [] ifte
[>] [swap put "is greater than " putchars putln] [] ifte
# B A
quit.
jq
# compare/0 compares the first two items if they are numbers,
# otherwise an "uncomparable" message is emitted.
def compare:
def english:
if .[0] < .[1] then "less than"
elif .[0] == .[1] then "equal to"
else "greater than"
end;
if (.[0]|type) == "number" and (.[1]|type) == "number" then
"\(.[0]) is \(english) \(.[1])"
else
"\(.[0]) is uncomparable to \(.[1])"
end ;
compare
Examples;
$ jq -s -r -f Integer_comparison.jq
1 2
1 is less than 2
$ jq -s -r -f Integer_comparison.jq
1 "a"
1 is uncomparable to a
Julia
function compare()
int1 = readline(stdin)
int2 = readline(stdin)
print(int1, " is ",
int1 < int2 ? "less than " :
int1 == int2 ? "equal to " :
int1 > int2 ? "greater than " :
"uncomparable to",
int2)
end
- Output:
julia> compare() 3 5 3 is less than 5
Kotlin
fun main() {
val n1 = readLine()!!.toLong()
val n2 = readLine()!!.toLong()
println(when {
n1 < n2 -> "$n1 is less than $n2"
n1 > n2 -> "$n1 is greater than $n2"
n1 == n2 -> "$n1 is equal to $n2"
else -> ""
})
}
Lambdatalk
{def compare
{lambda {:a :b}
{if {< :a :b}
then :a is lesser than :b
else {if {> :a :b}
then :a is greater than :b
else :a is equal to :b}}}}
{compare 1 2}
-> 1 is lesser than 2
{compare 2 1}
-> 2 is greater than 1
{compare 1 1}
-> 1 is equal to 1
Lang
fn.print(Enter a:\s)
$a = fn.int(fn.input())
fn.print(Enter b:\s)
$b = fn.int(fn.input())
if($a < $b) {
fn.println($a is less than $b)
}elif($a > $b) {
fn.println($a is greater than $b)
}elif($a === $b) {
fn.println($a is equals to $b)
}
Lasso
local(
number1 = integer(web_request -> param('number1')),
number2 = integer(web_request -> param('number2'))
)
#number1 < #number2 ? 'Number 1 is less than Number 2' | 'Number 1 is not less than Number 2'
'<br />'
#number1 == #number2 ? 'Number 1 is the same as Number 2' | 'Number 1 is not the same as Number 2'
'<br />'
#number1 > #number2 ? 'Number 1 is greater than Number 2' | 'Number 1 is not greater than Number 2'
- Output:
// with input of 2 & 2 Number 1 is not less than Number 2 Number 1 is the same as Number 2 Number 1 is not greater than Number 2
LIL
print "Enter two numbers separated by space"
set rc [readline]
set a [index $rc 0]
set b [index $rc 1]
if {$a < $b} {print "$a is less than $b"}
if {$a == $b} {print "$a is equal to $b"}
if {$a > $b} {print "$a is greater than $b"}
Lingo
Lingo programs are normally not run in the console, so interactive user input is handled via GUI. To not clutter this page with GUI creation code, here only the comparison part of the task:
on compare (a, b)
if a < b then put a&" is less than "&b
if a = b then put a&" is equal to "&b
if a > b then put a&" is greater than "&b
end
LiveCode
ask question "Enter 2 numbers (comma separated)" with empty titled "Enter 2 numbers"
if it is not empty then
put item 1 of it into num1
put item 2 of it into num2
if isnumber(num1) and isnumber(num2) then
if num1 < num2 then answer num1 && "is less than" && num2
if num1 is num2 then answer num1 && "is equal to" && num2
if num1 > num2 then answer num1 && "is greater than" && num2
-- alternative is to use switch case construct
switch
case (num1 < num2)
answer num1 && "is less! than" && num2; break
case (num1 > num2)
answer num1 && "is greater! than" && num2; break
case (num1 = num2)
answer num1 && "equal! to" && num2
end switch
end if
end if
LLVM
Note, this targets the mingw-32 ABI.
; ModuleID = 'test.o'
;e means little endian
;p: { pointer size : pointer abi : preferred alignment for pointers }
;i same for integers
;v is for vectors
;f for floats
;a for aggregate types
;s for stack objects
;n: {size:size:size...}, best integer sizes
target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32-n8:16:32"
;this was compiled with mingw32; thus it must be linked to a compatible c library
target triple = "i386-mingw32"
; Declare string constants
@.str = private constant [6 x i8] c"%d %d\00", align 1 ; <[6 x i8]*> [#uses=1]
@.str1 = private constant [20 x i8] c"%d is less than %d\0A\00", align 1 ; <[20 x i8]*> [#uses=1]
@.str2 = private constant [19 x i8] c"%d is equal to %d\0A\00", align 1 ; <[19 x i8]*> [#uses=1]
@.str3 = private constant [23 x i8] c"%d is greater than %d\0A\00", align 1 ; <[23 x i8]*> [#uses=1]
;Declare main function (entry point). It does not throw any exceptions, and returns an integer of size 32.
define i32 @main() nounwind {
;Entry block
entry:
;Allocate the first integer, register %a will point to that
%a = alloca i32, align 4 ; <i32*> [#uses=4]
;Allocate the second integer, register %b will point to that
%b = alloca i32, align 4 ; <i32*> [#uses=4]
;Use the C standard library function scanf() to obtain input from users.
;Scanf takes a pointer to the string constant @.str, "%d %d\00", which will take two integers from the user.
;getelementptr basically does pointer math, in this case, no ptr math is required (we point to the beginning of @.str).
;Pass %a and %b, which are pointers to integers allocated previously.
;Scanf will store the two integers into the memory locations represented by %a and %b
%0 = call i32 (i8*, ...)* @scanf(i8* noalias getelementptr inbounds ([6 x i8]* @.str, i32 0, i32 0), i32* %a, i32* %b) nounwind ; <i32> [#uses=0]
;Load the integer pointed to by %a and %b into registers %1 and %2 respectively
%1 = load i32* %a, align 4 ; <i32> [#uses=3]
%2 = load i32* %b, align 4 ; <i32> [#uses=3]
;Boolean register which represents if %1 is less than to %2
%3 = icmp slt i32 %1, %2 ; <i1> [#uses=1]
;If %1 is less than to %2, goto branch %bb, otherwise, goto %bb1
br i1 %3, label %bb, label %bb1
;If integer %1 is less than %2
bb: ; preds = %entry
;Use the C standard library function printf to output information to users
;Print @.str1, "%d is less than %d\0A\00"
;Additionally, pass the integers %1 and %2 to printf, to be formatted into the string
%4 = call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([20 x i8]* @.str1, i32 0, i32 0), i32 %1, i32 %2) nounwind ; <i32> [#uses=0]
;Continue on to %bb1, to check for equality of the two integers
br label %bb1
;Continue checking if the integers are equal
bb1: ; preds = %bb, %entry
;Boolean register which represents if %1 is equal to %2
%5 = icmp eq i32 %1, %2 ; <i1> [#uses=1]
;If %1 is equal to %2, goto branch %bb2, otherwise, goto %bb3
br i1 %5, label %bb2, label %bb3
;If integer %1 is equal to %2
bb2: ; preds = %bb1
;Use the C standard library function printf to output information to users
;Print @.str2 "%d is equal to %d\0A\00"
;Additionally, pass the integers %1 and %2 to printf, to be formatted into the string
%6 = call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([19 x i8]* @.str2, i32 0, i32 0), i32 %1, i32 %2) nounwind ; <i32> [#uses=0]
;Continue on to %bb3, to check if %1 is greater than %2
br label %bb3
;Continue checking if %1 is greater than %2
bb3: ; preds = %bb2, %bb1
;Boolean register which represents if %1 is greater than %2
%7 = icmp sgt i32 %1, %2 ; <i1> [#uses=1]
;If %1 is greather than %2, goto branch %bb4, otherwise, goto %bb5
br i1 %7, label %bb4, label %bb5
;If integer %1 is greater than %2
bb4: ; preds = %bb3
;Use the C standard library function printf to output information to users
;Print @.str3 "%d is greater than %d\0A\00"
;Additionally, pass the integers %1 and %2 to printf, to be formatted into the string
%8 = call i32 (i8*, ...)* @printf(i8* noalias getelementptr inbounds ([23 x i8]* @.str3, i32 0, i32 0), i32 %1, i32 %2) nounwind ; <i32> [#uses=0]
;Return 0 for the main function, indicating program executed successfully
ret i32 0
bb5: ; preds = %bb3
;Return 0 for the main function, indicating program executed successfully
ret i32 0
}
;Declare external fuctions
declare i32 @scanf(i8* nocapture, ...) nounwind
declare i32 @printf(i8* nocapture, ...) nounwind
Logo
to compare :a :b
if :a = :b [(print :a [equals] :b)]
if :a < :b [(print :a [is less than] :b)]
if :a > :b [(print :a [is greater than] :b)]
end
Each infix operator has prefix synonyms (equalp, equal?, lessp, less?, greaterp, greater?), where the 'p' stands for "predicate" as in Lisp.
LSE
avec SI
(* Comparaison de deux entiers en LSE (LSE-2000) *)
ENTIER A, B
LIRE ['Entrez un premier entier:',U] A
LIRE ['Entrez un second entier:',U] B
SI A < B ALORS
AFFICHER [U,' est plus petit que ',U,/] A, B
FIN SI
SI A = B ALORS
AFFICHER [U,' est égale à ',U,/] A, B
FIN SI
SI A > B ALORS
AFFICHER [U,' est plus grand que ',U,/] A, B
FIN SI
avec ÉVALUER
(* Comparaison de deux entiers en LSE (LSE-2000) *)
ENTIER A, B
LIRE ['Entrez un premier entier:',U] A
LIRE ['Entrez un second entier:',U] B
EVALUER .VRAI.
QUAND A < B
AFFICHER [U,' est plus petit que ',U,/] A, B
QUAND A = B
AFFICHER [U,' est égale à ',U,/] A, B
QUAND AUTRE
AFFICHER [U,' est plus grand que ',U,/] A, B
FIN EVALUER
avec SI..IS
(* Comparaison de deux entiers en LSE (LSE-2000) *)
ENTIER A, B
LIRE ['Entrez un premier entier:',U] A
LIRE ['Entrez un second entier:',U] B
AFFICHER [U, U, U, /] A, \
SI A < B ALORS ' est plus petit que ' SINON \
SI A = B ALORS ' est égale à ' SINON \
SI A > B ALORS ' est plus grand que ' SINON '?' IS IS IS, B
LSE64
over : 2 pick
2dup : over over
compare : 2dup = then " equals"
compare : 2dup < then " is less than"
compare : 2dup > then " is more than"
show : compare rot , sp ,t sp , nl
Lua
print('Enter the first number: ')
a = tonumber(io.stdin:read())
print('Enter the second number: ')
b = tonumber(io.stdin:read())
if a < b then print(a .. " is less than " .. b) end
if a > b then print(a .. " is greater than " .. b) end
if a == b then print(a .. " is equal to " .. b) end
In lua, a double equals symbol is required to test for equality. A single equals sign is used for assignment, and will cause an error during jit precompilation, if it is used within a boolean expression:
-- if a = b then print("This will not work")
Maple
CompareNumbers := proc( )
local a, b;
printf( "Enter a number:> " );
a := parse(readline());
printf( "Enter another number:> " );
b := parse(readline());
if a < b then
printf("The first number is less than the second");
elif a = b then
printf("The first number is equal to the second");
elif a > b then
printf("The first number is greater than the second");
end if;
end proc:
CompareNumbers();
Mathematica / Wolfram Language
a=Input["Give me the value for a please!"];
b=Input["Give me the value for b please!"];
If[a==b,Print["a equals b"]]
If[a>b,Print["a is bigger than b"]]
If[a<b,Print["b is bigger than a"]]
Maxima
/* all 6 comparison operators (last is "not equal") */
block(
[a: read("a?"), b: read("b?")],
if a < b then print(a, "<", b),
if a <= b then print(a, "<=", b),
if a > b then print(a, ">", b),
if a >= b then print(a, ">=", b),
if a = b then print(a, "=", b),
if a # b then print(a, "#", b))$
MAXScript
a = getKBValue prompt:"Enter value of a:"
b = getKBValue prompt:"Enter value of b:"
if a < b then print "a is less then b"
else if a > b then print "a is greater then b"
else if a == b then print "a is equal to b"
Metafont
message "integer 1: ";
a1 := scantokens readstring;
message "integer 2: ";
a2 := scantokens readstring;
if a1 < a2:
message decimal a1 & " is less than " & decimal a2
elseif a1 > a2:
message decimal a1 & " is greater than " & decimal a2
elseif a1 = a2:
message decimal a1 & " is equal to " & decimal a2
fi;
end
min
"$1 is $2 $3."
("Enter an integer" ask) 2 times over over
(
((>) ("greater than"))
((<) ("less than"))
((==) ("equal to"))
) case
' append prepend % print
MiniScript
integer1 = input("Please Input Integer 1:").val
integer2 = input("Please Input Integer 2:").val
if integer1 < integer2 then print integer1 + " is less than " + integer2
if integer1 == integer2 then print integer1 + " is equal to " + integer2
if integer1 > integer2 then print integer1 + " is greater than " + integer2
МК-61/52
- ЗН С/П
Input: a ^ b
Output: 1 (a > b) | -1 (a < b) | 0 (a = b)
ML/I
This reads the two numbers from 'standard input' or similar, and outputs the results to 'standard output' or equivalent. Note that ML/I only has tests for equality, greater-than, and greater-than-or-equal.
"" Integer comparison
"" assumes macros on input stream 1, terminal on stream 2
MCSKIP MT,<>
MCSKIP SL WITH ~
MCINS %.
MCDEF SL SPACES NL AS <MCSET T1=%A1.
MCSET T2=%A2.
MCGO L1 UNLESS T1 EN T2
%A1. is equal to %A2.
%L1.MCGO L2 UNLESS %A1. GR %A2.
%A1. is greater than %A2.
%L2.MCGO L3 IF %A1. GE %A2.
%A1. is less than %A2.
%L3.
MCSET S10=0
>
MCSET S1=1
~MCSET S10=2
MMIX
Some simple error checking is included.
// main registers
p IS $255 % pointer
pp GREG % backup for p
A GREG % first int
B GREG % second int
// arg registers
argc IS $0
argv IS $1
LOC Data_Segment
GREG @
ERR BYTE "Wrong number of arguments",#a,0
ILLH BYTE "Argument -> ",0
ILLT BYTE " <- contains an illegal character",#a,0
LT BYTE "A is less than B",#a,0
EQ BYTE "A equals B",#a,0
GT BYTE "A is greater than B",#a,0
LOC #1000
GREG @
// call: p points to the start of a 0-terminated numeric string
// leading chars + and - are allowed
// reg $72 0 if negative int
// reg $73 gen. purpose
// return: reg $70 contains integer value
readInt XOR $70,$70,$70 % reset result reg: N=0.
LDA pp,p % remember &p
LDBU $72,p
CMP $73,$72,'+' % ignore '+'
BZ $73,2F
CMP $72,$72,'-'
BNZ $72,1F
2H INCL p,1
JMP 1F
% repeat
3H CMP $73,$71,'0' % if c < '0' or c > '9'
BN $73,4F % then print err and halt program
CMP $73,$71,'9'
BP $73,4F
SUB $71,$71,'0' % 'extract' number
MUL $70,$70,10
ADD $70,$70,$71 % N = 10 * N + digit
INCL p,1
1H LDBU $71,p % get next digit
PBNZ $71,3B % until end of string
CMP $72,$72,0
BNZ $72,2F % if marked negative
NEG $70,$70 % then make negative
2H GO $127,$127,0 % return (N)
4H LDA p,ILLH
TRAP 0,Fputs,StdErr
LDA p,pp
TRAP 0,Fputs,StdErr
LDA p,ILLT
TRAP 0,Fputs,StdErr
TRAP 0,Halt,0
// entrance of program
// e.g. ~> mmix compare2ints A B
//
Main CMP p,argc,3 % main (argc, argv) {
BZ p,1F % if argc == 3 then continue
LDA p,ERR % else print wrong number of args
TRAP 0,Fputs,StdErr
TRAP 0,Halt,0
// get ints A and B
1H LDOU p,argv,8 % fetch addres of first int
GO $127,readInt % read int A
ADD A,$70,0
LDOU p,argv,16
GO $127,readInt % read int B
ADD B,$70,0
// perform comparison
CMP A,A,B % case compare A B
LDA p,LT
BN A,2F % LT: print 'LT'
LDA p,EQ
BZ A,2F % EQ: print 'EQ'
LDA p,GT % _ : print 'GT'
2H TRAP 0,Fputs,StdOut % print result
TRAP 0,Halt,0
Example of use:
~/MIX/MMIX/Progs> mmix compare2ints 121 122 A is less than B ~/MIX/MMIX/Progs> mmix compare2ints 121 121 A equals B ~/MIX/MMIX/Progs> mmix compare2ints 121 120 A is greater than B ~/MIX/MMIX/Progs> mmix compare2ints -121 -122 A is greater than B ~/MIX/MMIX/Progs> mmix compare2ints -121 -121 A equals B ~/MIX/MMIX/Progs> mmix compare2ints -121 -120 A is less than B
Modula-2
MODULE IntCompare;
IMPORT InOut;
VAR
A, B: INTEGER;
BEGIN
InOut.ReadInt(A);
InOut.ReadInt(B);
InOut.WriteInt(A, 1);
IF A < B THEN
InOut.WriteString(' is less than ')
ELSIF A = B THEN
InOut.WriteString(' is equal to ')
ELSE
InOut.WriteString(' is greater than ')
END;
InOut.WriteInt(B, 1);
InOut.WriteLn
END IntCompare.
Modula-3
MODULE Main;
FROM IO IMPORT Put, GetInt;
FROM Fmt IMPORT Int;
VAR a,b: INTEGER;
BEGIN
a := GetInt();
b := GetInt();
IF a < b THEN
Put(Int(a) & " is less than " & Int(b) & "\n");
ELSIF a = b THEN
Put(Int(a) & " is equal to " & Int(b) & "\n");
ELSIF a > b THEN
Put(Int(a) & " is greater than " & Int(b) & "\n");
END;
END Main.
MUMPS
INTCOMP
NEW A,B
INTCOMPREAD
READ !,"Enter an integer to test: ",A
READ !,"Enter another integer: ",B
IF (+A\1'=A)!(+B\1'=B) WRITE !!,"Please enter two integers.",! GOTO INTCOMPREAD
IF A<B WRITE !,A," is less than ",B
IF A=B WRITE !,A," is equal to ",B
IF A>B WRITE !,A," is greater than ",B
KILL A,B
QUIT
- Output:
USER>d INTCOMP^ROSETTA Enter an integer to test: 43 Enter another integer: 44 43 is less than 44 USER>d INTCOMP^ROSETTA Enter an integer to test: 44 Enter another integer: 43 44 is greater than 43 USER>d INTCOMP^ROSETTA Enter an integer to test: 2 Enter another integer: 2 2 is equal to 2
Nanoquery
print "enter first integer: "
first = int(input())
print "enter second integer: "
second = int(input())
if first = second
println "the two integers are equal"
else if first < second
println first + " is less than " + second
else if first > second
println first + " is greater than " + second
end
Nemerle
Showing both the use of comparison operators and the .Net Int32.CompareTo() method.
using System;
using System.Console;
module IntComp
{
Main() : void
{
def ReadInt() : int {Int32.Parse(ReadLine())}
def WriteResult(x : int, y : int, res : string) : void
{WriteLine($"$x is $res $y")}
def a = ReadInt();
def b = ReadInt();
match(a)
{
|a when a > b => WriteResult(a, b, "greater than")
|a when a < b => WriteResult(a, b, "less than")
|a when a == b => WriteResult(a, b, "equal to")
}
def x = a.CompareTo(b);
match(x)
{
|x when x > 0 => WriteResult(a, b, "greater than")
|x when x < 0 => WriteResult(a, b, "less than")
|x when x == 0 => WriteResult(a, b, "equal to")
}
}
}
NetRexx
/* NetRexx */
options replace format comments java crossref symbols nobinary
numL = 0
numR = 0
loop label running forever
say 'Provide two integers [or anything else to stop]:'
parse ask numL numR .
if \numL.datatype('w') | \numR.datatype('w') then leave running
if numL < numR then say numL 'is less than' numR
if numL = numR then say numL 'is equal to' numR
if numL > numR then say numL 'is greater than' numR
end running
return
NewLISP
(print "Please enter the first number: ")
(set 'A (int (read-line)))
(print "Please enter the second number: ")
(set 'B (int (read-line)))
(println
"The first one is "
(cond
((> A B) "greater than")
((= A B) "equal to")
(true "less than"))
" the second.")
Nim
import rdstdin, strutils
var a = parseInt(readLineFromStdin "Enter value of a: ")
var b = parseInt(readLineFromStdin "Enter value of b: ")
if a < b:
echo "a is less than b"
elif a > b:
echo "a is greater than b"
elif a == b:
echo "a is equal to b"
NSIS
Pure NSIS (Using IntCmp directly)
Function IntergerComparison
Push $0
Push $1
StrCpy $0 8
StrCpy $1 2
IntCmp $0 $1 Equal Val1Less Val1More
Equal:
DetailPrint "$0 = $1"
Goto End
Val1Less:
DetailPrint "$0 < $1"
Goto End
Val1More:
DetailPrint "$0 > $1"
Goto End
End:
Pop $1
Pop $0
FunctionEnd
Using LogicLib (bundled library)
Function IntegerComparison
Push $0
Push $1
StrCpy $0 8
StrCpy $1 2
${If} $0 == $1
DetailPrint "$0 = $1"
${ElseIf} $0 < $1
DetailPrint "$0 < $1"
${ElseIf} $0 > $1
DetailPrint "$0 > $1"
${EndIf}
Pop $1
Pop $0
FunctionEnd
Nu
[First Second] | each {input $"($in) integer: "| into int} | [
[($in.0 < $in.1) "less than"]
[($in.0 == $in.1) "equal to"]
[($in.0 > $in.1) "greater than"]
] | each {if $in.0 {$"The first integer is ($in.1) the second integer."}} | str join "\n"
Oberon-2
MODULE Compare;
IMPORT In, Out;
VAR a,b: INTEGER;
BEGIN
In.Int(a);
In.Int(b);
IF a < b THEN
Out.Int(a,0);
Out.String(" is less than ");
Out.Int(b,0);
Out.Ln;
ELSIF a = b THEN
Out.Int(a,0);
Out.String(" is equal to ");
Out.Int(b,0);
Out.Ln;
ELSIF a > b THEN
Out.Int(a,0);
Out.String(" is greater than ");
Out.Int(b,0);
Out.Ln;
END;
END Compare.
Objeck
bundle Default {
class IntCompare {
function : Main(args : String[]) ~ Nil {
a := Console->GetInstance()->ReadString()->ToInt();
b := Console->GetInstance()->ReadString()->ToInt();
if (a < b) {
Console->GetInstance()->Print(a)->Print(" is less than ")->PrintLine(b);
};
if (a = b) {
Console->GetInstance()->Print(a)->Print(" is equal than ")->PrintLine(b);
};
if (a > b) {
Console->GetInstance()->Print(a)->Print(" is greater than ")->PrintLine(b);
};
}
}
}
OCaml
let my_compare a b =
if a < b then "A is less than B"
else if a > b then "A is greater than B"
else if a = b then "A equals B"
else "cannot compare NANs"
let () =
let a = read_int ()
and b = read_int () in
print_endline (my_compare a b)
Octave
printf("Enter a: ");
a = scanf("%d", "C");
printf("Enter b: ");
b = scanf("%d", "C");
if (a > b)
disp("a greater than b");
elseif (a == b)
disp("a equal to b");
elseif (a < b)
disp("a less than b");
endif
Oforth
import: console
: cmpInt
| a b |
doWhile: [ System.Console askln asInteger dup ->a isNull ]
doWhile: [ System.Console askln asInteger dup ->b isNull ]
a b < ifTrue: [ System.Out a << " is less than " << b << cr ]
a b == ifTrue: [ System.Out a << " is equal to " << b << cr ]
a b > ifTrue: [ System.Out a << " is greater than " << b << cr ] ;
Ol
(define (compare a b)
(cond ((< a b) "A is less than B")
((> a b) "A is greater than B")
((= a b) "A equals B")))
(print (compare 1 2))
; ==> A is less than B
(print (compare 2 2))
; ==> A equals B
(print (compare 3 2))
; ==> A is greater than B
; manual user input:
(print (compare (read) (read)))
Oz
functor
import
Application(exit)
Open(text file)
define
Txt = class from Open.file Open.text end
Stdout = {New Open.file init(name:stdout)}
Stdin = {New Txt init(name:stdin)}
proc{Print Msg}
{Stdout write(vs:Msg)}
end
fun{GetInt Prompt}
{Print Prompt}
{StringToInt {Stdin getS($)}}
end
Int1 = {GetInt "Enter 1st Integer:"}
Int2 = {GetInt "Enter 2nd Integer:"}
if(Int1 < Int2) then {Print Int1#" less than "#Int2} end
if(Int1 > Int2) then {Print Int1#" greater than "#Int2} end
if(Int1 == Int2) then {Print Int1#" equal to "#Int2} end
{Application.exit 0}
end
PARI/GP
a=input();
b=input();
if(a<b, print(a" < "b));
if(a==b, print(a" = "b));
if(a>b, print(a" > "b));
Pascal
program compare(input, output);
var
a, b: integer;
begin
write('Input an integer number: ');
readln(a);
write('Input another integer number: ');
readln(b);
if (a < b) then writeln(a, ' is less than ', b);
if (a = b) then writeln(a, ' is equal to ', b);
if (a > b) then writeln(a, ' is greater than ', b);
end.
PascalABC.NET
begin
var (a,b) := ReadInteger2('Enter a,b:');
if a < b then
Println($'{a} is less then {b}')
else if a > b then
Println($'{a} is greater then {b}')
else Println($'{a} is equal to then {b}')
end.
Perl
Separate tests for less than, greater than, and equals
sub test_num {
my $f = shift;
my $s = shift;
if ($f < $s){
return -1; # returns -1 if $f is less than $s
} elsif ($f > $s) {
return 1; # returns 1 if $f is greater than $s
} elsif ($f == $s) {
# = operator is an assignment
# == operator is a numeric comparison
return 0; # returns 0 $f is equal to $s
};
};
All three tests in one. If $f is less than $s return -1, greater than return 1, equal to return 0
sub test_num {
return $_[0] <=> $_[1];
};
Note: In Perl, $a and $b are (kind of) reserved identifiers for the built-in sort function. It's good style to use more meaningful names, anyway.
# Get input, test and display
print "Enter two integers: ";
($x, $y) = split ' ', <>;
print $x, (" is less than ", " is equal to ",
" is greater than ")[test_num($x, $y) + 1], $y, "\n";
Phix
atom a = prompt_number("first number:",{}), b = prompt_number("second number:",{}) printf(1,"%g is ",a) if a < b then puts(1,"less than") elsif a = b then puts(1,"equal to") elsif a > b then puts(1,"greater than") end if printf(1," %g",b)
Phixmonti
/# Rosetta Code problem: http://rosettacode.org/wiki/Integer_comparison
by Galileo, 10/2022 #/
"Enter first number: " input tonum nl
"Enter second number: " input tonum nl
over over -
rot print " is " print
/# dup 0 < if drop "less" else 0 > if "greater" else "equal" endif endif #/
dup 0 < if drop "less" else dup 0 > if drop "greater" else dup 0 == if drop "equal" endif endif endif
print " than " print print
- Output:
Enter first number: 5 Enter second number: 1 5 is greater than 1 === Press any key to exit ===
PHL
module intergertest;
extern printf;
extern scanf;
@Integer main [
var a = 0;
var b = 0;
scanf("%i %i", ref (a), ref (b));
if (a < b)
printf("%i is less than %i\n", a::get, b::get);
if (a == b)
printf("%i is equal to %i\n", a::get, b::get);
if (a > b)
printf("%i is greater than %i\n", a::get, b::get);
return 0;
]
PHP
<?php
echo "Enter an integer [int1]: ";
fscanf(STDIN, "%d\n", $int1);
if(!is_numeric($int1)) {
echo "Invalid input; terminating.\n";
exit(1); // return w/ general error
}
echo "Enter an integer [int2]: ";
fscanf(STDIN, "%d\n", $int2);
if(!is_numeric($int2)) {
echo "Invalid input; terminating.\n";
exit(1); // return w/ general error
}
// now $int1 and $int2 are numbers.
// for simplicity, this does not explicitly examine types
if($int1 < $int2)
echo "int1 < int2\n";
if($int1 == $int2)
echo "int1 = int2\n";
if($int1 > $int2)
echo "int1 > int2\n";
?>
Note that this works from the command-line interface only, whereas PHP is usually executed as wp:Common_Gateway_Interface CGI.
PicoLisp
(prin "Please enter two values: ")
(in NIL # Read from standard input
(let (A (read) B (read))
(prinl
"The first one is "
(cond
((> A B) "greater than")
((= A B) "equal to")
(T "less than") )
" the second." ) ) )
- Output:
Please enter two values: 4 3 The first one is greater than the second.
Pike
int main(int argc, array(int) argv){
if(argc != 3){
write("usage: `pike compare-two-ints.pike <x> <y>` where x and y are integers.\n");
return 0;
}
int a = argv[1];
int b = argv[2];
if(a > b) {
write(a + " is greater than " + b + "\n");
} else if (a < b) {
write(a + " is less than " + b + "\n");
} else {
write(a + " is equal to " + b + "\n");
}
}
PL/I
declare (a, b) fixed binary;
get list (a, b);
if a = b then
put skip list ('The numbers are equal');
if a > b then
put skip list ('The first number is greater than the second');
if a < b then
put skip list ('The second number is greater than the first');
Plain English
To run:
Start up.
Write "Enter the first number: " to the console without advancing.
Read a first number from the console.
Write "Enter the second number: " to the console without advancing.
Read a second number from the console.
If the first number is less than the second number, write "Less than!" to the console.
If the first number is the second number, write "Equal!" to the console.
If the first number is greater than the second number, write "Greater than!" to the console.
Wait for the escape key.
Shut down.
Pop11
;;; Comparison procedure
define compare_integers(x, y);
if x > y then
printf('x is greater than y\n');
elseif x < y then
printf('x is less than y\n');
elseif x = y then
printf('x equals y\n');
endif;
enddefine;
;;; Setup token reader
vars itemrep;
incharitem(charin) -> itemrep;
;;; Read numbers and call comparison procedure
compare_integers(itemrep(), itemrep());
PowerShell
$a = [int] (Read-Host a)
$b = [int] (Read-Host b)
if ($a -lt $b) {
Write-Host $a is less than $b`.
} elseif ($a -eq $b) {
Write-Host $a is equal to $b`.
} elseif ($a -gt $b) {
Write-Host $a is greater than $b`.
}
Python
#!/usr/bin/env python
a = input('Enter value of a: ')
b = input('Enter value of b: ')
if a < b:
print 'a is less than b'
elif a > b:
print 'a is greater than b'
elif a == b:
print 'a is equal to b'
(Note: in Python3 input() will become int(input()))
An alternative implementation could use a Python dictionary to house a small dispatch table to be indexed by the results of the built-in cmp() function. cmp() returns a value suitable for use as a comparison function in a sorting algorithm: -1, 0 or 1 for <, = or > respectively. Thus we could use:
#!/usr/bin/env python
import sys
try:
a = input('Enter value of a: ')
b = input('Enter value of b: ')
except (ValueError, EnvironmentError), err:
print sys.stderr, "Erroneous input:", err
sys.exit(1)
dispatch = {
-1: 'is less than',
0: 'is equal to',
1: 'is greater than'
}
print a, dispatch[cmp(a,b)], b
In this case the use of a dispatch table is silly. However, more generally in Python the use of dispatch dictionaries or tables is often preferable to long chains of elif' clauses in a condition statement. Python's support of classes and functions (including currying, partial function support, and lambda expressions) as first class objects obviates the need for a "case" or "switch" statement.
Quackery
$ "Please enter two numbers separated by a space; "
input quackery cr
say "The first number is "
[ 2dup > iff [ say "larger than" ] done
2dup = iff [ say "equal to" ] done
2dup < if [ say "smaller than" ] ]
2drop
say " the second number." cr
- Output:
Testing in the Quackery shell (REPL).
/O> $ "Please enter two numbers separated by a space; " ... input quackery cr ... say "The first number is " ... [ 2dup > iff [ say "larger than" ] done ... 2dup = iff [ say "equal to" ] done ... 2dup < if [ say "smaller than" ] ] ... 2drop ... say " the second number." cr ... Please enter two numbers separated by a space; 4 2 The first number is larger than the second number. Stack empty.
R
print("insert number a")
a <- scan(what=numeric(0), nmax=1)
print("insert number b")
b <- scan(what=numeric(0), nmax=1)
if ( a < b ) {
print("a is less than b")
} else if ( a > b ) {
print("a is greater than b")
} else if ( a == b ) { # could be simply else of course...
print("a and b are the same")
}
Racket
#lang racket
(define (compare-two-ints a b)
(define compared
(cond ((> a b) "is greated than")
((= a b) "equals")
((< a b) "is lesser than")))
(format "~a ~a ~a" a compared b))
(compare-two-ints (read) (read))
Raku
(formerly Perl 6)
my $a = prompt("1st int: ").floor;
my $b = prompt("2nd int: ").floor;
if $a < $b {
say 'Less';
}
elsif $a > $b {
say 'Greater';
}
elsif $a == $b {
say 'Equal';
}
With <=>
:
say <Less Equal Greater>[($a <=> $b) + 1];
A three-way comparison such as <=> actually returns an Order
enum which stringifies into 'Decrease', 'Increase' or 'Same'. So if it's ok to use this particular vocabulary, you could say that this task is actually a built in:
say prompt("1st int: ") <=> prompt("2nd int: ");
Rapira
output: "Enter two integers, a and b"
input: a
input: b
case
when a > b:
output: "a is greater than b"
when a < b:
output: "a is less than b"
when a = b:
output: "a is equal to b"
esac
Raven
"Enter the first number: " print
expect trim 1.1 prefer as $a
"Enter the second number: " print
expect trim 1.1 prefer as $b
$a $b < if $b $a "%g is less than %g\n" print
$a $b > if $b $a "%g is greater than %g\n" print
$a $b = if $b $a "%g is equal to %g\n" print
REBOL
REBOL [
Title: "Comparing Two Integers"
URL: http://rosettacode.org/wiki/Comparing_two_integers
]
a: ask "First integer? " b: ask "Second integer? "
relation: [
a < b "less than"
a = b "equal to"
a > b "greater than"
]
print [a "is" case relation b]
Relation
There is no input, so numbers have to be given in code
set a = 15
set b = 21
if a > b
' a is bigger than b
else
if b > a
' b is bigger than a
else
' a is equal to b
end if
end if
Red
Red [
Title: "Comparing Two Integers"
URL: http://rosettacode.org/wiki/Comparing_two_integers
Date: 2021-10-25
]
a: to-integer ask "First integer? " b: to-integer ask "Second integer? "
relation: [
a < b "less than"
a = b "equal to"
a > b "greater than"
]
print [a "is" case relation b]
ReScript
let my_compare = (a, b) => {
if a < b { "A is less than B" } else
if a > b { "A is greater than B" } else
if a == b { "A equals B" }
else { "cannot compare NANs" }
}
let a = int_of_string(Sys.argv[2])
let b = int_of_string(Sys.argv[3])
Js.log(my_compare(a, b))
- Output:
$ bsc compint.res > compint.bs.js $ node compint.bs.js 4 2 A is greater than B $ node compint.bs.js 2 3 A is less than B $ node compint.bs.js 1 1 A equals B
Retro
Taking the numbers from the stack:
:example (ab-)
dup-pair gt? [ 'A>B s:put nl ] if
dup-pair lt? [ 'A<B s:put nl ] if
eq? [ 'A=B s:put nl ] if ;
REXX
/*REXX program prompts for two integers, compares them, and displays the results.*/
numeric digits 2000 /*for the users that really go ka─razy.*/
@=copies('─', 20) /*eyeball catcher for the user's eyen. */
a=getInt(@ 'Please enter your 1st integer:') /*obtain the 1st integer from the user.*/
b=getInt(@ 'Please enter your 2nd integer:') /* " " 2nd " " " " */
say
if a<b then say @ a ' is less than ' b
if a=b then say @ a ' is equal to ' b
if a>b then say @ a ' is greater than ' b
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
getInt: do forever; say /*keep prompting the user until success*/
say arg(1) /*display the prompt message to console*/
parse pull x /*obtain X, and keep its case intact.*/
select
when x='' then call serr "No argument was entered."
when words(x)>1 then call serr 'Too many arguments entered.' x
when \datatype(x, 'N') then call serr "Argument isn't numeric:" x
when \datatype(x, 'W') then call serr "Argument isn't an integer:" x
otherwise return x /* [↑] Eureka! Return # to invoker. */
end /*select*/
end /*forever*/
/*──────────────────────────────────────────────────────────────────────────────────────*/
serr: say @ '***error*** ' arg(1); say @ "Please try again."; return
- output (shows user input and computer program output together):
──────────────────── Please enter your 1st integer: bupkis ◄■■■■■■■■■■■■■■■ user input. ──────────────────── ***error*** Argument isn't numeric: bupkis ──────────────────── Please try again. ──────────────────── Please enter your 1st integer: 1 2 ◄■■■■■■■■■■■■■■■ user input. ──────────────────── ***error*** Too many arguments entered. ──────────────────── Please try again. ──────────────────── Please enter your 1st integer: 5.77 ◄■■■■■■■■■■■■■■■ user input. ──────────────────── ***error*** Argument isn't an integer: 5.77 ──────────────────── Please try again. ──────────────────── Please enter your 1st integer: -6 ◄■■■■■■■■■■■■■■■ user input. ──────────────────── Please enter your 2nd integer: 19.00 ◄■■■■■■■■■■■■■■■ user input. ──────────────────── -6 is less than 19.00
Ring
Func Compare a,b
if a < b
See "A is less than B"
but a > b
See "A is more than B"
else
See "A equals B"
ok
Rockstar
Minimized Rockstar:
(Get two numbers from user)
Listen to Number One
Listen to Number Two
(Check if n1 > n2)
If Number One is greater than Number Two
Say "The first is greater than the second"
(Check if n1 = n2)
If Number One is Number Two
Say "The Numbers are equal"
(Check if n1 < n2)
If Number One is less than Number Two
Say "The first is less than the second"
Idiomatic version:
Listen to your soul
Listen to my words
If your soul is my words,
Say "They're the same"
If your soul is stronger than my words,
Say "The first was bigger"
If your soul is smaller than my words,
Say "The second was bigger".
RPG
Two integers are passed as parameters. Because the command line casts numeric literals as packed(15,5), calling from the command line requires the user to specify the 8 nybbles in hexadecimal form:
CALL rc_intcmp (x'00000000' x'00000001')
h dftactgrp(*no)
d pi
d integer1 10i 0
d integer2 10i 0
d message s 50a
if integer1 < integer2;
message = 'Integer 1 is less than integer 2';
endif;
if integer1 > integer2;
message = 'Integer 1 is greater than integer 2';
endif;
if integer1 = integer2;
message = 'Integer 1 is equal to integer 2';
endif;
dsply message;
*inlr = *on;
RPL
≪ IF DUP2 < THEN "a < b" ROT ROT END IF DUP2 == THEN "a = b" ROT ROT END IF > THEN "a > b" END ≫ 'COMPR' STO
- Input:
3 5 COMPR
- Output:
1: "a < b"
Ruby
This uses Kernel#gets to get input from STDIN, and String#to_i to convert the string into an integer. (Without this conversion, Ruby would compare strings: 5 < 10 but "5" > "10".)
a = (print "enter a value for a: "; gets).to_i
b = (print "enter a value for b: "; gets).to_i
puts "#{a} is less than #{b}" if a < b
puts "#{a} is greater than #{b}" if a > b
puts "#{a} is equal to #{b}" if a == b
Another way:
a = (print "enter a value for a: "; gets).to_i
b = (print "enter a value for b: "; gets).to_i
case a <=> b
when -1; puts "#{a} is less than #{b}"
when 0; puts "#{a} is equal to #{b}"
when +1; puts "#{a} is greater than #{b}"
end
Example input and output:
$ '''ruby compare.rb''' enter a value for a: '''5''' enter a value for b: '''10''' 5 is less than 10 $ '''ruby compare.rb''' enter a value for a: '''cat''' enter a value for b: '''dog''' 0 is equal to 0
An alternative method, which is similar to the python version mentioned above (at the time of writing this) is:
# Function to make prompts nice and simple to abuse
def prompt str
print str, ": "
gets.chomp
end
# Get value of a
a = prompt('Enter value of a').to_i
# Get value of b
b = prompt('Enter value of b').to_i
# The dispatch hash uses the <=> operator
# When doing x<=>y:
# -1 means x is less than y
# 0 means x is equal to y
# 1 means x is greater than y
dispatch = {
-1 => "less than",
0 => "equal to",
1 => "greater than"
}
# I hope you can figure this out
puts "#{a} is #{dispatch[a<=>b]} #{b}"
Rust
Reading from stdin into a string is cumbersome at the moment, but convenience functions will be implemented in the future.
use std::io::{self, BufRead};
fn main() {
let mut reader = io::stdin();
let mut buffer = String::new();
let mut lines = reader.lock().lines().take(2);
let nums: Vec<i32>= lines.map(|string|
string.unwrap().trim().parse().unwrap()
).collect();
let a: i32 = nums[0];
let b: i32 = nums[1];
if a < b {
println!("{} is less than {}" , a , b)
} else if a == b {
println!("{} equals {}" , a , b)
} else if a > b {
println!("{} is greater than {}" , a , b)
};
}
SAS
/* Showing operators and their fortran-like equivalents. Note that ~= and ^= both mean "different" */
data _null_;
input a b;
put a= b=;
if a = b then put "a = b";
if a ^= b then put "a ^= b";
if a ~= b then put "a ~= b";
if a < b then put "a < b";
if a > b then put "a > b";
if a <= b then put "a <= b";
if a >= b then put "a >= b";
if a eq b then put "a eq b";
if a ne b then put "a ne b";
if a lt b then put "a lt b";
if a gt b then put "a gt b";
if a le b then put "a le b";
if a ge b then put "a ge b";
cards;
1 2
2 1
1 1
;
run;
Scala
object IntCompare {
def main(args: Array[String]): Unit = {
val a=Console.readInt
val b=Console.readInt
if (a < b)
printf("%d is less than %d\n", a, b)
if (a == b)
printf("%d is equal to %d\n", a, b)
if (a > b)
printf("%d is greater than %d\n", a, b)
}
}
Scheme
(define (my-compare a b)
(cond ((< a b) "A is less than B")
((> a b) "A is greater than B")
((= a b) "A equals B")))
(my-compare (read) (read))
Seed7
$ include "seed7_05.s7i";
const proc: main is func
local
var integer: a is 0;
var integer: b is 0;
begin
readln(a);
readln(b);
if a < b then
writeln(a <& " is less than " <& b);
end if;
if a = b then
writeln(a <& " is equal to " <& b);
end if;
if a > b then
writeln(a <& " is greater than " <& b);
end if;
end func;
SenseTalk
Ask "Provide Any Number"
Put It into A
Ask " Provide Another Number"
Put it into B
if A is less than B
Put A&" Is less than " &B
end if
if A is greater than B
Put A& " is Greater than " &B
end if
If A is Equal to B
Put A& " is Equal to " &B
End If
Sidef
var a = read("a: ", Number);
var b = read("b: ", Number);
if (a < b) {
say 'Lower';
}
elsif (a == b) {
say 'Equal';
}
elsif (a > b) {
say 'Greater';
}
- Output:
% sidef numcmp.sf a: 21 b: 42 Lower
Slate
[ |:a :b |
( a > b ) ifTrue: [ inform: 'a greater than b\n' ].
( a < b ) ifTrue: [ inform: 'a less than b\n' ].
( a = b ) ifTrue: [ inform: 'a is equal to b\n' ].
] applyTo: {Integer readFrom: (query: 'Enter a: '). Integer readFrom: (query: 'Enter b: ')}.
Smalltalk
| a b |
'a = ' display. a := (stdin nextLine asInteger).
'b = ' display. b := (stdin nextLine asInteger).
( a > b ) ifTrue: [ 'a greater than b' displayNl ].
( a < b ) ifTrue: [ 'a less than b' displayNl ].
( a = b ) ifTrue: [ 'a is equal to b' displayNl ].
SNOBOL4
Comparisons in Snobol are not operators, but predicate functions that return a null string and generate a success or failure value which allows or blocks statement execution, and which can be tested for branching. Other numeric comparisons are ge (>=), le (<=) and ne (!= ). There is also a parallel set of L-prefixed predicates in modern Snobols for lexical string comparison.
* # Get user input
output = 'Enter X,Y:'
trim(input) break(',') . x ',' rem . y
output = lt(x,y) x ' is less than ' y :s(end)
output = eq(x,y) x ' is equal to ' y :s(end)
output = gt(x,y) x ' is greater than ' y
end
SNUSP
There are no built-in comparison operators, but you can (destructively) check which of two adjacent cells is most positive.
++++>++++ a b !/?\<?\# a=b
> - \# a>b
- <
a<b #\?/
Sparkling
let a = 13, b = 37;
if a < b {
print("a < b");
} else if a > b {
print("a > b");
} else if a == b {
print("a == b");
} else {
print("either a or b or both are NaN");
}
SQL
drop table test;
create table test(a integer, b integer);
insert into test values (1,2);
insert into test values (2,2);
insert into test values (2,1);
select to_char(a)||' is less than '||to_char(b) less_than
from test
where a < b;
select to_char(a)||' is equal to '||to_char(b) equal_to
from test
where a = b;
select to_char(a)||' is greater than '||to_char(b) greater_than
from test
where a > b;
SQL> SQL> 2 3 LESS_THAN -------------------------------------------------------------------------------- 1 is less than 2 SQL> SQL> 2 3 EQUAL_TO -------------------------------------------------------------------------------- 2 is equal to 2 SQL> SQL> 2 3 GREATER_THAN -------------------------------------------------------------------------------- 2 is greater than 1
SQL PL
With SQL only:
CREATE TABLE TEST (
VAL1 INT,
VAL2 INT
);
INSERT INTO TEST (VAL1, VAL2) VALUES
(1, 2),
(2, 2),
(2, 1);
SELECT
CASE
WHEN VAL1 < VAL2 THEN VAL1 || ' less than ' || VAL2
WHEN VAL1 = VAL2 THEN VAL1 || ' equal to ' || VAL2
WHEN VAL1 > VAL2 THEN VAL1 || ' greater than ' || VAL2
END COMPARISON
FROM TEST;
Output:
db2 -t db2 => CREATE TABLE TEST ( db2 (cont.) => VAL1 INT, db2 (cont.) => VAL2 INT db2 (cont.) => ); DB20000I The SQL command completed successfully. db2 => INSERT INTO TEST (VAL1, VAL2) VALUES db2 (cont.) => (1, 2), db2 (cont.) => (2, 2), db2 (cont.) => (2, 1); DB20000I The SQL command completed successfully. db2 => SELECT db2 (cont.) => CASE db2 (cont.) => WHEN VAL1 < VAL2 THEN VAL1 || ' less than ' || VAL2 db2 (cont.) => WHEN VAL1 = VAL2 THEN VAL1 || ' equal to ' || VAL2 db2 (cont.) => WHEN VAL1 > VAL2 THEN VAL1 || ' greater than ' || VAL2 db2 (cont.) => END COMPARISON db2 (cont.) => FROM TEST; COMPARISON ----------------------------------- 1 less than 2 2 equal to 2 2 greater than 1 3 record(s) selected.
version 9.7 or higher.
With SQL PL:
--#SET TERMINATOR @
SET serveroutput ON @
CREATE PROCEDURE COMPARISON (IN VAL1 INT, IN VAL2 INT)
BEGIN
IF (VAL1 < VAL2) THEN
CALL DBMS_OUTPUT.PUT_LINE(VAL1 || ' less than ' || VAL2);
ELSEIF (VAL1 = VAL2) THEN
CALL DBMS_OUTPUT.PUT_LINE(VAL1 || ' equal to ' || VAL2);
ELSEIF (VAL1 > VAL2) THEN
CALL DBMS_OUTPUT.PUT_LINE(VAL1 || ' greater than ' || VAL2);
END IF;
END @
CALL COMPARISON(1, 2) @
CALL COMPARISON(2, 2) @
CALL COMPARISON(2, 1) @
Output:
db2 -td@ db2 => SET serveroutput ON @ DB20000I The SET SERVEROUTPUT command completed successfully. db2 => CREATE PROCEDURE COMPARISON (IN VAL1 INT, IN VAL2 INT) db2 (cont.) => BEGIN db2 (cont.) => IF (VAL1 < VAL2) THEN db2 (cont.) => CALL DBMS_OUTPUT.PUT_LINE(VAL1 || ' less than ' || VAL2); db2 (cont.) => ELSEIF (VAL1 = VAL2) THEN db2 (cont.) => CALL DBMS_OUTPUT.PUT_LINE(VAL1 || ' equal to ' || VAL2); db2 (cont.) => ELSEIF (VAL1 > VAL2) THEN db2 (cont.) => CALL DBMS_OUTPUT.PUT_LINE(VAL1 || ' greater than ' || VAL2); db2 (cont.) => END IF; db2 (cont.) => END @ DB20000I The SQL command completed successfully. db2 => CALL COMPARISON(1, 2) @ Return Status = 0 1 less than 2 db2 => CALL COMPARISON(2, 2) @ Return Status = 0 2 equal to 2 db2 => CALL COMPARISON(2, 1) @ Return Status = 0 2 greater than 1
SSEM
The SSEM only provides one conditional operation: 011 Test, which causes execution to skip one instruction if the value in the accumulator is negative. We can use this to implement conditional tests along the lines of the following pseudocode:
accumulator := a - b; if accumulator >= 0 then (* a is not less than b, so *) goto next_test else goto less; next_test: accumulator := accumulator - 1; if accumulator >= 0 then goto greater else (* a and b are equal *) accumulator := 0; halt; greater: accumulator := 1; halt; less: accumulator := -1; halt
To run the SSEM program, load A into storage address 21 and B into storage address 22. No additional space is used. Like the pseudocode version, the program halts with the accumulator holding 1 if A>B, 0 if A=B, or -1 if A<B.
10101000000000100000000000000000 0. -21 to c
10101000000001100000000000000000 1. c to 21
10101000000000100000000000000000 2. -21 to c
01101000000000010000000000000000 3. Sub. 22
00000000000000110000000000000000 4. Test
00001000000001000000000000000000 5. Add 16 to CI
00101000000000000000000000000000 6. 20 to CI
00001000000000010000000000000000 7. Sub. 16
00000000000000110000000000000000 8. Test
11001000000000000000000000000000 9. 19 to CI
10001000000000100000000000000000 10. -17 to c
00000000000001110000000000000000 11. Stop
01001000000000100000000000000000 12. -18 to c
00000000000001110000000000000000 13. Stop
00001000000000100000000000000000 14. -16 to c
00000000000001110000000000000000 15. Stop
10000000000000000000000000000000 16. 1
00000000000000000000000000000000 17. 0
11111111111111111111111111111111 18. -1
11010000000000000000000000000000 19. 11
10110000000000000000000000000000 20. 13
Standard ML
fun compare_integers(a, b) =
if a < b then print "A is less than B\n"
if a > b then print "A is greater than B\n"
if a = b then print "A equals B\n"
fun test () =
let
open TextIO
val SOME a = Int.fromString (input stdIn)
val SOME b = Int.fromString (input stdIn)
in
compare_integers (a, b)
end
handle Bind => print "Invalid number entered!\n"
A more idiomatic and less error-prone way to do it in SML would be to use a compare function that returns type order, which is either LESS, GREATER, or EQUAL:
fun myCompare (a, b) = case Int.compare (a, b) of
LESS => "A is less than B"
| GREATER => "A is greater than B"
| EQUAL => "A equals B"
Swift
import Cocoa
var input = NSFileHandle.fileHandleWithStandardInput()
println("Enter two integers separated by a space: ")
let data = input.availableData
let stringArray = NSString(data: data, encoding: NSUTF8StringEncoding)?.componentsSeparatedByString(" ")
var a:Int!
var b:Int!
if (stringArray?.count == 2) {
a = stringArray![0].integerValue
b = stringArray![1].integerValue
}
if (a==b) {println("\(a) equals \(b)")}
if (a < b) {println("\(a) is less than \(b)")}
if (a > b) {println("\(a) is greater than \(b)")}
- Output:
Enter two integers separated by a space: 234 233 234 is greater than 233
Tcl
This is not how one would write this in Tcl, but for the sake of clarity:
puts "Please enter two numbers:"
gets stdin x
gets stdin y
if { $x > $y } { puts "$x is greater than $y" }
if { $x < $y } { puts "$x is less than $y" }
if { $x == $y } { puts "$x equals $y" }
Other comparison operators are "<=", ">=" and "!=".
Note that Tcl doesn't really have a notion of a variable "type" - all variables are just strings of bytes and notions like "integer" only ever enter at interpretation time. Thus the above code will work correctly for "5" and "6", but "5" and "5.5" will also be compared correctly. It will not be an error to enter "hello" for one of the numbers ("hello" is greater than any integer). If this is a problem, the type can be expressly cast
if {int($x) > int($y)} { puts "$x is greater than $y" }
or otherwise type can be checked with "if { string is integer $x }..."
Note that there is no substitution/evaluation here anywhere: entering "3*5" and "15" will parse "3*5" as a non-numerical string (like "hello") and thus the result will be "3*5 is greater than 15".
A variant that iterates over comparison operators, demonstrated in an interactive tclsh:
% set i 5;set j 6
% foreach {o s} {< "less than" > "greater than" == equal} {if [list $i $o $j] {puts "$i is $s $j"}}
5 is less than 6
% set j 5
% foreach {o s} {< "less than" > "greater than" == equal} {if [list $i $o $j] {puts "$i is $s $j"}}
5 is equal 5
% set j 4
% foreach {o s} {< "less than" > "greater than" == equal} {if [list $i $o $j] {puts "$i is $s $j"}}
5 is greater than 4
Toka
[ ( a b -- )
2dup < [ ." a is less than b\n" ] ifTrue
2dup > [ ." a is greater than b\n" ] ifTrue
= [ ." a is equal to b\n" ] ifTrue
] is compare-integers
1 1 compare-integers
2 1 compare-integers
1 2 compare-integers
TUSCRIPT
$$ MODE TUSCRIPT
ASK "Please enter your first integer:": i1=""
ASK "Please enter your second integer:": i2=""
IF (i1!='digits'||i2!='digits') ERROR/STOP "Please insert digits"
IF (i1==i2) PRINT i1," is equal to ",i2
IF (i1<i2) PRINT i1," is less than ",i2
IF (i1>i2) PRINT i1," is greater than ",i2
UNIX Shell
There are multiple examples here, because each shell has a different form of the 'read' command.
#!/bin/ksh
# tested with ksh93s+
builtin printf
integer a=0
integer b=0
read a?"Enter value of a: " || { print -u2 "Input of a aborted." ; exit 1 ; }
read b?"Enter value of b: " || { print -u2 "Input of b aborted." ; exit 1 ; }
if (( a < b )) ; then
printf "%d is less than %d\n" a b
fi
if (( a == b )) ; then
printf "%d is equal to %d\n" a b
fi
if (( a > b )) ; then
printf "%d is greater than %d\n" a b
fi
exit 0
One can backport the previous code to pdksh, which has no builtin printf, but can call /usr/bin/printf as an external program.
#!/bin/ksh
# tested with pdksh
integer a=0
integer b=0
read a?"Enter value of a: " || { print -u2 "Input of a aborted." ; exit 1 ; }
read b?"Enter value of b: " || { print -u2 "Input of b aborted." ; exit 1 ; }
if (( a < b )) ; then
printf "%d is less than %d\n" $a $b
fi
if (( a == b )) ; then
printf "%d is equal to %d\n" $a $b
fi
if (( a > b )) ; then
printf "%d is greater than %d\n" $a $b
fi
exit 0
read -p "Enter two integers: " a b
if [ $a -gt $b ]; then comparison="greater than"
elif [ $a -lt $b ]; then comparison="less than"
elif [ $a -eq $b ]; then comparison="equal to"
else comparison="not comparable to"
fi
echo "${a} is ${comparison} ${b}"
Ursa
decl int first second
out "enter first integer: " console
set first (in int console)
out "enter second integer: " console
set second (in int console)
if (= first second)
out "the two integers are equal" endl console
end if
if (< first second)
out first " is less than " second endl console
end if
if (> first second)
out first " is greater than " second endl console
end if
V
[compare
[ [>] ['less than' puts]
[<] ['greater than' puts]
[=] ['is equal' puts]
] when].
|2 3 compare
greater than
|3 2 compare
less than
|2 2 compare
is equal
Vala
void main(){
int a;
int b;
stdout.printf("Please type in int 1\n");
a = int.parse(stdin.read_line());
stdout.printf("Please type in int 2\n");
b = int.parse(stdin.read_line());
if (a < b)
stdout.printf("%d is less than %d\n", a, b);
if (a == b)
stdout.printf("%d is equal to %d\n", a, b);
if (a > b)
stdout.printf("%d is greater than %d\n", a, b);
}
Wart
a <- (read)
b <- (read)
prn (if (a < b)
: "a is less than b"
(a > b)
: "a is greater than b"
:else
: "a equals b")
Wren
import "io" for Stdin, Stdout
System.print("Enter anything other than a number to quit at any time.\n")
while (true) {
System.write(" First number : ")
Stdout.flush()
var a = Num.fromString(Stdin.readLine())
if (!a) break
System.write(" Second number : ")
Stdout.flush()
var b = Num.fromString(Stdin.readLine())
if (!b) break
var s = (a-b).sign
if (s < 0) {
System.print(" %(a) < %(b)")
} else if (s == 0) {
System.print(" %(a) == %(b)")
} else {
System.print(" %(a) > %(b)")
}
System.print()
}
- Output:
Sample session:
Enter anything other than a number to quit at any time. First number : 5 Second number : 23 5 < 23 First number : 56 Second number : 6 56 > 6 First number : 4 Second number : 4 4 == 4 First number : q
XLISP
(DEFUN COMPARE-INTEGERS ()
(DISPLAY "Enter two integers separated by a space.")
(NEWLINE)
(DISPLAY "> ")
(DEFINE A (READ))
(DEFINE B (READ))
(COND
((> A B) (DISPLAY "The first number is larger."))
((= A B) (DISPLAY "They are equal."))
((< A B) (DISPLAY "The first number is smaller."))))
XPL0
code IntIn=10, Text=12;
int A, B;
[A:= IntIn(0);
B:= IntIn(0);
if A<B then Text(0, "A<B");
if A=B then Text(0, "A=B");
if A>B then Text(0, "A>B");
CrLf(0);
]
XSLT
Because XSLT uses XML syntax, the less than and greater than operators which would normally be written '<' and '>' must be escaped using character entities, even inside of XPath expressions.
<xsl:template name="compare">
<xsl:param name="a" select="1"/>
<xsl:param name="b" select="2"/>
<fo:block>
<xsl:choose>
<xsl:when test="$a < $b">a < b</xsl:when>
<xsl:when test="$a > $b">a > b</xsl:when>
<xsl:when test="$a = $b">a = b</xsl:when>
</xsl:choose>
</fo:block>
</xsl:template>
zkl
var x,y; x,y=ask("Two ints: ").split(" ").apply("toInt")
(if (x==y) "equal" else if (x<y) "less" else if(x>y) "greater").println()
- Output:
Two ints: 3 2 greater
- Programming Tasks
- Basic Data Operations
- Arithmetic operations
- Simple
- 11l
- 360 Assembly
- 6502 Assembly
- 68000 Assembly
- 8051 Assembly
- 8th
- AArch64 Assembly
- ABAP
- Action!
- Ada
- Aime
- ALGOL 68
- ALGOL W
- AppleScript
- ARM Assembly
- Arturo
- Astro
- AutoHotkey
- Avail
- AWK
- Axe
- BASIC
- Applesoft BASIC
- BaCon
- BASIC256
- BBC BASIC
- FreeBASIC
- FutureBasic
- Gambas
- IS-BASIC
- Liberty BASIC
- OxygenBasic
- PureBasic
- QBasic
- Run BASIC
- SmallBASIC
- TI-83 BASIC
- TI-89 BASIC
- Tiny BASIC
- True BASIC
- VBA
- VBScript
- Visual Basic .NET
- Yabasic
- ZX Spectrum Basic
- Batch File
- Bc
- BCPL
- Befunge
- BQN
- Bracmat
- Brat
- Burlesque
- C
- C sharp
- C++
- CFEngine
- ChucK
- Clean
- Clipper
- Clojure
- CMake
- COBOL
- ColdFusion
- Common Lisp
- Computer/zero Assembly
- D
- Dc
- DCL
- Delphi
- Draco
- Dyalect
- E
- EasyLang
- ECL
- EDSAC order code
- Efene
- Eiffel
- Elena
- Elixir
- Emacs Lisp
- EMal
- Erlang
- Euphoria
- Excel
- F Sharp
- Factor
- FALSE
- Fantom
- Fermat
- Fish
- Forth
- Fortran
- Friendly interactive shell
- Frink
- FunL
- Fōrmulæ
- Go
- Groovy
- Harbour
- Haskell
- Hexiscript
- HicEst
- HolyC
- Hy
- I
- Icon
- Unicon
- J
- Java
- JavaScript
- Joy
- Jq
- Julia
- Kotlin
- Lambdatalk
- Lang
- Lasso
- LIL
- Lingo
- LiveCode
- LLVM
- Cstdlib
- Logo
- LSE
- Avec SI
- Avec ÉVALUER
- Avec SI..IS
- LSE64
- Lua
- Maple
- Mathematica
- Wolfram Language
- Maxima
- MAXScript
- Metafont
- Min
- MiniScript
- МК-61/52
- ML/I
- MMIX
- Modula-2
- Modula-3
- MUMPS
- Nanoquery
- Nemerle
- NetRexx
- NewLISP
- Nim
- NSIS
- LogicLib
- Nu
- Oberon-2
- Objeck
- OCaml
- Octave
- Oforth
- Ol
- Oz
- PARI/GP
- Pascal
- PascalABC.NET
- Perl
- Phix
- Phix/basics
- Phixmonti
- PHL
- PHP
- PicoLisp
- Pike
- PL/I
- Plain English
- Pop11
- PowerShell
- Python
- Quackery
- R
- Racket
- Raku
- Rapira
- Raven
- REBOL
- Relation
- Red
- ReScript
- Retro
- REXX
- Ring
- Rockstar
- RPG
- RPL
- Ruby
- Rust
- SAS
- Scala
- Scheme
- Seed7
- SenseTalk
- Sidef
- Slate
- Smalltalk
- SNOBOL4
- SNUSP
- Sparkling
- SQL
- SQL PL
- SSEM
- Standard ML
- Swift
- Tcl
- Toka
- TUSCRIPT
- UNIX Shell
- Ursa
- V
- Vala
- Wart
- Wren
- XLISP
- XPL0
- XSLT
- Zkl
- Pages with too many expensive parser function calls