Ho un problema sul lavoro. Ho bisogno di confrontare due numeri che arrivano come stringhe da due diversi database. I numeri possono venire con zeri iniziali e / o spazi iniziali / finali. Quindi potrei avere "0001 "da un database e " 1 "dall'altro.

Ho risolto il problema in C # con il seguente codice:

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

La sfida

Questa è una sfida davvero semplice, adatta a principianti e qualsiasi tipo di lingue esoteriche. Dati due numeri come stringhe che possono venire con zeri iniziali e / o spazi iniziali / finali, scrivere il codice più breve che controlla se le due stringhe rappresentano lo stesso numero.

• Gli input devono essere due stringhe o equivalenti nella tua lingua (un array di caratteri è OK) e rappresenteranno sempre valori interi maggiori di zero.
• L'output deve essere due valori coerenti che rappresentano un valore di verità e un valore di falsità.

Esempi

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

Questo è code-golf , quindi può vincere il codice più breve per ogni lingua!

Javascript , 11 byte

a=>b=>+a==b

Abusare un po 'delle regole di casting di Javascript; +acostringe ain un tipo numerico.

-6 byte grazie a Shaggy e Martin Ender ♦

Anche una bella idea di LiefdeWen :

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

05AB1E , 1 byte

Q

Provalo online!

Spiegazione

Il confronto per uguaglianza Qproverà automaticamente a valutare le stringhe come ints prima del confronto.

Operazione linguaggio di scripting Flashpoint , 33 byte

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

Chiama 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]

Produzione:

Versione alternativa (41 byte):

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

Ancora 5 byte più brevi di quelli più semplici f={t=_this;call(t select 0)==call(t select 1)}

39 byte:

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

count(che restituisce le dimensioni di un array) funziona invece di forEach, perché puoi assegnargli un "lambda" che viene utilizzato come condizione per contare solo gli elementi dell'array che soddisfano tale condizione. La "condizione" utilizzata in questo caso non è una condizione valida, ma qui non importa perché non causa un errore e countnon è necessario il valore restituito .

Taxi , 488 byte

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.

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

Il taxi è (relativamente) adatto a questa sfida perché le stringhe sono l'unico tipo di input o output consentito. The Babelfisheryè ciò che converte le stringhe in numero (e viceversa) e gestisce la rimozione di tutti gli spazi e lo zero iniziale. Gestirà anche numeri negativi se -è immediatamente prima della prima cifra. Successivamente, Equal's Cornercontrolla i due valori l'uno contro l'altro e Writer's Depotfornisce l'output in formato stringa. L'output è 1per la verità e 0per la falsità.

C (gcc) , 27 byte

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

