Integer comparison: Difference between revisions

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

V b = Int(input(‘Enter value of b: ’))

print(‘a is greater than b’)

I a == b

=={{header|360 Assembly}}==

Input is done by a standard register 1 pointed parameter list.

* Reg1=Addr(Addr(argA),Addr(argB))

L 2,0(1) Reg2=Addr(argA)

A DS F 31-bit signed integer

B DS F 31-bit signed integer

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

Specific OS/hardware routines for user input and printing are left unimplemented.

It should be noted that this is strictly an unsigned comparison.

JSR GetUserInput ;routine not implemented

;integers to compare now in memory locations A and B

A_equals_B: JSR DisplayAEqualsB ;routine not implemented

Done: PLA ;restore Accumulator from stack

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

===Unsigned Comparison===

;integers to compare are in D0 and D1

CMP.L D1,D0

Equal:

dc.b "both are equal",0

===Signed Comparison===

;integers to compare are in D0 and D1

CMP.L D1,D0

Equal:

dc.b "both are equal",0

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

push psw

cjne a, b, clt

compare_:

pop psw

Testing for (a <= b) or (a >= b) can be performed by changing the jumps.

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

{{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>).

.equ SVC_WRITE, 64

.equ SVC_EXIT, 93

_exit:

mov x8, #SVC_EXIT

=={{header|ABAP}}==

This works in ABAP version 7.40 and above. Note that empty input is evaluated to 0.

report z_integer_comparison.

write comparison_result.

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

INT a,b

=={{header|Ada}}==

with Ada.Integer_Text_IO; use Ada.Integer_Text_Io;

Put_Line("A is greater than B");

end if;

=={{header|Aime}}==

output(integer a, integer b, text condition)

{

return 0;

Run as:

<pre>aime FILE integer a 33 integer b 133</pre>

The above distributions of both [[ALGOL 68G]] and [[ELLA ALGOL 68]] compilers only

allow [[wp:ASCII|ASCII]] characters (ASCII has neither "&le;", "&ge;" nor "&ne;" characters).

INT a, b;

read((a, space, b, new line));

print((a," is greater or equal to ", b, new line))

FI

{{out}}

<pre>

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

integer a, b;

if a > b then write( a, " is greater than ", b );

=={{header|AppleScript}}==

set n2 to text returned of (display dialog "Enter the second number:" default answer "") as integer

set msg to {n1}

end if

set end of msg to n2

Or...

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

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

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

szMessErrDep: .asciz "Too large: overflow 32 bits.\n"

=={{header|Arturo}}==

b: to :integer input "enter a value for b: "

=={{header|Astro}}==

let b = input('Enter value of b: ')

print 'a is greater than b'

elif a == b:

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

The default range is 0 to 100.

Gui, Add, UpDown, vVar1

Gui, Add, Edit

GuiClose:

=={{header|Avail}}==

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";]

=={{header|AWK}}==

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:

=={{header|Axe}}==

If r₁<r₂

Disp "LESS THAN",i

Disp "GREATER THAN",i

End

=={{header|BASIC}}==

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

{{works with|QuickBasic|4.5}}

INPUT "a, b"; a, b 'remember to type the comma when you give the numbers

PRINT "a is ";

IF a = b THEN PRINT "equal to ";

IF a > b THEN PRINT "greater than ";

==={{header|Applesoft BASIC}}===

20 A$(0) = "NOT "

30 PRINT A% " IS " A$(A% < B%) "LESS THAN " B%

40 PRINT A% " IS " A$(A% = B%) "EQUAL TO " B%

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

110 INPUT PROMPT "Enter B: ":B

120 IF A<B THEN

160 ELSE

170 PRINT A;"is greater than ";B

or

110 INPUT PROMPT "Enter B: ":B

120 SELECT CASE A

170 CASE ELSE

180 PRINT A;"is greater than ";B

==={{header|BASIC256}}===

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

==={{header|OxygenBasic}}===

uses console

print "Integer comparison. (press ctrl-c to exit) " cr cr

endif

loop

==={{header|QBasic}}===

IF x < y THEN PRINT x; " is less than "; y

IF x = y THEN PRINT x; " is equal to "; y

==={{header|True BASIC}}===

INPUT x, y

IF x = y THEN PRINT x; " is equal to "; y

IF x > y THEN PRINT x; " is greater than "; y

==={{header|Yabasic}}===

if x < y then print x, " is less than ", y : fi

if x = y then print x, " is equal to ", y : fi

==={{Header|Tiny BASIC}}===

INPUT A

PRINT "Enter another number"

IF A < B THEN PRINT A," is less than ",B

IF A > B THEN PRINT A," is greater than ",B

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

setlocal EnableDelayedExpansion

set /p a="A: "

) else ( if %a% EQU %b% (

echo %a% is equal to %b%

{{Out}}

<pre>C:\Test>IntegerComparison.bat

=={{header|BBC BASIC}}==

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

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

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"

=={{header|Befunge}}==

The branch commands (underline _ and pipe |) test for zero.

>&&"=A",,\:."=B ",,,\: .55+,-:0`|

v "<" _v#<

=={{header|BQN}}==

The function <code>Comp</code> compares two integers and returns the appropriate string result.

⊑(/⟜⟨ "Greater than" "Equal To" "Lesser Than" ⟩>∾=∾<)

"Equal To"

6 Comp 5

=={{header|Bracmat}}==

& get$:?B

& (!A:!B&out$"A equals B"|)

& (!A:<!B&out$"A is less than B"|)

=={{header|Brat}}==

second = ask("Second integer: ").to_i

when { first > second } { p "#{first} is greater than #{second}" }

{ first < second } { p "#{first} is less than #{second}" }

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

=={{header|C}}==

int main()

return 0;

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

class Program

Console.WriteLine("{0} is greater than {1}", a, b);

}

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

int main()

if (a > b)

std::cout << a << " is greater than " << b << "\n";

=={{header|CFEngine}}==

bundle agent __main__

{

if => isgreaterthan( "$(first_integer)", "$(second_integer)" );

}

=={{header|ChucK}}==

fun void intComparison (int one, int two)

{

// uncomment next line and change values to test

// intComparison (2,4);

=={{header|Clean}}==

compare a b

(_, a, console) = freadi console

(_, b, console) = freadi console

=={{header|Clipper}}==

IF a < b

? "A is less than B"

ENDIF

Return Nil

=={{header|Clojure}}==

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.

(doseq [[op string] [[< "less than"]

[> "greater than"]

[= "equal to"]]]

(when (op a b)

=={{header|CMake}}==

# cmake -DA=3 -DB=5 -P compare.cmake

if(A GREATER B)

message(STATUS "${A} is greater than ${B}")

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. Int-Compare.

GOBACK

=={{header|ColdFusion}}==

===In CFML===

<cfargument name="Integer1" type="numeric">

<cfargument name="Integer2" type="numeric">

</cfif>

<cfreturn VARIABLES.Result >

===In CFScript===

function CompareInteger( Integer1, Integer2 ) {

VARIABLES.Result = "";

return VARIABLES.Result;

}

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

You can type this directly into a REPL:

(b (read *standard-input*)))

(cond

((> a b) (format t "~A is greater than ~A." a b))

((= a b) (format t "~A is equal to ~A." a b))

After hitting enter, the REPL is expecting the two numbers right away.

Alternatively, you can wrap this code in a function definition:

(let ((a (read *standard-input*))

(b (read *standard-input*)))

((> a b) (format t "~A is greater than ~A." a b))

((= a b) (format t "~A is equal to ~A." a b))

Then, execute the function for better control:

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.

x: NOP

JMP start

=={{header|D}}==

import std.stdio, std.conv, std.string;

if (a > b)

writeln(a, " is greater than ", b);

{{out}}

<pre>10 is less than 20</pre>

=={{header|Dc}}==

[Enter two numbers to compare: ]P

? sbsa

[ [equal to]]sp lb la =p

la n [ is ]P P [ ]P lbn []pP

{{out}}

44 is greater than 3

=={{header|DCL}}==

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

{{out}}

<pre>$ @integer_comparison

:''Slightly different than the [[#Pascal|Pascal]] example''

{$APPTYPE CONSOLE}

if a = b then Writeln(a, ' is equal to ', b);

if a > b then Writeln(a, ' is greater than ', b);

=={{header|Draco}}==

int a, b;

write("Please enter two integers: ");

elif a>b then writeln(a, " > ", b)

fi

=={{header|Dyalect}}==

{{trans|Clipper}}

if a < b {

"A is less than B"

"A equals B"

}

=={{header|E}}==

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?` })

=={{header|EasyLang}}==

b = number input

if a < b

if a > b

print "greater"

=={{header|ECL}}==

CompareThem(INTEGER A,INTEGER B) := FUNCTION

Result := A <=> B;

CompareThem(2,2); //Shows "2 is equal to 2"

CompareThem(2,1); //Shows "2 is greater than 1"

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

==================

[ 18 ] AF [ - character ]

=={{header|Efene}}==

since if does pattern matching the else is required to avoid the application from crashing

if A == B {

io.format("~p equals ~p~n", [A, B])

compare(4, 5)

}

=={{header|Eiffel}}==

APPLICATION

inherit

end

end

=={{header|Elena}}==

ELENA 4.x:

public program()

if (a > b)

{ console.printLine(a," is greater than ",b) }

=={{header|Elixir}}==

{b,_} = IO.gets("Enter your second integer: ") |> Integer.parse

a == b ->

IO.puts "#{a} is equal to #{b}"

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

"Compare A to B and print the outcome in the message buffer."

(interactive "nFirst integer ⇒\nnSecond integer ⇒")

((< a b) (message "%d is less than %d." a b))

((> a b) (message "%d is greater than %d." a b))

Invoke from within Emacs Lisp (or e.g., with <code>M-:</code>) as <code>(integer-comparison 12 42)</code>

=={{header|Erlang}}==

main() ->

{ok, [N]} = io:fread("First integer: ", "~d"),

end.

=={{header|Euphoria}}==

integer a,b

puts(1,"grater then")

end if

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

=={{header|F_Sharp|F#}}==

let r =

match a with

| x when x > b -> 1, printfn "%d is greater than %d" x b

| x -> 0, printf "default condition (not reached)"

=={{header|Factor}}==

readln readln [ string>number ] bi@

[ > [ "A > B" print ] when ]

[ < [ "A < B" print ] when ]

[ = [ "A = B" print ] when ] 2tri ;

=={{header|FALSE}}==

Only equals and greater than are available.

>[\$," is greater than "\$,]?

\>[\$," is less than "\$,]?

=={{header|Fantom}}==

Uses Env.cur to access stdin and stdout.

{

public static Void main ()

}

}

=={{header|Fermat}}==

?a;

?b;

=={{header|Fish}}==

This example assumes you [http://www.esolangs.org/wiki/Fish#Input.2Foutput pre-populate] the stack with the two integers.

v <>l?^"Please pre-populate the stack with the two integers."ar>l?^;

\$:@@:@)?v v ;oanv!!!?<

> v

/oo". "nooooo" and "n$< v o<

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.

To keep the example simple, the word takes the two numbers from the stack.

2dup < if ." a is less than b" then

2dup > if ." a is greater than b" then

=={{header|Fortran}}==

In ALL Fortran versions (including original 1950's era) you could use an "arithmetic IF" statement to compare using subtraction:

integer a, b

40 continue

In ANSI FORTRAN 66 or later you could use relational operators (.lt., .gt., .eq., etc.) and unstructured IF statements:

integer a, b

c fortran 77 I/O statements, for simplicity

if (a .eq. b) write(*, *) a, ' is equal to ', b

if (a .gt. b) write(*, *) a, ' is greater than ', b

In ANSI FORTRAN 77 or later you can use relational operators and structured IF statements:

integer a, b

read(*,*) a, b

end if

In ISO Fortran 90 or later you can use symbolic relational operators (<, >, ==, etc.)

integer :: a, b

read(*,*) a, b

end if

=={{header|FreeBASIC}}==

Dim As Integer x, y

Print

Print "Press any key to exit"

=={{header|friendly interactive shell}}==

read b

else if test $a -eq $b

echo Equal

=={{header|Frink}}==

All integers in Frink can be arbitrarily large.

if a<b

println["$a < $b"]

println["$a == $b"]

if a>b

=={{header|FunL}}==

a = readInt()

val (_, c) = [((<), 'less than'), ((==), 'equal to'), ((>), 'greater than')].find( (compare, _) -> compare(a, b) ).get()

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

begin enum 1

_integer1Fld

on dialog fn DoDialog

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

=={{header|Gambas}}==

Dim sIn As String = InputBox("Enter 2 integers seperated by a comma")

Dim iFirst, iSecond As Integer

If iFirst = iSecond Then Print iFirst & " is equal to " & iSecond

Output:

<pre>

=={{header|Go}}==

import (

fmt.Println(n1, "greater than", n2)

}

=={{header|Groovy}}==

===Relational Operators===

println "a ? b = ${a} ? ${b} = a ${a < b ? '<' : a > b ? '>' : a == b ? '==' : '?'} b"

Program:

comparison(2000,300000)

{{out}}

==="Spaceship" (compareTo) Operator===

Using spaceship operator and a lookup table:

def comparisonSpaceship = { a, b ->

println "a ? b = ${a} ? ${b} = a ${rels[a <=> b]} b"

Program:

comparison(2000,300000)

{{out}}

=={{header|Harbour}}==

IF a < b

ENDIF

=={{header|Haskell}}==

myCompare a b

| a < b = "A is less than B"

a <- readLn

b <- readLn

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:

LT -> "A is less than B"

GT -> "A is greater than B"

=={{header|hexiscript}}==

let b scan int

if a = b

println a + " is equal to " + b

=={{header|HicEst}}==

IF (a < b) THEN

ELSEIF(a > b) THEN

WRITE(Messagebox) a, ' is greater than ', b

=={{header|HolyC}}==

a = Str2I64(GetStr("Enter your first number: "));

b = Str2I64(GetStr("Enter your second number: "));

if (a > b)

=={{header|Hy}}==

(def b (int (input "Enter value of b: ")))

(print (cond [(< a b) "a is less than b"]

[(> a b) "a is greater than b"]

=={{header|i}}==

a = number(read(' '))

b = number(read())

print(a, " is greater than ", b)

end

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

until integer(a) do {

write(a," = ", a = b)

write(a," > ", a > b)

{{out}}

=={{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>:

cti=: dyad define

English =. ' is less than ';' is equal to ';' is greater than '

x (":@[, (compare select English"_), ":@]) y

Examples of use:

0 1 0

4 cti 3

=={{header|Java}}==

public class compInt {

} catch(IOException e) { }

}

=={{header|JavaScript}}==

// Using type coercion

function compare(a, b) {

}

}

=={{header|Joy}}==

DEFINE

prompt == "Please enter a number and <Enter>: " putchars;

=={{header|jq}}==

# otherwise an "uncomparable" message is emitted.

end ;

Examples;

$ jq -s -r -f Integer_comparison.jq

1 2

1 "a"

1 is uncomparable to a

=={{header|Julia}}==

int1 = readline(stdin)

int2 = readline(stdin)

int2)

end

<pre>julia> compare()

3

=={{header|Kotlin}}==

val n1 = readLine()!!.toLong()

val n2 = readLine()!!.toLong()

else -> ""

})

=={{header|Lambdatalk}}==

{def compare

{lambda {:a :b}

{compare 1 1}

-> 1 is equal to 1

=={{header|Lasso}}==