Compare two numbers given as strings

Question

I have a problem at work. I need to compare two numbers that come as strings from two different databases. The numbers may come with leading zeroes and/or leading/trailing spaces. So I may have "0001 " from one database and " 1 " from the other one.

I solved the problem in C# with the following code:

Func<string, string, bool> f = (a,b) => int.Parse(a.Trim()) == int.Parse(b.Trim())

The challenge

This is a really simple challenge, suitable for beginners and any kind of esoteric languages. Given two numbers as strings that may come with leading zeroes and/or leading/trailing spaces, write the shortest code that checks if the two strings represent the same number.

• The inputs need to be two strings or the equivalent in your language (a char array is OK), and they will always represent integer values greater than zero.
• The output must be any two consistent values that represent a truthy value and a falsey value.

Examples

A          B          Result
----------------------------
"0001"     "1    "    true
"1450"     "1450 "    true
"0010001 " " 10001  " true
"0010000"  "  10  "   false
"101023"   "101024"   false

This is code-golf, so may the shortest code for each language win!

Answer 1

Javascript, 11 bytes

a=>b=>+a==b

Abusing Javascript's casting rules a bit; +a coerces a into a numeric type.

-6 bytes thanks to Shaggy and Martin Ender♦

Also a cool take by LiefdeWen:

a=>b=>~~a==~~b

Answer 2

05AB1E, 1 byte

Q

Try it online!

Explanation

Comparison for equality Q will automatically try to evaluate strings as ints before comparing.

Answer 3

Operation Flashpoint scripting language, 33 bytes

f={call format(["%1==%2"]+_this)}

Call with:

hint format["%1\n%2\n%3\n%4\n%5",
    ["0001", "1    "] call f,
    ["1450", "1450 "] call f,
    ["0010001 ", " 10001  "] call f,
    ["0010000", "  10  "] call f,
    ["101023", "101024"] call f]

Output:

Alternative version (41 bytes):

f={{t=call _x;r=t==s;s=t}forEach _this;r}

Still 5 bytes shorter than the more straightforward f={t=_this;call(t select 0)==call(t select 1)}

39 bytes:

f={{t=call _x;r=t==s;s=t}count _this;r}

count (which returns the size of an array) works instead of forEach, because you can give it a "lambda" that is used as a condition to count only the array elements that meet that condition. The "condition" used in this case is not a valid condition, but it doesn't matter here because it doesn't cause an error and the return value of the count is not needed.

Answer 4

Taxi, 488 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Equal's Corner.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:n 1 l 1 l 1 l.Switch to plan "b" if no one is waiting.'1' is waiting at Writer's Depot.[b]'0' is waiting at Writer's Depot.Go to Writer's Depot:n 1 l 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.

Try it online!

Ungolfed:

Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Equal's Corner.
Pickup a passenger going to Equal's Corner.
Go to Equal's Corner: north 1st left 1st left 1st left.
Switch to plan "b" if no one is waiting.
'1' is waiting at Writer's Depot.
[b]
'0' is waiting at Writer's Depot.
Go to Writer's Depot: north 1st left 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.

Taxi is (relatively) well-suited to this challenge because strings are the only input or output type allowed. The Babelfishery is what converts strings to number (and vice versa) and it handles stripping all the spaces and leading zeroes. It will also handle negative numbers if the - is immediately before the first digit. After that, Equal's Corner checks the two values against each other and Writer's Depot provides the output in string format. Output is 1 for truthy and 0 for falsey.

Answer 5

C (gcc), 27 bytes

f(s,t){s=atoi(s)==atoi(t);}

With -O0 (which is the default setting).

Try it online!

C, 32 bytes

f(s,t){return atoi(s)==atoi(t);}

Try it online!

Answer 6

J, 4 bytes

=&do

Compare = after & evaluating do. Can also be =&". Try it online!

Answer 7

Retina, 11 bytes

