J'ai un problème au travail. J'ai besoin de comparer deux nombres provenant de chaînes de deux bases de données différentes. Les nombres peuvent être accompagnés de zéros de tête et / ou d'espaces de début / fin. Je peux donc avoir "0001 "d'une base de données et " 1 "de l'autre.

J'ai résolu le problème en C # avec le code suivant:

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

Le défi

Il s'agit d'un défi très simple, adapté aux débutants et à tout type de langues ésotériques. Étant donné deux nombres sous forme de chaînes pouvant être accompagnés de zéros de début et / ou d'espaces de début / de fin, écrivez le code le plus court qui vérifie si les deux chaînes représentent le même nombre.

• Les entrées doivent être deux chaînes ou l'équivalent dans votre langue (un tableau de caractères est OK), et elles représenteront toujours des valeurs entières supérieures à zéro.
• La sortie doit être deux valeurs cohérentes quelconques qui représentent une valeur véridique et une valeur de falsey.

Exemples

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

Il s'agit de code-golf , de sorte que le code le plus court pour chaque langue gagne!

Javascript , 11 octets

a=>b=>+a==b

Abuser un peu des règles de casting de Javascript; +acontraint aen un type numérique.

-6 octets grâce à Shaggy et Martin Ender ♦

Aussi une prise cool de LiefdeWen :

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

05AB1E , 1 octet

Q

Essayez-le en ligne!

Explication

La comparaison pour l'égalité Qessaiera automatiquement d'évaluer les chaînes comme des entiers avant de comparer.

Langage de script Operation Flashpoint , 33 octets

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

Appeler avec:

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]

Sortie:

Version alternative (41 octets):

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

Encore 5 octets de moins que le plus simple f={t=_this;call(t select 0)==call(t select 1)}

39 octets:

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

