Questa è una sfida per poliziotti e ladri . Per il thread della polizia, vai qui .

Questa sfida prevede due sequenze OEIS scelte dai poliziotti - S ₁ , S ₂ - e quanto bene queste sequenze possono essere giocate a golf e offuscate.

I poliziotti stanno costruendo il codice A che produce S ₁ e danno un numero X che sostengono sia la migliore distanza di Levenshtein possibile (in caratteri) per creare B che produce S ₂ .

La sfida dei ladri

Per infrangere l'invio di un particolare poliziotto, i ladri devono inventare un programma C nella stessa lingua (e versione) della risposta che produce S ₂ (n) e che il carattere Y cambia da A (con Y <= X). I ladri non hanno necessariamente bisogno di trovare esattamente lo stesso codice B che il poliziotto (segretamente) ha prodotto. Le osservazioni dei ladri devono aderire allo stesso indice 0 o 1 come specificato dall'invio del poliziotto.

Se lo gestisci, pubblica una risposta con la soluzione, collegandoti alla risposta del poliziotto e lascia un commento sulla risposta del poliziotto che rimanda alla tua.

Ogni risposta del poliziotto può essere decifrata una sola volta e, naturalmente, non ti è permesso di decifrare la tua risposta. Se la risposta del poliziotto risulta non valida prima o dopo il crack, non viene conteggiata per il punteggio del ladro.

Vincere e segnare

Ai ladri viene assegnato un punteggio (X - Y)*5 + 5per ciascuna delle loro fessure e vince il ladro con il punteggio complessivo più alto.

Ulteriori regole

• Non è necessario utilizzare alcun built-in per hashing, crittografia o generazione di numeri casuali (anche se si esegue il seeding del generatore di numeri casuali su un valore fisso).
• Sono consentiti programmi o funzioni, ma il codice non deve essere uno snippet e non è necessario assumere un ambiente REPL.
• Puoi prendere input e dare output in qualsiasi formato conveniente . I metodi di input / output devono essere gli stessi per entrambe le sequenze.
• Il calcolatore definitivo per la distanza Levenshtein per questa sfida è questo sul Pianeta Calc.
• Oltre ad essere una sfida CnR, si tratta di code-golf, quindi si applicano tutte le normali regole del golf.

Pyke, Levenshtein distanza di 1, A036487 , A135628 - punteggio 5

Crepa di un'entrata da muddyfish

wX*e

Provalo qui!

Il codice originale, X*e, piazze ingresso, Xmoltiplica che dall'ingresso *, e dimezza quindi il risultato pavimenti, e.

Il trucco è che 'X'56 nella rappresentazione base 96 di w, quindi wXproduce 56, moltiplicalo per l'input, quindi il pavimento e la metà e ottieni 28 volte l'input secondo necessità.

Brain-Flak , 28 byte, Distanza di 4, A002817 , A090809

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

Questa risposta è stata scoperta con l'aiuto di un bruto-forcer, che ha generato 35.000 possibili programmi (molti di loro erano sbilanciati e quindi un codice non valido per il cervello, ma ho trovato il bug e ho trovato la risposta comunque). Questo era circa il 20 millesimo programma testato, e ci sono voluti circa un'ora per trovare (anche se non so esattamente da quanto tempo ero via quando è finito).

Non volevo ancora pubblicare questa risposta, dal momento che non ho ancora una piena comprensione di come funziona questo programma. Tuttavia, la risposta sta per essere sicura, quindi non voglio che scada. Spero di aggiornare di più questa risposta dopo averlo compreso appieno, oltre a pubblicare il codice che ho usato per trovare questa risposta. Ma per ora, posterò solo una spiegazione parziale.

#Push the sum of:
(

    #The (n-1)th triangular number, and the range [1, n] (The range doesn't count towards the sum I believe)
    ({(({})[()])}{})

    #Triangulate every number on the stack
    {{({}[()])}{}}

)

Questo ha senso perché OEIS afferma:

Per n> 0, i termini di questa sequenza sono correlati ad A000124 da a (n) = sum (i * A000124 (i), i = 0..n-1). [Bruno Berselli, 20 dic 2013]

E A000124 sono i numeri triangolari + 1. Tuttavia, non so esattamente cosa sia il forumla, quindi non posso spiegare completamente come funziona.

Perl 6, 19 byte, X = 1, A000045 → A000035

{(0,1,*+<*...*)[$_]}

+>al posto di +<avrebbe funzionato anche.

Provalo online!

Come funziona

infix ... è abbastanza utile per semplici sequenze ricorsive. La (0,1,*+*...*)parte del codice originale, che è una scorciatoia per