.+
$*
D`
¶$

Try it online!

Input is linefeed separated, but the test suite uses comma separation for convenience. Prints 1 for equality and 0 for inequality.

Explanation

.+
$*

Convert each line to unary. This ignores leading zeros and spaces.

D`

Deduplicate: clear the second line if both are the same.

¶$

Check that the string now ends in a linefeed.

Answer 8

Brain-Flak, 22 bytes

(([{}]{})[{(){}}](){})

Try it online!

Saved 4 bytes thanks to Jo King.

Answer 9

Python 3, 25 bytes

lambda a,b:int(a)==int(b)

Try it online!

Answer 10

Triangularity, 17 bytes

..)..
.Ii).
@Ii=.

Try it online!

Triangularity is, for once, competitive!

How it works

Triangularity requires the code to have a triangular distribution of the dots. That is, the length of each row must be equal the number of rows multiplied by 2 and decremented, and each row must have (on each side) a number of dots equal to its position in the program (the bottom row is row 0, the one above it is row 1 and so forth). Keeping this in mind, let's analyse how the code works:

..).. || Push a 0 onto the stack.
.Ii   || Get the 0th input and cast it to an integer.
   ). || Push another 0 onto the stack.
@I    || Increment the ToS => 1. Get the first input.
  i=. || Then cast it to an integer and compare their equality.

Answer 11

APL (Dyalog), 4 bytes

3 bytes saved thanks to @Adám

=/⍎¨

Try it online!

Answer 12

Japt, 3 bytes

¥Vn

Try it

Converts the second input to an integer and compares equality with the first.

Answer 13

Alice, 7 bytes

X/n
o@i

Try it online!

Any non-digit separator works. Prints 1 for equality and 0 otherwise.

Explanation

X   XOR, does nothing.
/   Switch to Ordinal mode.
i   Read all input as a string.
/   Switch to Cardinal mode.
X   XOR. Implicitly finds all integers in the string and pushes them separately
    onto the stack. The XOR gives 0 if the values are identical.
n   Logical NOT. Gives 1 for equal inputs and 9 otherwise.
/   Switch to Ordinal.
o   Print the 0 or 1 as a string.
/   Switch to Cardinal.
@   Terminate the program.

Answer 14

jq, 24 characters

map(tonumber)|.[0]==.[1]

The 2 strings are passed as items of an array.

Sample run:

bash-4.4$ jq 'map(tonumber)|.[0]==.[1]' <<< '["0010001 ", " 10001  "]'
true

bash-4.4$ jq 'map(tonumber)|.[0]==.[1]' <<< '["0010000", "  10  "]'
false

Try it online! (All test cases)

Answer 15

Excel VBA, 27 16 Bytes

-9 Thanks to @Nayrb and @TaylorScott

[C1]=[A1]-[B1]=0

Where you input the values on the Cells with 'string.

Where x and y are the input Strings and z is a Boolean output.

If CInt(x)=CInt(y) Then z=1

Using CInt

Answer 16

Husk, 3 bytes

¤=r

Try it online!

Explanation

¤    -- combine both arguments of ..
 =   -- .. equality ..
  r  -- .. with read

Answer 17

PowerShell, 20 bytes

param($a,$b)+$a-eq$b

Similar to the JavaScript answer, just longer because PowerShell doesn't have currying. Uses + to cast the first string to integer, and then the -equals automatically casts the second string to integer. Output is True/False.

Try it online!

Answer 18

T-SQL, 35 bytes

Per our standards, data is input via pre-existing table t with varchar fields a and b.

    SELECT IIF(ABS(a)=ABS(b),1,0)FROM t

Returns 1 if they match, 0 if they don't.

A few of SQL's mathematical functions (including ABS, FLOOR and CEILING) will do an implicit conversion to numeric if given string parameters, this is shorter than an explicit CAST(a AS INT) or CONVERT(INT,b), and works in this case since we know the input values are always positive.

IIF is specific to MS SQL 2012 and above, so no guarantee about other implementations.

Answer 19

