Tengo un problema en el trabajo Necesito comparar dos números que vienen como cadenas de dos bases de datos diferentes. Los números pueden venir con ceros iniciales y / o espacios iniciales / finales. Entonces puedo tener "0001 "de una base de datos y " 1 "de la otra.

Resolví el problema en C # con el siguiente código:

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

El reto

Este es un desafío realmente simple, adecuado para principiantes y cualquier tipo de lenguaje esotérico. Dados dos números como cadenas que pueden venir con ceros iniciales y / o espacios iniciales / finales, escriba el código más corto que verifique si las dos cadenas representan el mismo número.

• Las entradas deben ser dos cadenas o el equivalente en su idioma (una matriz de caracteres está bien), y siempre representarán valores enteros mayores que cero.
• La salida debe ser dos valores consistentes que representen un valor verdadero y un valor falso.

Ejemplos

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

Este es el código de golf , ¡así que puede ganar el código más corto para cada idioma!

Javascript , 11 bytes

a=>b=>+a==b

Abusar un poco de las reglas de conversión de Javascript; +acoacciona aen un tipo numérico.

-6 bytes gracias a Shaggy y Martin Ender ♦

También una versión genial de LiefdeWen :

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

05AB1E , 1 byte

Q

Pruébalo en línea!

Explicación

La comparación por igualdad Qintentará evaluar automáticamente las cadenas como ints antes de comparar.

Lenguaje de script Operation Flashpoint , 33 bytes

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

Llamar con:

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]

Salida:

Versión alternativa (41 bytes):

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

Todavía 5 bytes más cortos que los más directos 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(que devuelve el tamaño de una matriz) funciona en lugar de hacerlo forEach, porque puede darle una "lambda" que se usa como condición para contar solo los elementos de la matriz que cumplen esa condición. La "condición" utilizada en este caso no es una condición válida, pero no importa aquí porque no causa un error y el valor de retorno de la countno es necesario.

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.

Pruébalo en línea!

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

El taxi es (relativamente) adecuado para este desafío porque las cadenas son el único tipo de entrada o salida permitido. The Babelfisheryes lo que convierte las cadenas en números (y viceversa) y maneja la eliminación de todos los espacios y ceros a la izquierda. También manejará números negativos si -está inmediatamente antes del primer dígito. Después de eso, Equal's Cornercomprueba los dos valores entre sí y Writer's Depotproporciona la salida en formato de cadena. La salida es 1para la verdad y 0para falsey.

C (gcc) , 27 bytes

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

Con -O0(que es la configuración predeterminada).

Pruébalo en línea!

C, 32 bytes

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

Pruébalo en línea!

J , 4 bytes

=&do

Compare =después de &evaluar do. También se puede =&". probar en línea!

Retina , 11 bytes

.+
$*
D`
¶$

Pruébalo en línea!

La entrada está separada por salto de línea, pero el conjunto de pruebas utiliza la separación por coma para mayor comodidad. Impresiones 1para la igualdad y0 desigualdad.

Explicación

.+
$*

Convierta cada línea a unario. Esto ignora los ceros y espacios iniciales.

D`

Deduplicar: borra la segunda línea si ambos son iguales.

¶$

Compruebe que la cadena ahora termina en un salto de línea.

Python 3 , 25 bytes

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

Pruébalo en línea!

Brain-Flak , 22 bytes

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

Pruébalo en línea!

Guardado 4 bytes gracias a Jo King .

Triangularidad , 17 bytes.

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

Pruébalo en línea!

¡La triangularidad es, por una vez, competitiva!

Cómo funciona

La triangularidad requiere que el código tenga una distribución triangular de los puntos. Es decir, la longitud de cada fila debe ser igual al número de filas multiplicado por 2 y decrementado, y cada fila debe tener (en cada lado) un número de puntos igual a su posición en el programa (la fila inferior es la fila 0, el de arriba es la fila 1 y así sucesivamente). Teniendo esto en cuenta, analicemos cómo funciona el código:

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

X/n
o@i

Pruébalo en línea!

Cualquier separador sin dígitos funciona. Impresiones 1para la igualdad y lo 0contrario.

Explicación

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 bytes

¥Vn

Intentalo

Convierte la segunda entrada en un número entero y compara la igualdad con la primera.

APL (Dyalog) , 4 bytes

3 bytes guardados gracias a @ Adám

=/⍎¨

Pruébalo en línea!

jq, 24 caracteres

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

Las 2 cadenas se pasan como elementos de una matriz.

Ejecución de muestra:

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

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

Pruébalo en línea! ( Todos los casos de prueba )

Casco , 3 bytes

¤=r

Pruébalo en línea!

Explicación

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

PowerShell , 20 bytes

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

Similar a la respuesta de JavaScript, solo más tiempo porque PowerShell no tiene curry. Utiliza +para convertir la primera cadena a entero, y luego los -equals automáticamente convierten la segunda cadena a entero. La salida es verdadera / falsa.