Con -O0(che è l'impostazione predefinita).

Provalo online!

C, 32 byte

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

Provalo online!

J , 4 byte

=&do

Confronta =dopo aver &valutato do. Può anche essere =&". Provalo online!

Retina , 11 byte

.+
$*
D`
¶$

Provalo online!

L'input è separato dalla linea di alimentazione, ma la suite di test utilizza la separazione virgola per comodità. Stampa 1per l'uguaglianza e 0per la disuguaglianza.

Spiegazione

.+
$*

Converti ogni riga in unario. Ciò ignora gli zeri e gli spazi iniziali.

D`

Deduplica: cancella la seconda riga se entrambi sono uguali.

¶$

Controlla che la stringa finisca ora con un avanzamento riga.

Python 3 , 25 byte

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

Provalo online!

Brain-Flak , 22 byte

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

Provalo online!

Salvato 4 byte grazie a Jo King .

Triangolarità , 17 byte

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

Provalo online!

La triangolarità è, per una volta, competitiva!

Come funziona

La triangolarità richiede che il codice abbia una distribuzione triangolare dei punti. Cioè, la lunghezza di ogni riga deve essere uguale al numero di righe moltiplicato per 2 e decrementato e ogni riga deve avere (su ciascun lato) un numero di punti uguale alla sua posizione nel programma (la riga inferiore è la riga 0, quello sopra di esso è la riga 1 e così via). Tenendo presente questo, analizziamo come funziona il codice:

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

X/n
o@i

Provalo online!

Qualsiasi separatore senza cifre funziona. Stampa 1per uguaglianza e 0altro.

Spiegazione

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 byte

¥Vn

Provalo

Converte il secondo input in un numero intero e confronta l'uguaglianza con il primo.

APL (Dyalog) , 4 byte

3 byte salvati grazie a @ Adám

=/⍎¨

Provalo online!

jq, 24 caratteri

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

Le 2 stringhe vengono passate come elementi di un array.

Esecuzione di esempio:

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

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

Provalo online! ( Tutti i casi di test )

Buccia , 3 byte

¤=r

Provalo online!

Spiegazione

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

PowerShell , 20 byte

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

Simile alla risposta JavaScript, solo più a lungo perché PowerShell non ha curry. Utilizza per +eseguire il cast della prima stringa in numero intero, quindi -equals lancia automaticamente la seconda stringa in numero intero. L'output è Vero / Falso.

Provalo online!

PowerShell , 19 byte

$args-join'-eq'|iex

Provalo online!

-joinl'argomento array ( $args) con la rappresentazione in formato stringa dell'operatore di confronto ( -eq) quindi valuta l'espressione con Invoke-Expression( iex).

Q (Kdb +), 13 byte

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

Spiegazione

(x; y): un elenco dei due input.

"J" $: cast di ogni input in un tipo lungo (7j) da stringa (10c), che può interpretare correttamente
gli spazi bianchi e gli 0 iniziali.

= /: controlla l'uguaglianza sugli elementi in un elenco (ogni coppia successiva).
Poiché esiste solo una coppia, restituisce un singolo booliano 0b / 1b.

T-SQL, 35 byte

Secondo i nostri standard , i dati vengono inseriti tramite una tabella preesistente tcon varcharcampi ae b.

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

Restituisce 1se corrispondono, in 0caso contrario.

Alcune delle funzioni matematiche di SQL (incluso ABS, FLOORe CEILING) eseguiranno una conversione implicita in valori numerici se dati parametri stringa, questo è più breve di un esplicito CAST(a AS INT)o CONVERT(INT,b), e funziona in questo caso poiché sappiamo che i valori di input sono sempre positivi.

IIF è specifico per MS SQL 2012 e versioni successive, quindi nessuna garanzia su altre implementazioni.

Excel VBA, 27 16 byte

-9 Grazie a @Nayrb e @TaylorScott

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

Dove si inseriscono i valori nelle celle con 'string.

Dove xe ysono le stringhe di input ed zè un output booleano.

Se CInt (x) = CInt (y) Quindi z = 1

Utilizzando CInt

R , 28 27 byte

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

Legge i numeri come stringhe, li converte in doppi e verifica se la loro differenza non è zero.

Provalo online!

−1 byte grazie a Giuseppe

Lua , 20 byte

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

Provalo online!

Haskell , 20 byte

-11 byte grazie a Laikoni. -2 byte grazie a Zgarb.

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

Provalo online!

Gema , 21 personaggi

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

Nessun booleano a Gema. Come il @get-switch{}/@set-switch{} funzioni usano 0 e 1 per rappresentare gli stati degli interruttori, usate anche 0 e 1.

Le 2 stringhe vengono passate su righe di input separate.

Esecuzione di esempio:

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 byte

$_=$_==<>

provalo online

Impilato , 8 byte

[#~\#~=]

Provalo online!

Spiegazione

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

Attache , 11 byte

Same@Map&:N

Provalo online!

Questo richiede una serie di stringhe, come ad esempio V["0001", "1 "]. Detto semplicemente, Map&:Nè una funzione che si associa Nal suo argomento e Sameverifica che l'array contenga solo membri uguali. (Curiosità: questa funzione funziona per più di 2 argomenti di stringa.)

SNOBOL4 (CSNOBOL4) , 42 byte

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

Provalo online!

Output 1 per verità, niente per falsità. Poiché (spazio) è l'operatore di concatenazione in SNOBOL, EVALl' inging un numero con spazi iniziali / finali produce il numero stesso e si occupa anche ordinatamente di tutti gli zeri iniziali. EQtest per l'uguaglianza numerica, impostando condizionalmente OUTPUTa 1 su Success.

Sinclair ZX81 / Timex TS1000 / 1500 BASIC, ~ 29 byte BASIC tokenizzati

Nuova soluzione grazie a Neil (grazie per la punta).

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

Questa soluzione richiede l'input dell'utente, quindi inserisci due stringhe con spazi bianchi e / o zeri iniziali o inserisci due stringhe di valore numerico non uguale; 0è falso ed 1è vero una volta che la riga tre ha confrontato il valore di ogni stringa immessa.

Vecchia soluzione: Sinclair ZX81 / Timex TS1000 / 1500 BASIC, ~ 46 byte BASIC tokenizzati

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

Il controllo effettivo viene eseguito nella riga tre, che è solo ~ 16 byte BASIC tokenizzati; quindi inserendo ciascuna coppia di test case usando la modalità diretta si risparmierà ~ 30 byte dall'elenco. Si noti che questo conteggio di byte non include il var stack.

APL (NARS2000) , 7 byte

=⍥⍎

Bene, sì, so che NARS2000 non può competere su Dyalog qui poiché usa Unicode, ma ho pensato che avrei preferito mettermi in mostra ⍥(chiamato Composizione in NARS2000, anche se in realtà non è correlato alla composizione delle funzioni), qualcosa che Dyalog non ha come built-in e non ho mai visto usato qui. In Dyalog, deve essere implementato come {(⍵⍵⍺)⍺⍺⍵⍵ ⍵}. Ciò che fa è chiamare la funzione monadica dell'operando destro sull'argomento sinistro e destro, quindi chiamare la funzione diadica dell'operando sinistro sui risultati.

Qui, l'operando di destra è ⍎( Esegui , cioè eval) e l'operando di sinistra è =( Uguale a , cioè controlla se i suoi argomenti sono uguali).