Q (Kdb+), 13 bytes

=/["J"$(x;y)]

Explanation

(x;y) : a list of the two inputs.

"J"$ : casting each input to a long (7j) type from string (10c), which can correctly interpret
white space and leading 0s.

=/ : checks equality over elements in a list (each subsequent pair).
As there is only one pair, returns single boolian 0b/1b.

Answer 20

PowerShell, 19 bytes

$args-join'-eq'|iex

Try it online!

-join the argument array ($args) with the string representation of the comparison operator (-eq) then evaluate the expression with Invoke-Expression (iex).

Answer 21

R, 28 27 bytes

!diff(as.double(scan(,'')))

Reads numbers as strings, converts them to doubles and checks if their difference is not zero.

Try it online!

−1 byte thanks to Giuseppe

Answer 22

Haskell, 20 bytes

-11 bytes thanks to Laikoni. -2 bytes thanks to Zgarb.

a#b=0+read a==read b

Try it online!

Answer 23

Lua, 20 bytes

print(...-arg[2]==0)

Try it online!

Answer 24

Sinclair ZX81/Timex TS1000/1500 BASIC, ~29 tokenized BASIC bytes

New solution thanks to Neil (thanks for the tip).

 1 INPUT A$
 2 INPUT B$
 3 PRINT VAL A$=VAL B$

This solution requires user input, so enter in two strings with white spaces and/or leading zeros, or enter two strings of non-equal numeric value; 0 is false and 1 is true once line three has compared the value of each string entered.

Old solution: Sinclair ZX81/Timex TS1000/1500 BASIC, ~46 tokenized BASIC bytes

 1 LET A$=" 001 "
 2 LET B$="1"
 3 PRINT (VAL A$=VAL B$)

The actual check is done in line three, which is only ~16 tokenized BASIC bytes; so entering each test case pair using direct mode will save ~30 bytes from the listing. Note that this byte count does not include the var stack.

Answer 25

Gema, 21 characters

*\n*=@cmpn{*;*;0;1;0}

No boolean in Gema. As the @get-switch{}/@set-switch{} functions use 0 and 1 to represent switch statuses, also used 0 and 1.

The 2 strings are passed on separate input lines.

Sample run:

bash-4.4$ gema '*\n*=@cmpn{*;*;0;1;0}' <<< $'0010001\n10001  '
1

bash-4.4$ gema '*\n*=@cmpn{*;*;0;1;0}' <<< $'0010000\n  10  '
0

Answer 26

Perl 5, 9 + 1 (-p) = 10 bytes

$_=$_==<>

try it online

Answer 27

Stacked, 8 bytes