Pruébalo en línea!

PowerShell , 19 bytes

$args-join'-eq'|iex

Pruébalo en línea!

-joinla matriz de argumentos ( $args) con la representación de cadena del operador de comparación ( -eq) luego evalúa la expresión con Invoke-Expression( iex).

Q (Kdb +), 13 bytes

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

Explicación

(x; y): una lista de las dos entradas.

"J" $: convertir cada entrada a un tipo largo (7j) desde la cadena (10c), que puede interpretar correctamente
los espacios en blanco y los ceros a la izquierda.

= /: verifica la igualdad sobre los elementos en una lista (cada par posterior).
Como solo hay un par, devuelve un solo booliano 0b / 1b.

T-SQL, 35 bytes

Según nuestros estándares , los datos se ingresan a través de una tabla preexistente tcon varcharcampos ay b.

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

Devuelve 1si coinciden,0 si no.

Algunas de las funciones matemáticas de SQL (que incluyen ABS, FLOORy CEILING) harán una conversión implícita a numéricos si se les dan parámetros de cadena, esto es más corto que un explícito CAST(a AS INT)o CONVERT(INT,b), y funciona en este caso ya que sabemos que los valores de entrada son siempre positivos.

IIF es específico de MS SQL 2012 y superior, por lo que no hay garantía sobre otras implementaciones.

Excel VBA, 27 16 bytes

-9 Gracias a @Nayrb y @TaylorScott

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

Donde ingresas los valores en las Celdas con 'string .

Donde xy yson las cadenas de entrada y zes una salida booleana.

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

Utilizando CInt

R , 28 27 bytes

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

Lee los números como cadenas, los convierte en dobles y comprueba si su diferencia no es cero.

Pruébalo en línea!

-1 byte gracias a Giuseppe

Lua , 20 bytes

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

Pruébalo en línea!

Haskell , 20 bytes

-11 bytes gracias a Laikoni. -2 bytes gracias a Zgarb.

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

Pruébalo en línea!

Gema , 21 personajes

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

No booleano en Gema. Como las funciones @get-switch{}/ @set-switch{}usan 0 y 1 para representar estados de cambio, también se usan 0 y 1.

Las 2 cadenas se pasan en líneas de entrada separadas.

Ejecución de muestra:

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 bytes

$_=$_==<>

pruébalo en línea

Apilado , 8 bytes

[#~\#~=]

Pruébalo en línea!

Explicación

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

Adjunto , 11 bytes

Same@Map&:N

Pruébalo en línea!

Esto toma una serie de cadenas, como V["0001", "1 "]. En pocas palabras, Map&:Nes una función que se asigna Nsobre su argumento y Samecomprueba que la matriz contiene solo miembros iguales. (Dato curioso: esta función funciona para más de 2 argumentos de cadena).

SNOBOL4 (CSNOBOL4) , 42 bytes

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

Pruébalo en línea!

Salidas 1 para la verdad, nada para falsey. Dado que (espacio) es el operador de concatenación en SNOBOL, al EVALingresar un número con espacios iniciales / finales se obtiene el número en sí mismo, y también se ocupa perfectamente de los ceros iniciales. EQprueba la igualdad numérica, condicionalmente OUTPUTa 1 en Success.

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

Nueva solución gracias a Neil (gracias por el consejo).

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

Esta solución requiere la entrada del usuario, por lo tanto, ingrese dos cadenas con espacios en blanco y / o ceros a la izquierda, o ingrese dos cadenas de valor numérico no igual; 0es falso y1 es verdadero una vez que la línea tres ha comparado el valor de cada cadena ingresada.

Solución anterior: Sinclair ZX81 / Timex TS1000 / 1500 BASIC, ~ 46 bytes BASIC tokenizados

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

La verificación real se realiza en la línea tres, que es solo ~ 16 bytes BASIC tokenizados; así que ingresar cada par de casos de prueba usando el modo directo ahorrará ~ 30 bytes de la lista. Tenga en cuenta que este recuento de bytes no incluye el var stack.

APL (NARS2000) , 7 bytes

=⍥⍎

Bueno, sí, sé que NARS2000 no puede competir con Dyalog aquí ya que usa Unicode, pero pensé que preferiría presumir ⍥(llamado Composición en NARS2000, aunque en realidad no está relacionado con la composición de funciones), algo que Dyalog no tengo como incorporado y nunca he visto usado aquí. En Dyalog, debe implementarse como{(⍵⍵⍺)⍺⍺⍵⍵ ⍵} . Lo que hace es llamar a la función monádica del operando derecho en el argumento izquierdo y derecho, y luego llamar a la función diádica del operando izquierdo en los resultados.

Aquí, el operando correcto es ⍎( Ejecutar , es decir, eval) y el operando izquierdo es =( Igual a , es decir, verificar si sus argumentos son iguales).