count(qui renvoie la taille d'un tableau) fonctionne à la place de forEach, car vous pouvez lui donner un "lambda" qui est utilisé comme condition pour ne compter que les éléments du tableau qui remplissent cette condition. La "condition" utilisée dans ce cas n'est pas une condition valide, mais elle n'a pas d'importance ici car elle ne provoque pas d'erreur et la valeur de retour de la countn'est pas nécessaire.

Taxi , 488 octets

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.

Essayez-le en ligne!

Non golfé:

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 est (relativement) bien adapté à ce défi car les chaînes sont le seul type d'entrée ou de sortie autorisé. The Babelfisheryest ce qui convertit les chaînes en nombre (et vice versa) et gère la suppression de tous les espaces et des zéros non significatifs. Il gérera également les nombres négatifs si le -est immédiatement avant le premier chiffre. Après cela, Equal's Cornervérifie les deux valeurs l'une par rapport à l'autre et Writer's Depotfournit la sortie au format chaîne. La sortie est 1pour truey et 0pour falsey.

C (gcc) , 27 octets

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

Avec -O0(qui est le paramètre par défaut).

Essayez-le en ligne!

C, 32 octets

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

Essayez-le en ligne!

J , 4 octets

=&do

Comparez =après &évaluation do. Peut également être =&". Essayez-le en ligne!

Rétine , 11 octets

.+
$*
D`
¶$

Essayez-le en ligne!

L'entrée est séparée par saut de ligne, mais la suite de tests utilise la séparation par virgule pour plus de commodité. Imprime 1pour l'égalité et 0pour l'inégalité.

Explication

.+
$*

Convertissez chaque ligne en unaire. Cela ignore les zéros et les espaces en tête.

D`

Dédupliquer: effacer la deuxième ligne si les deux sont identiques.

¶$

Vérifiez que la chaîne se termine maintenant par un saut de ligne.

Python 3 , 25 octets

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

Essayez-le en ligne!

Brain-Flak , 22 octets

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

Essayez-le en ligne!

Enregistré 4 octets grâce à Jo King .

Triangularité , 17 octets

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

Essayez-le en ligne!

La triangulation est, pour une fois, compétitive!

Comment ça marche

La triangularité nécessite que le code ait une distribution triangulaire des points. Autrement dit, la longueur de chaque ligne doit être égale au nombre de lignes multiplié par 2 et décrémenté, et chaque ligne doit avoir (de chaque côté) un nombre de points égal à sa position dans le programme (la ligne du bas est la ligne 0, celui au-dessus est la ligne 1 et ainsi de suite). Gardant cela à l'esprit, analysons le fonctionnement du code:

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

Alice , 7 octets

X/n
o@i

Essayez-le en ligne!

Tout séparateur non numérique fonctionne. Imprime 1pour l'égalité et 0autrement.

Explication

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.

Japt , 3 octets

¥Vn

Essayez-le

Convertit la deuxième entrée en un entier et compare l'égalité avec la première.

APL (Dyalog) , 4 octets

3 octets enregistrés grâce à @ Adám

=/⍎¨

Essayez-le en ligne!

jq, 24 caractères

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

Les 2 chaînes sont passées en tant qu'éléments d'un tableau.

Exemple d'exécution:

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

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

Essayez-le en ligne! ( Tous les cas de test )

Husk , 3 octets

¤=r

Essayez-le en ligne!

Explication

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

PowerShell , 20 octets

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

Semblable à la réponse JavaScript, juste plus longtemps car PowerShell n'a pas de curry. Utilise +pour convertir la première chaîne en entier, puis l' -equals convertit automatiquement la deuxième chaîne en entier. La sortie est True / False.

Essayez-le en ligne!

PowerShell , 19 octets

$args-join'-eq'|iex

Essayez-le en ligne!

-joinl'argument array ( $args) avec la représentation sous forme de chaîne de l'opérateur de comparaison ( -eq) puis évaluer l'expression avec Invoke-Expression( iex).

Q (Kdb +), 13 octets

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

Explication

(x; y): une liste des deux entrées.

"J" $: conversion de chaque entrée en un type long (7j) à partir de la chaîne (10c), qui peut interpréter correctement
les espaces blancs et les 0 en tête.

= /: vérifie l'égalité sur les éléments d'une liste (chaque paire suivante).
Comme il n'y a qu'une seule paire, retourne un booléen unique 0b / 1b.

T-SQL, 35 octets

Selon nos normes , les données sont entrées via une table préexistante tavec des varcharchamps aet b.

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

Renvoie 1s'ils correspondent, 0sinon.

Quelques-unes des fonctions mathématiques de SQL (y compris ABS, FLOORet CEILING) effectueront une conversion implicite en numérique si des paramètres de chaîne donnés sont plus courts qu'un explicite CAST(a AS INT)ou CONVERT(INT,b), et fonctionnent dans ce cas car nous savons que les valeurs d'entrée sont toujours positives.

IIF est spécifique à MS SQL 2012 et supérieur, donc aucune garantie sur les autres implémentations.

Excel VBA, 27 16 octets

-9 Merci à @Nayrb et @TaylorScott

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

Où vous entrez les valeurs sur les cellules avec 'string.

Où xet ysont les chaînes d'entrée et zest une sortie booléenne.

Si CInt (x) = CInt (y) Alors z = 1

Utilisation de CInt

R , 28 27 octets

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

Lit les nombres sous forme de chaînes, les convertit en doubles et vérifie si leur différence n'est pas nulle.

Essayez-le en ligne!

−1 octet grâce à Giuseppe

Lua , 20 octets

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

Essayez-le en ligne!

Haskell , 20 octets

-11 octets grâce à Laikoni. -2 octets grâce à Zgarb.

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

Essayez-le en ligne!

Gema , 21 personnages

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

Pas de booléen à Gema. Comme les fonctions @get-switch{}/ @set-switch{}utilisent 0 et 1 pour représenter les états des commutateurs, également utilisées 0 et 1.

Les 2 chaînes sont passées sur des lignes d'entrée distinctes.

Exemple d'exécution:

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

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

$_=$_==<>

essayez-le en ligne

Empilé , 8 octets

[#~\#~=]

Essayez-le en ligne!

Explication

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

Attaché , 11 octets

Same@Map&:N

Essayez-le en ligne!

Cela prend un tableau de chaînes, comme V["0001", "1 "]. En termes simples, Map&:Nest une fonction qui mappe Nson argument et Samevérifie que le tableau ne contient que des membres égaux. (Fait amusant: cette fonction fonctionne pour plus de 2 arguments de chaîne.)

SNOBOL4 (CSNOBOL4) , 42 octets

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

Essayez-le en ligne!

Sorties 1 pour véridique, rien pour falsey. Puisque (espace) est l'opérateur de concaténation dans SNOBOL, EVALing un nombre avec des espaces de début / fin donne le nombre lui-même, et il prend également soin de tous les zéros de tête. EQtests d'égalité numérique, conditionnellement OUTPUTà 1 activé Success.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, ~ 29 octets BASIC à jeton

Nouvelle solution grâce à Neil (merci pour l'astuce).

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

Cette solution nécessite une entrée utilisateur, donc entrez deux chaînes avec des espaces blancs et / ou des zéros non significatifs, ou entrez deux chaînes de valeur numérique non égale; 0est faux et 1vrai une fois que la ligne trois a comparé la valeur de chaque chaîne entrée.

Ancienne solution: Sinclair ZX81 / Timex TS1000 / 1500 BASIC, ~ 46 octets BASIC tokenisés

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

La vérification proprement dite est effectuée sur la troisième ligne, qui ne représente que ~ 16 octets BASIC à jeton; donc la saisie de chaque paire de cas de test en mode direct permettra d'économiser environ 30 octets de la liste. Notez que ce nombre d'octets n'inclut pas le var stack.

APL (NARS2000) , 7 octets

=⍥⍎

Eh bien, oui, je sais que NARS2000 ne peut pas rivaliser avec Dyalog ici car il utilise Unicode, mais je pensais que je préfèrerais me montrer ⍥(appelé Composition dans NARS2000, même si cela n'est en fait pas lié à la composition des fonctions), ce que Dyalog ne fait pas avoir comme intégré et je n'ai jamais vu utilisé ici. Dans Dyalog, il doit être mis en œuvre comme{(⍵⍵⍺)⍺⍺⍵⍵ ⍵} . Ce qu'il fait, c'est appeler la fonction monadique de l'opérande droit sur les arguments gauche et droit, puis appeler la fonction dyadique de l'opérande gauche sur les résultats.

Ici, l'opérande de droite est ⍎( Execute , ie eval) et l'opérande de gauche est =( Equal To , c'est-à-dire vérifier si ses arguments sont égaux).