[#~\#~=]

Try it online!

Explanation

[#~\#~=]   anonymous function
 #~        eval TOS
   \       swap top two
    #~     eval TOS
      =    push equality of top two

Answer 28

Swift, 80 79 78 bytes

import Foundation;func r(g:[NSString])->Bool{return g[0].intValue==g[1].intValue}

Try it online!

Answer 29

Attache, 11 bytes

Same@Map&:N

Try it online!

This takes an array of strings, such as V["0001", "1 "]. Simply stated, Map&:N is a function that maps N over its argument, and Same checks that the array contains only equal members. (Fun fact: this function works for more than 2 string arguments.)

Answer 30

SNOBOL4 (CSNOBOL4), 42 bytes

	OUTPUT =EQ(EVAL(INPUT),EVAL(INPUT)) 1
END

Try it online!

Outputs 1 for truthy, nothing for falsey. Since (space) is the concatenation operator in SNOBOL, EVALing a number with leading/trailing spaces yields the number itself, and it also neatly takes care of any leading zeroes. EQ tests for numerical equality, conditionally setting OUTPUT to 1 on Success.

Answer 31

Java 8, 58 51 bytes

7 bytes thanks to Kevin

b->c->new Long(b.trim()).equals(new Long(c.trim()))

Try it online!

Explanation

Trims off spaces, casting to Long removes leading zeros, and then returns boolean value if they are equal or not.

Answer 32

APL (NARS2000), 7 bytes

=⍥⍎

Well, yes, I do know NARS2000 can't compete over Dyalog here since it uses Unicode, but I thought I'd rather show off ⍥ (called Composition in NARS2000, even though it's actually unrelated to function composition), something Dyalog doesn't have as a built-in and I haven't ever seen used here. In Dyalog, it has to be implemented as {(⍵⍵⍺)⍺⍺⍵⍵ ⍵}. What it does is call the right operand monadic function on both the left and right argument, and then call the left operand dyadic function on the results.

Here, the right operand is ⍎ (Execute, i.e. eval) and the left operand is = (Equal To, i.e. check if its arguments are equal).

Answer 33

Jelly, 8 bytes

t€⁶V€€ḌE

Try it online! or see the test suite

35 answers, and no Jelly submission? Takes the argument as a list (["0001", "1 "] for the first example)

How it works

t€⁶V€€ḌE - Main link. Argument: list       e.g.    ["0001", "1    "]
 €       - For €ach element...                     ["0001", "1"]
t        -   trim from both sides...
  ⁶      -   spaces
     €   - For €ach element...
   V€    -   evaluate €ach character               [[0, 0, 0, 1], [1]]
      Ḍ  - Convert from digits                     [1, 1]
       E - Are they equal?                         1

Answer 34

R, 37 35 bytes

pryr::f(as.double(x)==as.double(y))

There's probably some cleverer way to coerce strings to numerics but I haven't figured it out yet.

Try it online!

Answer 35

><>, 2 + 3 = 5 bytes

=n

Try it online!

Uses the -v flag to pass the values into the program. This automatically converts them to numbers, removing the spaces and leading 0s. It then outputs if the two are equal, and exits with an error as it tries to compare an empty stack.

Answer 36

dc, 9 bytes

[1p]sQ?=Q

Outputs 1 if the numbers are equal, or nothing if unequal. The input numbers are separated by ',', and this gives a warning since data is code in dc. I wasn't sure if space was allowed as delimiter, so I chose one that doesn't stop the program.

Try it online!

Answer 37

Excel, 8 bytes

=A1-B1=0

Excel does the string to num conversion for us.

(To input as string, prefix values with '.)

Answer 38

Batch, 89 bytes

@call:c %1
@set e=%errorlevel%
@call:c %2
@if %e%==%errorlevel% echo 1
:c
@exit/b%~1

Prints 1 if the two numbers are the same. Explanation: Batch's numeric processing usually uses leading zeros to indicate an octal number, however exit/b always takes a decimal number. The ~ removes any quotes that would be needed to pass leading or trailing spaces in the parameter.

Answer 39

Ruby, 23 bytes

s=->x,y{x.to_i==y.to_i}

Answer 40

Pyth, 4 bytes

qFsM

Try it online!

Int-parse each element of the input list with sM(Q), then Fold over equality.

Answer 41

Wolfram Language, 27 bytes

ToExpression[#1<>"=="<>#2]&

Test cases:

In[1]:= ToExpression[#1 <> "==" <> #2] &["0001", "1"]
Out[1]= True

In[2]:= ToExpression[#1 <> "==" <> #2] &["1450", "1450 "]
Out[2]= True

In[3]:= ToExpression[#1 <> "==" <> #2] &["0010001", " 10001"]
Out[3]= True

In[4]:= ToExpression[#1 <> "==" <> #2] &["0010000", "  10  "]
Out[4]= False

In[5]:= ToExpression[#1 <> "==" <> #2] &["101023", "101024"]
Out[5]= False

Answer 42

AWK, 12 bytes

{$0=$1==$2}1

Try it online!

AWK, 9 bytes

$0=$1==$2

Alternate version: outputs 1 on match, otherwise outputs nothing

Try it online!

Answer 43

Clean, 52 bytes

import StdEnv
$n=toInt{#c\\c<-n|c>' '}
?n=(==)($n)o$

Try it online!

Answer 44

C++ (gcc), 65 bytes

#include<cstdlib>
auto a(auto b,auto c){return atoi(b)==atoi(c);}

Try it online!

I initially tried used a lambda expression, but auto a=[] is three more characters, and less one more for no trailing semicolon. On the other hand, since atoi is not referenced until the lambda is instantiated, could I delete the #include and put that in the test harness footer instead?

Answer 45

Javascript, 6 bytes

Pretty standard stuff, but using Javascript's auto type casting

!(a-b)

Or if we don't need it as a function (19 bytes)

let f=(a,b)=>!(a-b)

Try it online! https://jsfiddle.net/pgz4ctLy/2/

Answer 46

PHP 5.6+, 16 (42 when callable) bytes

The minimum code that meets the puzzle's requirements (16 bytes):

(int)$a==(int)$b

In callable form (42 bytes):

function f($a,$b){return(int)$a==(int)$b;}

Try it online, with tests

Explanation

Declare a regular function with a single-character name f with two, otherwise undetermined parameters. It returns the result of comparing both arguments after casting each to integers, which safely removed the padding and whitespace. The code could have been made 2 bytes shorter by converting the function to a closure, but then the closure would not be assigned (which takes another 3 bytes), and therefore not callable.

Answer 47

Mumps, 7 bytes

W +X=+Y

In Mumps, all data are strings, the '+' operator evaluates the string to a numeric value. There is no implicit output function, so the 'W' (Write) function provides the output.

Answer 48

Tcl, 45 bytes

proc x a\ b {expr [scan $a %d]==[scan $b %d]}

Try it online!

Answer 49

K (oK), 5 bytes

Solution:

=/.:'

Try it online!

Examples:

=/.:'("0001";"1    ")
1
=/.:'("1450";"1450 ")
1
=/.:'("0010001";" 10001  ")
1
=/.:'("0010000";"  10  ")
0
=/.:'("101023";"101024")
0

Explanation:

Convert each input to an integer, and then check for equality.

=/.:' / the solution
  .:' / value (.:) each ('), converts char list to integer
=/    / equality (=) over (/)

Answer 50

Perl 6, 4 bytes

*==*

Test it

The == operator converts to Numeric which ignores leading and trailing whitespace, and leading 0's get ignored just the same. (0o127 is how you write an octal)

The two * are just there to turn it into a lambda that takes two arguments.

Answer 51

Implicit, 5 bytes

'ì'ì=

Try it online!

'ì'ì=
'      «read string, push to stack                  »;
 ì     «swap type (integer/string) of top of stack  »;
  'ì   «do it again for the second integer string   »;
    =  «compare for equality                        »;

Answer 52

C# (32 bytes)

a=>b=>int.Parse(a)==int.Parse(b)

Try it online

as already mentioned in the comments, you can do it shorter than the C# provided in the question. I wrote this thinking I was clever before reading the reply to the comments by the OP. :)

Answer 53

R, 55 bytes

V<-strtoi(gsub(" ","",c(A,B),fixed=T),base=9)
V[1]==V[2]

This is my first attempt at codegolf; gave it my best try. Suggestions welcome!

Assumptions:

1. The inputs are given as strings A and B

2. The integers contained are less than 1888888888. Larger values will cause strtoi() to return NA.

Answer 54

Stratos, 3 bytes

_=_

Both of the _ take an input as a string and convert it to a number, then negate it.

Java converts the input to a number by removing 0s and spaces.

The = takes the results of this and checks for equality

Try it!

Answer 55

Pyt, 1 byte

=

Explanation

         Implicitly takes two inputs, and casts them to integers/floats if possible.
=        Checks if the two are equal

Try it online!

Answer 56

FALSE, 36 bytes

[0[^$9>][$32>[48-+10*]?]#%10/]$!\!=.

Numbers are received from the console, separated by a tab character. True=-1, False=0.