Ti verrà data una stringa. Conterrà 9 numeri interi univoci da 0-9. È necessario restituire il numero intero mancante. La stringa apparirà così:

123456789
 > 0

134567890
 > 2

867953120
 > 4

Python 2 , 18 16 byte

^{+ bellezza grazie a @Sarge Borsch}

`99066**2`.strip

Provalo online!

99066**2 è solo un modo più breve per generare una stringa che contiene 0 ~ 9

Python , 22 byte

lambda s:-int(s,16)%15

Provalo online!

Una soluzione aritmetica. Interpreta la stringa di input come esadecimale, la nega e prende il risultato modulo 15.

APL (Dyalog) , 4 byte

Funzione derivata

⎕D∘~

⎕D D igits

∘ (lega un argomento di sinistra alla seguente funzione diadica per creare una funzione monadica)

~ tranne [l'argomento]

Provalo online!

Treno di funzioni

⎕D~⊢

⎕D D igits

~ tranne

⊢ l'argomento giusto

Provalo online!

Programma esplicito

⎕D~⍞

⎕D D igits

~ tranne

⍞ input di caratteri

Provalo online!

Brain-Flak , 48 38 36 + 3 = 39 byte

10 byte salvati grazie a DJMcMayhem!

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

Provalo online!

Spiegazione

La somma di tutte le cifre in Ascii è 525. Questo programma riassume l'input e lo sottrae da 525 per ottenere la cifra mancante.

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

Spingerà 525. Questo sfrutta il fatto che sappiamo che ci saranno 9 elementi di input per cominciare. Ciò significa che []valuta 9, il che ci consente di raggiungere rapidamente numeri grandi come 525.

Quindi abbiamo il bit:

                             [{{}}]

che riassumerà gli input e lo sottrarrà dal totale.

Haskell , 24 23 byte

(477-).sum.map fromEnum

Provalo online! Uso: (477-).sum.map fromEnum $ "123456890". 477 è la somma dei codici dei caratteri delle cifre da 1 a 9, escluso 0. Questa funzione anonima calcola 477 meno la somma di tutti i codici dei caratteri delle cifre per trovare quello mancante.

La conversione delle cifre dei caratteri in ints è un byte più lungo:

(45-).sum.map(read.pure)
foldl(\a b->a-read[b])45

Provalo online!

Gelatina , 3 byte

ØDḟ

Filtra semplicemente ( ḟ) la stringa di input da "0123456789" ( ØD).

Provalo online!

Ruby, 14

Somma i codici ascii e sottrae da 48 * 9 + 45

->s{477-s.sum}

Usa così

f=->s{477-s.sum}

puts f["123456789"]

JavaScript (ES6), 26

Modifica 1 byte salva thx @Neil, con un trucco molto più intelligente

L'azzeramento di tutti i valori da 1 a 9 fornisce 1. Xor 1 ancora una volta e il risultato è 0. Quindi, se manca un singolo valore, il risultato sarà il valore mancante.

s=>eval([1,...s].join`^`)

Test

f=s=>eval([1,...s].join`^`)

function go() {

  var i=I.value;
  O.textContent = f(i)
}  

go()

<input oninput='go()' value='012987653' id=I>
<pre id=O></pre>

Retina , 27 21 19 byte

-6 Grazie a Basic Sunset
-2 Grazie a Martin Ender

.
$*_5$*
+`_1|1_

1

Provalo online!

Sostituisci ogni cifra con tanti se _5 1s:

.
$*_5$*

Rimuovi tutte le _s e una 1per ognuna:

+`_1|1_ 

Contare il numero di 1s rimasti:

1

05AB1E , 6 byte

45¹SO-

Provalo online!

45     # Push 45
  ¹    # push input
   S   # Split
    O  # Sum
     - # Subtract (45 - sum)

JavaScript (ES6), 31 29 28 22 byte

s=>(15-`0x${s}`%15)%15

Porta della risposta di Python di @ xnor, tranne per il fatto che JavaScript ha solo un operatore residuo anziché un operatore modulo, quindi non posso farlo in un solo passaggio. Modifica: salvato 6 byte grazie a @Arnauld.

Brainfuck, 17 15 byte

-[-[->-<],]>++.

Provalo qui . Questa soluzione funziona solo su Brainfuck standard (celle a 8 bit), poiché si basa sull'avvolgimento.

È un giorno raro in cui Brainfuck può effettivamente competere, ma questa sfida è appena riuscita ad allinearsi abbastanza bene con le specifiche BF!

Invece di abbattere direttamente questa risposta, vorrei passare attraverso le iterazioni che ho preso, perché penso che sarebbe più comprensibile (e più interessante).
Nota: questa soluzione è ispirata in gran parte dalla risposta Brain-Flak di Wheat Wizard .

Spiegazione

Passaggio 1, 26 byte

Nella sua risposta, Wheat Wizard ha sottolineato che la somma dei valori ASCII da 0-9 a 525. E poiché lo standard Brainfuck ha solo una nozione di [0,255], questo rende il valore 525% 256 = 13 . Vale a dire, sottraendo i valori ASCII dell'input da 13 si ottiene la cifra mancante.

La prima versione di questo programma era:
1. Inserisci 13 nella prima cella
2. Prendi input nella seconda cella
3. Sottrai la seconda cella dalla prima cella
4. Vai a 2 se ci sono input rimanenti
5. Stampa la prima cella

Ed ecco il codice per la soluzione semplice:

+++++++++++++ #Set the first cell to 13  
>,            #Take inputs into the second cell  
[[<->-],]     #Subtract the second cell from the first cell and repeat until inputs are over  
<.            #Print the first cell  

Passaggio 2, 19 byte

Come sottolineato nella sua risposta, poiché sappiamo che l'input avrà esattamente la lunghezza 9, possiamo usare quel valore come costante ed eliminare quella lunga stringa di + all'inizio.
Inoltre, non importa a che punto aggiungeremo 13 (grazie, proprietà commutativa!), Quindi lo mescoleremo con le fasi di sottrazione e stampa.

,        #Take input to enter the loop
[[->-<], #Subtract the first cell from the second cell 
>+<]     #Add 1 for each input; totaling 9
>++++    #Add the missing 4 to make 13
.        #And print

Questa era la mia risposta originale a questo problema, ma possiamo fare di meglio.

Passaggio 3, 17 byte

È interessante notare che la risposta precedente funziona anche se iniziamo con un + anziché un,

+[[->-<],>+<]>++++.

Brainfuck aveva bisogno di qualcosa in una cella per iniziare un ciclo. Abbiamo aggiunto ingenuamente quel extra 4 alla fine, quando avrebbe potuto andare in altri posti.

-[[->-<],>+<]>++.

Con alcuni stratagemmi di loop totalmente intenzionali (leggi: prova ed errore), l'avvio del programma con un - porta a due risultati interessanti:

1. Uno viene aggiunto alla seconda cella (salvando 1 byte alla fine).
2. I loop vengono eseguiti un ulteriore tempo, per un totale di 10 anziché 9 (salvando un altro 1 byte).

1 + 10 + 2 = 13 e finiamo con la risposta originale.

Ripensandoci, questo è probabilmente uno scritto eccessivo per un programma Brainfuck così semplice.

Passaggio 4, 15 byte

Dopo aver pensato a questa soluzione un po 'di più, sono stato in grado di tagliare 2 byte.

Volevo chiarire qualcosa sul passaggio precedente:
il meno per entrare nel loop aggiunge effettivamente 1, ma quello che sta effettivamente facendo è sottrarre 255 dalla seconda cella (risultante in 1).

È ovvio in retrospettiva, ma sottrarre 1 dalla prima cella equivale ad aggiungere 1 alla seconda cella (perché tutto nella prima cella viene sottratto dalla seconda cella).

-[-[->-<],]>++.

Sono stato in grado di rimuovere "> + <" aggiungendo un "-" all'inizio del primo ciclo. Deve andare lì, e non dove si trovava "> + <", perché altrimenti il ​​programma eseguirà un ciclo infinito.

Ottava , 22 byte

@(x)setdiff('0':'9',x)

Provalo online!

Mathematica, 25 byte

477-Tr@ToCharacterCode@#&

Funzione pura che accetta una stringa come input e restituisce un numero intero. Mathematica ha nomi di comandi lunghi ed è riluttante a convertire tra stringhe e numeri interi, il che rende particolarmente difficile questa sfida. Il migliore che ho trovato è stato l'algoritmo della risposta Ruby di Level River St , che esegue un calcolo basato sul totale dei codici ASCII della stringa di input; in Mathematica, utilizza solo un nome di comando lungo.

PHP, 27

<?=trim(32043**2,$argv[1]);

usa il trucco della risposta di Rod per generare una stringa contenente tutte le cifre, quindi rimuove tutte le cifre tranne quella mancante.

PHP, 41

for($b=1;$i<9;$b^=$argv[1][$i++]);echo$b;

Questo usa xor perché non l'ho ancora visto.

Bash + coreutils, 19 byte

Ho trovato una soluzione bash più breve , che utilizza un approccio checksum interessante:

sum -s|dc -e524?--P

Provalo online!

Spiegazione:

Il sumcomando stampa un checksum e un conteggio dei blocchi. Non conosco molti dettagli, ma l'uso dell'opzione -s(algoritmo System V) renderà il checksum uguale alla somma ASCII di ciascun codice di carattere di input. Come tale, il checksum rimane costante quando cambia l'ordine degli stessi caratteri di input.

Dato 867953120come test case (ultimo esempio), ecco come funziona lo script:

• sum -suscite 473 1. Se non mancasse alcun numero intero, il checksum sarebbe stato 525.
• dc -e524?spinge 524 e quindi l'ingresso del tubo. Lo stack è: 1 473 524. L'idea è di sottrarre il checksum da 525, ma dato che anche la somma degli output 1, devo lavorarci sopra.
• --P. Dopo aver applicato le due sottrazioni (524- (473-1)), lo stack è: 52. Con 'P' stampo il carattere con quel codice ASCII:, 4la cifra mancante.

Fortran 95, 146 128 byte

function m(s)
character(len=10)::s,t
t='0123456789'
do j=1,10
k=0
do i=1,9
if(s(i:i)==t(j:j))k=1
end do
if(k==0)m=j-1
end do
end

Non molto breve, temo.

Ungolfed:

integer function m(s)
    implicit none

    character(len=9)::s
    character(len=10)::t
    integer:: i, j, k

    t='0123456789'
    do j=1,10
        k=0
        do i=1,9
            if (s(i:i) == t(j:j)) k=1
        end do
        if (k==0) m=j-1
    end do

end function m

CJam , 5 byte

A,sq-

Provalo online!

A,     e# The range from 0 to 9: [0 1 2 3 4 5 6 7 8 9]
  s    e# Cast to a string: "0123456789"
   q   e# The input
    -  e# Remove all characters from the range that are in the input
       e# Implicit output

GNU sed , 36 byte

Include +1 per -r

s/$/0123456789/
:
s/(.)(.*)\1/\2/
t

Provalo online!

s/$/0123456789/ # Append 0123456789
:               # Start loop
s/(.)(.*)\1/\2/ # remove a duplicate character
t               # loop if something changed

Brachylog (2), 5 byte

ẹ:Ị↔x

Provalo online!

Probabilmente dovrebbe essere più breve (sono ancora confuso sul perché ẹsia necessario), ma questo è il meglio che potrei fare.

Spiegazione

ẹ:Ị↔x
ẹ      Split the input into a list of characters
 :Ị    Pair that list with the string "0123456789"
   ↔x  Remove all elements of the list from the string

Lisp comune, 47 byte

(lambda(s)(- 45(reduce'+ s :key'digit-char-p)))

Ungolfed:

(lambda (s) (- 45 (reduce '+ s :key 'digit-char-p)))

spiegazione:

(reduce '+ s :key 'digit-char-p)

Questo scorre attraverso i caratteri s, li converte in cifre e li aggiunge. Digit-char-p, convenientemente, restituisce il numero del carattere come il suo valore "vero", quindi può essere usato come test o conversione.

(- 45 ...)

Sottrai da 45 restituisce la cifra mancante nell'input.

Cubix , 18 byte

5v&;52/ni?@.>!&oW+

allargato

    5 v
    & ;
5 2 / n i ? @ .
> ! & o W + . .
    . .
    . .

Provalo qui

Utilizza lo stesso tipo di metodo di questa risposta da sclerosi cerebrale .

Crea il valore -525 nello stack premendo 5, 2, concatena, premi 5, concatena e annulla.
Quindi ottenere ripetutamente l'input e aggiungerlo fino alla fine dell'input.
Rimuovi l'ultimo input, annulla (rendi positivo) l'ultimo risultato aggiunto, stampa il carattere e ferma.

La ragione per lavorare da -525 in su è che l'output dei caratteri viene colpito per ogni iterazione di input. Poiché il valore è negativo, non viene emesso nulla finché non viene chiuso il loop e il valore negativo viene reso positivo.

PHP, 37 byte

<?=45-array_sum(str_split($argv[1]));

Bash (+ utility), 22, 19 byte

• Usa seqinvece di espansione parentesi, -3 byte (Thx @Riley!)

seq 0 9|tr -d \\n$1 

Test

$seq 0 9|tr -d \\n123456789
0

Provalo online!

Fogli Google, 39 33 byte

L'input è inserito nella cella A1.

Codice:

=REGEXEXTRACT(4&2^29,"[^"&A1&"]")

6 byte salvati grazie a Steve Kass.

Codice precedente:

=REGEXEXTRACT("0123456789","[^"&A1&"]")

Risultato:

Befunge 98, 14 12 byte

Ho salvato 1 byte spostando il programma su 1 riga e 1 byte facendo un po 'di matematica migliore

~+;@.%a--7;#

Provalo online!

Spiegazione

La somma dei valori ASCII varia da 477 a 468 a seconda del numero mancante. Sottraendo questo da 7, otteniamo l'intervallo da -470 a -461. Modificando questo numero per 10, otteniamo l'intervallo 0-9, che possiamo quindi stampare.

~+;       ;#    Sums the ASCII values of all characters to stdIn
~          #    The # doesn't skip over the ~ because it's on the end of a line
~               Once EOF is hit, the ~ reverses the IP's direction
          ;#    Jump the ; that was used before
       --7      Subtract the sum from 7 (really just 0 - (sum - 7))
     %a         Mod it by 10
   @.           Print and exit

Il motivo per cui utilizzo i valori ASCII invece di prendere l'input intero è perché il &comando in Try it Online si interrompe su EOF (anche se dovrebbe invertire l'IP). Il ~funziona correttamente, però.

