Questa è una sfida di poliziotti e ladri. Questo è il filo del ladro. Il thread del poliziotto è qui .

I poliziotti sceglieranno qualsiasi sequenza dall'OEIS e scriveranno un programma p che stampa il primo intero da quella sequenza. Essi potranno anche trovare qualche stringa s . Se si inserisce s da qualche parte in p , questo programma deve stampare il secondo numero intero dalla sequenza. Se si inserisce s + s nella stessa posizione in p , questo programma deve stampare il terzo intero dalla sequenza. s + s + s nella stessa posizione stamperà il quarto, e così via e così via. Ecco un esempio:

Python 3, sequenza A000027

print(1)

La stringa nascosta è di due byte .

La stringa è +1, poiché il programma print(1+1)stamperà il secondo numero intero in A000027, il programma print(1+1+1)stamperà il terzo numero intero, ecc.

I poliziotti devono rivelare la sequenza, il programma originale p e la lunghezza della stringa nascosta s . I ladri decifrano un invio trovando qualsiasi stringa fino a quella lunghezza e la posizione in cui inserirla per creare la sequenza. La stringa non deve necessariamente corrispondere alla soluzione prevista per essere un crack valido, né la posizione in cui è inserita.

Se cracchi una delle risposte della polizia, pubblica la tua soluzione (con la stringa nascosta e la posizione rivelate) e un link alla risposta. Quindi commenta la risposta della polizia con un link al tuo crack qui.

Regole

• La soluzione deve funzionare per qualsiasi numero nella sequenza, o almeno fino a un limite ragionevole in cui non riesce a causa di restrizioni di memoria, overflow di interi / stack, ecc.

• Il ladro vincente è l'utente che fa il maggior numero di invii, con il tiebreaker che ha raggiunto per primo quel numero di crepe.

• Il poliziotto vincente è il poliziotto con la stringa più corta s che non è spezzata. Tiebreaker è il p più breve . Se non ci sono invii non crackati, il poliziotto che aveva una soluzione non crackata per le vittorie più lunghe.

• Per essere dichiarata sicura, la soluzione deve rimanere senza crack per 1 settimana e quindi mostrare la stringa nascosta (e la posizione per inserirla).

• s non può essere nidificato, deve essere concatenato end-to-end. Ad esempio, se s è stato 10, ogni iterazione andrebbe 10, 1010, 101010, 10101010...piuttosto che10, 1100, 111000, 11110000...

