Emette il numero intero mancante


34

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

5
@riker Sembra che si tratti di trovare un numero mancante in una sequenza. Questo sembra riguardare la ricerca di una cifra mancante da un set.
DJMcMayhem

10
@Riker Non penso che sia un duplicato, dato che la sfida collegata ha una sequenza strettamente crescente (di numeri potenzialmente multi-cifra), mentre qui è in ordine arbitrario.
AdmBorkBork,

3
Ciao Josh! Dato che nessun altro lo ha menzionato finora, ti indirizzerò alla Sandbox dove puoi pubblicare idee per le sfide future e ottenere un feedback significativo prima di pubblicare sul main. Ciò avrebbe aiutato a chiarire tutti i dettagli (come STDIN / STDOUT) e risolto il dilemma duplicato prima di ricevere i downgrade qui.
AdmBorkBork,

1
È un peccato che 9-x% 9 funzioni per qualsiasi cifra tranne 0. Forse qualcuno più intelligente di me troverà un modo per farlo funzionare.
Bijan,

2
Diverse risposte accettano un numero intero come input di funzione. È permesso?
Dennis,

Risposte:


36

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


7
32043 può essere modificato in un numero più bello. 99066 è centro-simmetrico (non cambia se ruotato di 180 gradi attorno al centro) o forse 97779 (palindromo, due cifre distinte)
Sarge Borsch

1
Se l'OP consente di stampare il numero due volte, è 764**4possibile salvare due byte.
Tito

@Titus 764**4manca 5, 8e9
Rod

1
Errore di battitura ... intendevo 763**4=338920744561
Titus

25

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.


2
Puoi spiegare perché funziona?
KarlKastor,

1
@KarlKastor, il modulo 15 nella base 16 funziona analogamente al modulo 9 nella base 10. Modulo base-1 è costante quando si sommano le cifre, solo perché 10 ≡ 1 (mod base-1). La somma di tutte le cifre possibili è costante, quindi la cifra mancante è la differenza tra questa costante e il numero di input (modulo base-1).
Mik,

16

APL (Dyalog) , 4 byte

Funzione derivata

D∘~

⎕DD igits

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

~ tranne [l'argomento]

Provalo online!


Treno di funzioni

D~⊢

⎕DD igits

~ tranne

 l'argomento giusto

Provalo online!


Programma esplicito

D~⍞

⎕DD igits

~ tranne

 input di caratteri

Provalo online!


12

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.


Come funziona?
Pavel,

@ ГригорийПерельман Spiegazione aggiunta!
Wheat Wizard

2
Se si sposta negative(sum(input()))alla fine, è possibile abusare del nilad dell'altezza dello stack per spingere 525 più facilmente. (([][][]()()()){()()({}[()])}{}[{{}}])dovrebbe salvarti 10 byte
DJMcMayhem

30 byte sottraendo invece 477
Jo King

12

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!


10

Gelatina , 3 byte

ØDḟ

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

Provalo online!


3
Mi piace il modo in cui tutti i linguaggi del golf (e anche alcuni linguaggi non del golf) utilizzano lo stesso algoritmo, ma Jelly riesce ad avere i nomi più brevi per i builtin che utilizza e il meno boilerplate per invertire gli argomenti .

1
@ ais523 APL è lo stesso lettera per lettera (tranne che sarebbe uno snippet APL anziché una funzione / programma): Ø= , D= D, = ~, come in ⎕D~'867953120'.
Adám,

3
Io, mentre scorro le risposte: "Sto predicendo 3 personaggi in Jelly". Bingo. : ^ D
DLosc

9

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

9

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>


s=>eval([1,...s].join`^`)salva un byte.
Neil,

@Neil ... ed è anche molto più interessante
edc65,

Sento che questo suggerimento è arrivato sospettosamente poco dopo la mia risposta : D comunque bello golf +1.
Christoph,

1
@Christoph Beh, sembrava che volessi spargere la voce ...
Neil,

@Neil assolutamente :) Bello vedere che mi ha aiutato!
Christoph,

8

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

La prima riga della seconda risposta può essere giusta ..
Neil,

