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
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
Risposte:
+ bellezza grazie a @Sarge Borsch
`99066**2`.strip
99066**2
è solo un modo più breve per generare una stringa che contiene 0 ~ 9
764**4
possibile salvare due byte.
764**4
manca 5
, 8
e9
763**4
=338920744561
lambda s:-int(s,16)%15
Una soluzione aritmetica. Interpreta la stringa di input come esadecimale, la nega e prende il risultato modulo 15.
⎕D∘~
⎕D
D igits
∘
(lega un argomento di sinistra alla seguente funzione diadica per creare una funzione monadica)
~
tranne [l'argomento]
⎕D~⊢
⎕D
D igits
~
tranne
⊢
l'argomento giusto
⎕D~⍞
⎕D
D igits
~
tranne
⍞
input di caratteri
10 byte salvati grazie a DJMcMayhem!
((([]())[]{}){()()({}[()])}{}[{{}}])
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.
negative(sum(input()))
alla fine, è possibile abusare del nilad dell'altezza dello stack per spingere 525 più facilmente. (([][][]()()()){()()({}[()])}{}[{{}}])
dovrebbe salvarti 10 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
ḟ
.
Ø
= ⎕
, D
= D
, ḟ
= ~
, come in ⎕D~'867953120'
.
Somma i codici ascii e sottrae da 48 * 9 + 45
->s{477-s.sum}
Usa così
f=->s{477-s.sum}
puts f["123456789"]
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.
-6 Grazie a Basic Sunset
-2 Grazie a Martin Ender
.
$*_5$*
+`_1|1_
1
Sostituisci ogni cifra con tanti se _
5 1
s:
.
$*_5$*
Rimuovi tutte le _
s e una 1
per ognuna:
+`_1|1_
Contare il numero di 1
s rimasti:
1
.
.
^
5
^.
$*9¶
.
$*_
+`_¶_
¶
_
_
a 1
per salvare un 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
;-)
reduce
. +1 comunque
s[0]!='0'
, ma c'è già una risposta che utilizza eval
.
s=>(15-`0x${s}`%15)%15
?
-[-[->-<],]>++.
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 .
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
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.
È 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 + 10 + 2 = 13 e finiamo con la risposta originale.
Ripensandoci, questo è probabilmente uno scritto eccessivo per un programma Brainfuck così semplice.
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.
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.
<?=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.
32043,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
Ho trovato una soluzione bash più breve , che utilizza un approccio checksum interessante:
sum -s|dc -e524?--P
Spiegazione:
Il sum
comando 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 867953120
come test case (ultimo esempio), ecco come funziona lo script:
sum -s
uscite 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:, 4
la cifra mancante.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
A,sq-
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
Include +1 per -r
s/$/0123456789/
:
s/(.)(.*)\1/\2/
t
s/$/0123456789/ # Append 0123456789
: # Start loop
s/(.)(.*)\1/\2/ # remove a duplicate character
t # loop if something changed
ẹ:Ị↔x
Probabilmente dovrebbe essere più breve (sono ancora confuso sul perché ẹ
sia necessario), ma questo è il meglio che potrei fare.
ẹ:Ị↔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
x
l'implementazione è vecchia e buggy, motivo per cui è necessario ẹ
.
¬∋ℕ
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.
¬∋ℕ
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 )
(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.
5v&;52/ni?@.>!&oW+
allargato
5 v
& ;
5 2 / n i ? @ .
> ! & o W + . .
. .
. .
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.
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:
=REGEXEXTRACT(0&49^9,"[^"&A1&"]")
è anche una soluzione valida, data una logica simile. Risposta aggiornata.
Ho salvato 1 byte spostando il programma su 1 riga e 1 byte facendo un po 'di matematica migliore
~+;@.%a--7;#
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ò.
#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
param($n)0..9|?{$n-notmatch$_}
Accetta input $n
, costruisce un intervallo 0..9
(cioè, 0, 1, 2 ... 9
), quindi usa una Where-Object
clausola (il |?{...}
) per estrarre il numero che regex -notmatch
. Rimane in cantiere, l'output è implicito.
-jkUT
-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.