• Tutte le soluzioni crittografiche (ad esempio il controllo dell'hash della sottostringa) sono vietate.

• Se s contiene caratteri non ASCII, è necessario specificare anche la codifica utilizzata.

Python 2 , sequenza A138147 di xnor

Originale:

print 10

Cracked:

print "1%s0"%10
      ^^^^^^^

Provalo online!

Brain-Flak , A000984 di Nitrodon

({({}<>({}))<>}<>){({}<>)<>}<>

Sono solo 30 byte, non sono sicuro di cosa avesse in mente Nitrodon.

Provalo online!

Spiegazione

Ho provato molte cose, ma ecco cosa ha funzionato. I termini di A000984 sono gli elementi centrali del triangolo di Pascal.

Ora ho capito che posso ottenerli sommando le diagonali sopra di loro:

Per esempio:

$1+3+6+10 = 20$

E poiché l'azione finale del programma di Nitrodon è quella di riassumere tutto ciò che sembrava un buon candidato (più come se avessi provato un sacco di cose ma questa ha finito per funzionare).

Quindi vogliamo un programma che prenda una somma parziale e produca il successivo. Fortunatamente esiste un modo piuttosto semplice per passare da uno di questi all'altro. Ogni riga è il delta della riga successiva. Che è il $n$ esimo termine in una fila è la differenza tra il $n$ ° e $n-1$ th termini nella riga successiva.

L'unico problema è che non abbiamo abbastanza dell'ultima riga per calcolare la riga che vogliamo. Poiché ogni riga è una più lunga dell'ultima se disponiamo di una riga, non possiamo ottenere l'ultimo membro della riga successiva con questo metodo. Comunque qui abbiamo un altro trucco, l'ultimo membro di ogni riga è uguale a tutti i membri precedenti di quella riga!

$1+3+6=10$

E se hai familiarità con Brain-Flak, questo dovrebbe sporgerti come qualcosa che sarà davvero facile da fare.

Ora per il codice:

Per iniziare facciamo il calcolo della riga successiva in cui ogni nuovo membro è la somma di due membri vecchi adiacenti. Questo può essere fatto con:

{({}<>({}))<>}<>

Il che fondamentalmente sposta un elemento sopra e aggiunge (senza cancellazione) ciò che mai era già in cima ad esso. Tuttavia, questo inverte tutto, quindi per la prossima volta che otteniamo una riga dobbiamo rimetterlo.

{({}<>({}))<>}<>{({}<>)<>}<>

Ora dobbiamo calcolare l'ultimo membro della riga. Come ho già detto, questo è semplicissimo. Dal momento che abbiamo avuto un ciclo su tutti gli elementi della riga, possiamo semplicemente prendere quella somma e spingerla. Lo spingiamo prima del secondo anello in modo che finisca sul fondo.

({({}<>({}))<>}<>){({}<>)<>}<>

E questo è tutto.

Brain-Flak, A000290 , di Sriotchilism O'Zaic

Originale:

((()))({}<>)

Cracked:

((()))({}([])[]<>)
         ^^^^^^

Provalo online!

In alternativa:

((())([])[])({}<>)
     ^^^^^^

Provalo online!

MATL , sequenza A005206 di Luis Mendo

Originale:

voOdoO

Provalo online!

Cracked:

voOdoOdNq17L/k
      ^^^^^^^^

Non sono un esperto MATL, ma da quello che ho capito, l'originale voOdoOcrea due array vuoti e un array [0]in pila. questo [0]è ciò che viene stampato senza parentesi come primo elemento della sequenza. Il crack / soluzione quindi effettua le seguenti operazioni:

• dtoglie un elemento dallo stack e (supponendo che sia un numero o un array di dimensioni 1) lo trasforma in un array vuoto. Questi array vuoti non vengono stampati, ma contribuiscono alla dimensione della pila
• Nqconta la dimensione della pila e ne sottrae una. Questo è il n+1termine quando si valuta la funzione (poiché inizia da 2 e aumenta di uno ogni iterazione a causa ddell'aggiunta di elementi invisibili allo stack)
• 17L questa è la costante Phi = (1+sqrt(5))/2
• /kquesto esegue floor((n+1)/Phi)quale è una delle formule che calcola gli elementi della sequenza. Questa formula è elencata su OEIS poiché ad a(n) = floor(sigma*(n+1)) where sigma = (sqrt(5)-1)/2eccezione dell'utilizzo dell'identità(sqrt(5)-1)/2 = 1/Phi

Python 3 - A__

print(100+-1)

Provalo online!

100 bottiglie di birra, aggiungi -1per ottenere il numero successivo 99, ecc.

Keg , sequenza A000045 , di A__

Originale:

0.

Cracked:

01":&+.
 ^^^^^

Si noti che la sfida consisteva nel trovare una sottostringa di lunghezza <= 6, ma la stringa trovata ha lunghezza 5.

Definizione dei comandi per coloro che sono troppo pigri per cercare la specifica Keg: 0e 1spingere il rispettivo numero nello stack; "sposta la pila dall'alto verso il basso (rotolo); &inserisce la parte superiore dello stack nel registro se è vuota, altrimenti svuota il registro nello stack; +aggiunge i primi due valori dello stack.

L'iniziale 1"inserisce appena un 1 nella parte inferiore della pila. Questo elenco crescente di 1 gioca un ruolo solo nella prima iterazione, dove ci consente di presumere che lo stack inizi come 1 0non solo 0. In effetti, il programma 10:&+., in cui la :&+parte viene ripetuta, ha lo stesso identico comportamento della soluzione precedente, tranne per il fatto che non ha un elenco crescente di 1 in fondo.

Poiché &viene utilizzato solo una volta nella parte ripetuta e ha un comportamento alternato, il comportamento di 1":&+dipende dalla parità dell'iterazione.

Ora, questo programma in realtà non stampa la sequenza di Fibonacci che inizia con 0, 1 dall'inizio; in realtà stampa la sequenza 1, 0 di Fibonacci dal secondo posto, cioè dallo 0. (Ciò risulta nella stessa sequenza.) Sapendo questo, il programma può essere facilmente analizzato:

• Nella prima, terza, ... iterazione, lo stato inizia come [a, b]e termina come a+b (&=b).
• Nella seconda, quarta, ... iterazione, lo stato inizia come [b] (&=a)e termina come [b, b+a].

Questo infatti calcola la sequenza come richiesto.

Java 8+, sequenza A010686 di Benjamin Urquhart

()->System.out.println(1^4);
                        ^^

Brain-Flak, A000578 di Sriotchilism O'Zaic

Originale:

((())<>)

Provalo online!

Cracked:

((())(({})([][][]){})<>)
    ^^^^^^^^^^^^^^^^

Provalo online!

Pyret , sequenza A083420 , di MLavrentyev

fold({(b,e):(2 * b) + 1},1,[list: 0,0,])
                                  ^^^^

Puoi eseguirlo qui, ma non ho capito come collegarmi al codice. Dovrai copiare e incollare.

La funzione fornita ignora il suo secondo argomento. Raddoppia la prima e ne aggiunge una, che genererà la 2^n - 1sequenza necessaria necessaria qui: tutto ciò che devo fare è dirgli quante volte eseguire quell'operazione, cambiando la lunghezza della lista piegata. Fortunatamente, Pyret non si lamenta di quella virgola finale.

Python 3 , sequenza A268575 di NieDzejkob

Originale:

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW")
print(len(W))

Cracking (100 byte):

from itertools import product
S,F,D=lambda*x:tuple(map(sum,zip(*x))),lambda f,s:(v for x in s for v in f(x)),lambda s:{(c-48>>4,c&15)for c in map(ord,s)}
W=D("6@AQUVW");A=-1,1,0;*X,=F(lambda a:(S(a,x)for x in product(A,A)),W);W={p for p in X if 2<X.count(p)<4+({p}<W)}
print(len(W))

Provalo online!

Da quello che posso raccogliere, il codice originale sta impostando le definizioni per rendere la stringa nascosta il più abbreviata possibile e quindi definendo il modello iniziale di Game of Life. La stringa nascosta equivale quindi a scrivere un'iterazione di Game of Life di Conway in 102 byte.

Ai fini di questo crack, Sè una funzione che somma gli elementi nei suoi argomenti (che sono iterabili) e Fapplica una funzione che restituisce un iterabile a ogni elemento di un elenco e distrugge tutti i risultati insieme.

• ;A=-1,1,0; termina la frase precedente e abbrevia la tupla (-1,1,0) con A, che viene utilizzato come product(A,A) fornisce a tutti i vicini relativi a una determinata cella e alla cella stessa.
• *X,=F(lambda a:(S(a,x)for x in product(A,A)),W);crea un nuovo elenco che Xcontiene tutti i vicini di celle We le celle Wstesse aggiungendo le posizioni relative dei vicini a ciascuna cella e suddividendole in un elenco.
• W={p for p in X if 2<X.count(p)<4+({p}<W)}passa attraverso questo elenco Xe determina se ogni cella in Xappartiene al set di celle nella successiva iterazione. Questo è stato preso quasi alla lettera da questo golf di Game of Life .

Haskell, A014675 di Khuldraeseth na'Barya

Codice originale

main=print$uncurry(!!)([2],0)

Con sottostringa

main=print$uncurry(!!)                                   ([2],0)
                      $(\(a,n)->(a>>= \e->2:[1|e>1],n+1))

Provalo online!

Desktop Calculator, A006125 , di A__

Originale:

1n

Cracked:

1 2lx1+dsx^*n
 ^^^^^^^^^^^

Provalo online!

Implementazione semplice.

cQuents , sequenza A003617 di Stephen

=10#2:pZ
  ^

Provalo online!

Inizia con il numero più basso di n + 1 cifra, uno seguito da n zero. I #2specifica che soltanto il secondo termine della sequenza, che è la definizione sequenza applicato una volta al seme, viene stampato; questa definizione di sequenza trova semplicemente e restituisce il prossimo primo.

Python 3 - agtoever

from sympy import isprime, primerange
from itertools import count
r=1
r+=1
while isprime(r-2)or r&1<1and r>3:r+=1
print(r)

Provalo online!

MATL , sequenza A000796 di Luis Mendo

Originale:

'pi'td1_&:_1)Y$J)