È possibile salvare alcuni byte utilizzando la deduplicazione anziché la sostituzione: Provalo online
Business Cat

Oh bene, ed ecco che ho appena ricevuto la seconda risposta fino al vecchio conteggio dei byte della prima risposta ...^ 5 ^. $*9¶ . $*_ +`_¶_ _
Neil

@Neil l'ho preso per uno in meno rispetto all'originale.
Riley,

(Eh, sembra sospettosamente simile alla mia risposta, l'unica differenza è che sei passato da _a 1per salvare un byte.)
Neil


6

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.


s=>[...s].map(c=>r-=c,r=45)|r;-)
ETHproductions

3
Sei troppo innamorato di reduce. +1 comunque
edc65,

@Arnauld Non vedo che funziona quando s[0]!='0', ma c'è già una risposta che utilizza eval.
Neil,

Potresti farlo s=>(15-`0x${s}`%15)%15?
Arnauld,

@Arnauld Bah, e l'avevo già fatto anche per il porto di Batch ...
Neil

6

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.



5

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.


5

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.


Bello, non ho pensato di tagliare. Valori alternativi32043,32286,33144,35172,35337,35757,35853,37176,37905,38772,39147,39336,40545,42744,43902,44016,45567,45624,46587,48852,49314,49353,50706,53976,54918,55446,55524,55581,55626,56532,57321,58413,58455,58554,59403,60984,61575,61866,62679,62961,63051,63129,65634,65637,66105,66276,67677,68763,68781,69513,71433,72621,75759,76047,76182,77346,78072,78453,80361,80445,81222,81945,83919,84648,85353,85743,85803,86073,87639,88623,89079,89145,89355,89523,90144,90153,90198,91248,91605,92214,94695,95154,96702,97779,98055,98802,99066
Jörg Hülsermann

5

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.

4

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

3

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

3

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

3

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

xl'implementazione è vecchia e buggy, motivo per cui è necessario .
Fatalizza il

In realtà puoi argomentare che qualcosa del genere ¬∋ℕdovrebbe funzionare solo in 3 caratteri - questo è quello che ho provato prima - ma ci sono molte ragioni per cui non lo fa, e non penso che ci sia un modo plausibile per cambiare Brachylog in modo che lo faccia.

Avere un ¬∋ℕlavoro del genere non è nemmeno possibile in Prolog, a meno che non si stia programmando specificamente ciò che si intende per non not in. ¬in Brachylog è equivalente a \+in Prolog, e il suo significato è quello di "non dimostrabile sotto il presupposto del mondo chiuso", piuttosto che "dammi punti di scelta per tutto ciò che non lo verifica" (che è quasi sempre un numero infinito di cose )
Fatalizza il

L'unico modo per farlo in Prolog sarebbe "etichettare" l' anticipo, ma ciò significherebbe armeggiare con l'ordine di valutazione di Brachylog basato sul contenuto dei predicati. Questo è solo uno dei problemi che ha, però; ce ne sono molti altri.

3

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.


3

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.



3

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!


Se avessi spostato lo spazio prima del $1, sarebbe più ovvio ...
Neil

@Neil, sì, è una bella idea! Grazie !
Zeppelin,

È possibile utilizzare seqinvece di echo: seq 0 9|tr -d \\n$1
Riley

3

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:

inserisci qui la descrizione dell'immagine


Il numero 2 ^ 29 ha tutte le cifre tranne 4, quindi 33 byte: = REGEXEXTRACT (4 & 2 ^ 29, "[^" & A4 & "]")
Steve Kass

@SteveKass Nice. =REGEXEXTRACT(0&49^9,"[^"&A1&"]")è anche una soluzione valida, data una logica simile. Risposta aggiornata.
Grant Miller,

3

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

2

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.



2

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.


2

05AB1E , 5 byte

žhISK

Provalo online!

Spiegazione

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

6
Mi piace perché puoi dirlo ad alta voce. '"žhISK", gridò, mentre agitava la bacchetta sopra il cappello a cilindro e un piccolo coniglio bianco apparve in uno sbuffo di fumo'.
Penguino,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.