Vecchio programma , 14 byte

#v~+
@>'i5*--,

La somma dei valori ASCII di tutte e 10 le cifre è 525. Sottraendo la somma delle cifre fornite da 525, otteniamo il valore ASCII del carattere mancante.

#v~+         Sums the ASCII values of all characters on stdIn
             Moves to the next line when this is done
 >'i5*       Pushes 525 (105 * 5)
      --     Subtracts the sum from 525
@       ,    Prints and exits

PowerShell , 30 byte

param($n)0..9|?{$n-notmatch$_}

Provalo online!

Accetta input $n, costruisce un intervallo 0..9(cioè, 0, 1, 2 ... 9), quindi usa una Where-Objectclausola (il |?{...}) per estrarre il numero che regex -notmatch. Rimane in cantiere, l'output è implicito.

Röda , 28 byte

{(_/"")|ord _|sum|chr 525-_}

Provalo online!

Pyth, 5 byte

-jkUT

Provalo!

spiegazione

-jkUT
    T   # 10
   U    # The unary range of ten: [0,1,..,9]
 jk     # join that on the empty string
-       # set minus

"-jUT" funziona in qualche modo, ma produce nuove righe per ogni int.

05AB1E , 5 byte

žhISK

Provalo online!

Spiegazione

žh     # from the string "0123456789"
    K  # remove
  IS   # each digit of the input