Provalo online!

Cracked:

'pi'td1_&:|SQ_1)Y$J)
          ^^^

L'autore originale ha creato subdolamente l'array, [-7:-1]quindi ne ha estratto e negato il primo elemento da ottenere 7. Quindi lo usò per ottenere la 7 ° cifra arrotondata di pi (che è 3) e la presentò come prima cifra di pi. L'aggiunta |SQrende l'array originale tutto positivo, lo ordina e ne aggiunge uno a tutto. Ciò significa che dopo tutto invece di ottenere l'indice 7ottiene l'indice -2dopo un'applicazione, -3dopo due applicazioni e così via. Il -è importante perché racconta la Y$funzione per non rotonda le cifre.

Forth (gforth) , A000042 , di NieDzejkob

.( 1)1 .
^^^^^

Provalo online!

Il banale 1 byte sta semplicemente estendendo il letterale. Il problema è che trabocca 64 bit già nella nona cifra. La soluzione semplice è stampare ripetutamente la singola cifra, giusto? Sì, ma non è così facile. Anche se virare 1 .sull'estremità stamperà davvero le cifre aggiuntive richieste, saranno separate da spazi. Non funzionerà.

Ora, secondo Wikipedia, ".( (punto-paren) è una parola immediata che analizza una stringa delimitata da parentesi e la visualizza". Fortunatamente, quella visualizzazione non ha altri caratteri strani, quindi usare .(per stampare un singolo 1 dovrebbe essere sufficiente. E lo fa. Non è necessario spazio dopo il paren, quindi questi cinque personaggi (c'è uno spazio dopo il paren aperto) possono essere ripetuti al contenuto dei nostri cuori. Per dimostrare, ho incluso in TIO un esempio che avrebbe traboccato più volte di un int a 64 bit. Funziona come un fascino.

Unefunge-98 (PyFunge) , sequenza A000108 , di NieDzejkob

1# 2g1+:2p4*6-*2g/.@
 ^^^^^^^^^^^^^^^^^

Provalo online!

Ripetuto sei volte

Sono consentiti due byte in più rispetto ai diciannove! Quello che sembra essere uno spazio è in realtà un carattere 0x01 di inizio dell'intestazione.

Spiegazione:

Questa sfida consiste nel generare a(n)da a(n-1)e forse n. OEIS fornisce la formula esplicita a(n) = (2n)!/(n!(n+1)!), che è facilmente convertita ina(n) = a(n-1) * (4n-6) / n . Ora per implementare questo in Funge.

Devo inserire il codice tra il 1e il .. Questa è già metà del puzzle. Tutto ciò che rimane è quale codice inserire? Funge in particolare dagli strumenti di manipolazione dello stack, quindi il fondo dello stack è off-limits; Devo tenere traccia di entrambi ne a(n)senza aumentare lo stack. E come è meglio farlo che con lo spazio Funge?

Quel carattere 0x01 è il mio contatore n. Continuo a(n)in pila, poiché deve essere in pila dopo che l'esecuzione del bit è terminata.

1# 2g1+:2p4*6-*2g/.@
1                       Push 1. This is a(0).
 #                        Skip the next instruction. Without this, I believe the instruction pointer will reverse direction upon encountering 0x01.
   2g                     Push the third character in the source, which starts out as 1.
     1+                   Increment it...
       :                  ...copy it...
        2p                ...and put it back. One copy remains atop the stack.
          4*6-            Multiply by four. Subtract six.
              *           Multiply by a(n), leaving the result alone on the stack.
               2g         Push n again...
                 /        ...and divide our intermediate result by it. Ta-da!
                          At this point, the stack is the same as at the start of the indented block, except the one item has been advanced one place in the sequence.
                          The source of the program has changed; the third character holds the number of times this indented block has run.
                  .@    Print and terminate.

Python 3 , A008574 di tsh

print(1*2+2)
       ^^^^

Provalo online!

V, A000290 , di DJMcMayhem

é*Ä2é*Ø.
  ^^^^

restituisce i quadrati da 1.

Provalo online!

La base é*inserisce *e Ø.conta il numero di caratteri non newline nell'intero buffer. L'inserimento Äduplica la riga superiore sulla propria riga, su cui 2é*inserisce **. Le concatenazioni degli inserimenti producono numeri dispari successivi con il più grande in alto. Il finale Ø.in effetti somma i primi n numeri dispari, producendo quindi l'ennesimo quadrato.

AsciiDots , sequenza A019523 di Alion

\ +++ /
// \ / \

Una volta!

Due volte!

Dieci volte!

Mentre cercavo di capire come funziona il codice / linguaggio, ho imparato che le prime due righe del codice esistente fanno tutto il lavoro di produrre la sequenza di Fibonacci all'infinito. Il codice termina quando un punto colpisce &, quindi ho semplicemente bisogno di aggiungere un ulteriore ritardo nelle righe rimanenti per consentire l'uscita del numero appropriato di voci.

Dopo alcune prove, errori e osservazioni, ho scoperto che l'intervallo di ritardo corretto è di 16 unità di tempo per numero. Adattare un numero sufficiente di caratteri in una singola riga sembrava impossibile, quindi avrei bisogno di mettere il ritardo in 2 righe, lasciando 10 caratteri per il ritardo effettivo. Affinché lo schema si combini con se stesso, entrambe le righe devono avere 5 caratteri e poiché i tre caratteri centrali di una riga possono essere attraversati due volte, questo dà 16 unità di tempo come desiderato.

L'obbligo di abbinare questo fino al &nell'ottava colonna sembrava rendere ciò impossibile, fino a quando ho capito che potevo iniziare con una nuova riga all'interno della terza fila. Questo rende la penultima riga della giusta lunghezza e rimuove l'estremità ora ridondante della terza riga.

Brachylog , sequenza A114018 di Unrelated String

Programma originale:

≜ṗ↔ṗb&w

Stringa da inserire:

≜ṗ↔ṗẹbb&w
    ^^

Provalo online!

Spiegazione

Ecco prima la spiegazione del programma originale (sapendo che la sequenza utilizzata è "il minimo di n-digit il cui inversione di cifra è anche prime")

≜         Assign an integer value to a variable named ? 
            (try 0, then 1, then -1, then 2, etc.)
 ṗ        ? must be prime
  ↔ṗ      The reverse of ? must be prime
    b     Remove the first element of ?
     &    Ignore that we removed that element
      w   Write ? to STDOUT

Come puoi vedere, il programma è abbastanza semplice, tranne per una cosa: c'è un completamente inutile b - behead chiamata predicato , che rimuove il primo elemento del contrario del nostro numero, con il quale non facciamo nulla.

Questo è un indizio preciso su come possiamo trovare la stringa. L'idea è che, dal momento che vogliamo aumentare la lunghezza del numero di 1 cifra ogni volta che aggiungiamo la stringa, abbiamo bisogno di una stringa che "valuta" la lunghezza di quel numero in qualche modo, usando quel inutileb .

La soluzione è usare ẹb: in primo luogo, ẹ - elementstrasformerà il numero in un elenco di cifre; quindi, b - beheadrimuoverà il suo primo elemento. Il trucco è che bfallirà se l'elenco delle cifre è vuoto. Quindi ogni volta che aggiungiamo a b, aumenteremo la lunghezza del numero richiesto di 1 (perché fallirà fino al valore assegnato di? è abbastanza alto da contenere un numero sufficiente di cifre in modo che l'ultimo bvenga applicato su un elenco di una cifra).

Riapplicare ẹogni volta non ha alcun effetto perché è già un elenco di cifre. Ne abbiamo bisogno solo una volta all'inizio perché se decapitiamo un numero come 9001invece dell'elenco delle sue cifre, otterremo 001 = 1che perde informazioni sul numero di cifre.

VDM-SL , A000312 , per dati scaduti

let m={1|->{0}}in hd reverse[let x=x+1 in x**x|x in set m(1)&x<card m(1)]
                             ^^^^^^^^^^^^^

Dato che le letespressioni di VDM-SL possono ricollegare le variabili che sono già legate in un ambito chiuso, x**xpossono essere valutate arbitrariamente profondamente annidate in ambiti in cui xè uno in più rispetto allo scopo precedente, mentre l'originale xè ancora inferiore alla cardinalità di m(1).

Haskell, A083318 di xnor

f=length     [2]
        $show

Provalo online!

Haskell , A000045 (Fibonacci) , dalla trasformata di Fourier di Rin

f = head $(flip(:)<*>sum.take 2)[0, 1]
         ^^^^^^^^^^^^^^^^^^^^^^^

Provalo online!

23 byte esattamente.

Questo è stato divertente e un po 'complicato. Lo 0 e 1 invertito mi ha gettato via per un po 'prima che mi rendessi conto che non era un problema. La mancanza di $nell'originale mi ha fatto provare cose abbozzate come $...$id(un byte troppo lungo) prima che mi rendessi conto che avrei potuto semplicemente avvolgere tutto tra parentesi. Tutto sommato, un bel rompicapo.

H.PWiz sottolinea che il pattern matching mi avrebbe salvato almeno cinque byte: $(\[x,y]->[y,x+y]). Quella maledetta sfida senza senso mi fa pensare inutilmente ovunque.