(0, 1, -> $x, $y { $x + $y } ... *)

specifica una sequenza che inizia con 0 e 1 , quindi aggiunge elementi calcolando la somma dei due precedenti elementi della sequenza.

Al contrario, (0,1,*+<*...*)usa il bit-shift sinistro (anche il bit-shift +>destro funzionerebbe) per costruire la sequenza di parità. Poiché lo spostamento di 1 unità zero a sinistra è 1 e lo spostamento di 0 un'unità a sinistra è 0 , otteniamo i modelli alternati desiderati di uno e zero.

Perl 6 , 10 byte, distanza 1 - punteggio 5

Crepa di una voce di smls

*[0]o 1***

diventa:

*[0]o 1*+*

Provalo online!

Perl 6 , distanza 2, smls

Originale:

+(*%%2)

Crepa:

+(*+0%2)

Provalo online!

WolframAlpha, Distanza 1, Greg Martin , A002378 , A000537

(sum1to#of n^1)^2&

Come funziona

Mi sono reso conto che in modo interessante, (n * (n + 1) / 2) ^ 2 è una formula per la seconda sequenza. Dato che la somma (da 1 a n) equivale a n * (n + 1) / 2, ho dovuto solo passare da * a a ^.

Brain-Flak , 20 byte, DJMcMayhem

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

Provalo online!

Aggiunto ({})a all'inizio del ciclo per raddoppiare il valore in ogni iterazione.

JavaScript, Distanza 4, LliwTelracs

Originale:

f=x=>{return x?2*x-1+f(x-1):0}

Crepa:

f=x=>{return x?2*(-0+f(x-1)):1}

Provalo online!

JavaScript (ES6), Distanza 1, Advancid

Originale:

as=function(){ return 2*2**((11)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}

Crepa:

as=function(){ return 0*2**((11)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}

Provalo online!

o

as=function(){ return 2*1**((11)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}

Provalo online!

In qualche modo sono stato in grado di farlo comportare diversamente tra TIO e repl.it (assolutamente nessun indizio perché 2 * 1 ^ ... sarebbe uguale a 0 come secondo repl.it)

Javascript, 41 byte, Distanza di 3, A061313, A004526

f=x=>{return x>>1;0?x%2?f(x+1)+1:f(x/2)+1:0}

Provalo online!

Java, Distanza 4, Peech , A094683 , A000290

Originale:

int x{double r=1;for(int i=0;i<42;i++)r=r/2+n/r/2;int k=(int)((int)n*(float)n/Math.pow(n,(Math.sin(n)*Math.sin(n)+Math.cos(n)*Math.cos(n))/2));return n%4%2==(int)Math.log10(Math.E)/Math.log((double)'H'-'@')?(int)r:k;}

Crepa:

int x{double r=1;for(int i=0;i<42;i++)r=r/2+n/r/2;int k=(int)((int)n*(float)n/Math.pow(n,(Math.sin(n)*Math.sin(n)+Math.cos(n)*Math.cos(n))/2));return n%4%1==(int)Math.log10(Math.E)/Math.log((double)'H'-'@')?(int)n*n:k;}
                                                                                                                                                          ^                                                         ^^^

restituisce n * n

Javascript, Advancid , distanza di 2, A059841 e A000004

Lasciare il codice dietro il collegamento TIO solo perché sembra infrangere il sito.

Grazie a @nderscore, il cui codice ho usato per decrittografare il codice iniziale

C'era del codice ridondante come usare !! [] + [] + [] invece di !! [] + [].

L'aggiunta di! + [] - (! + []) (+ 1-1) inizialmente ha impedito la decodifica.

Provalo online

Pyke, Levenshtein distanza 2, A008788, A007526

'SS^

Provalo qui!

Come funziona

Questo fa una conversione di base mista.

'Sprende l'ingresso n e si applica, premendo [1, ..., n] sulla pila. Il successivo Sprende l'ingresso n e spinge ancora una volta lo stesso array. 'sembra causare il comando successivo da applicare al precedente precedente nello stack; Sono un po 'sfocato sui dettagli.

Infine, ^applica la conversione di base mista, quindi [1, ..., n] [1, ..., n] f calcola
a (n): = [1] n + n + (n) (n-1) .. . + [n!] 1 dove le parentesi indicano il valore del luogo e il numero alla loro destra la cifra.

Ora, a (n) = (1 + (1) (n-1) + (n-1) (n-2) (n-3) + ... + (n-1)!) N = n ( a (n) + 1) , che è la stessa formula ricorsiva che definisce a (n) in [A007526]. Poiché una somma vuota è zero, a (0) = 0 e anche il caso base corrisponde.