Cambia il codice, cambia la sequenza: poliziotti

27

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

Questa sfida coinvolge due sequenze OEIS scelte dai poliziotti - S 1 , S 2 - e quanto bene queste sequenze possono essere giocate a golf e offuscate.

La sfida della polizia

La tua sfida come poliziotto è quella di scegliere una lingua liberamente disponibile e due sequenze OEIS. Quindi, scrivere il codice A in quella lingua che accetta l'input n e produce S 1 (n). Quando quel codice viene modificato da una distanza di Levenshtein di caratteri X (con X non più di 0.5 * (length A)) e trasformato in codice B nella stessa lingua, deve quindi produrre S 2 (n). Devi effettivamente scrivere questo codice B , ma non rivelarlo finché la tua sfida non è sicura (vedi sotto).

Le richieste dei poliziotti devono includere il nome della lingua, il codice completo A , il conteggio dei byte di A , il valore X di quante modifiche arrivano al loro codice segreto B e i numeri di sequenza S 1 e S 2 scelti . Puoi scegliere se ogni sequenza è 0-indicizzata o 1-indicizzata, ma ti preghiamo di specificarla nel tuo invio.

Per decifrare una particolare proposta, i ladri devono elaborare un programma C nella stessa lingua (e versione) che produce S 2 (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.

Vincere e segnare

Se la risposta del tuo poliziotto non è stata decifrata entro 7 giorni (168 ore), puoi rivelare la tua soluzione B , a quel punto la tua risposta è considerata sicura. Fintanto che non rivelerai la tua soluzione, potrebbe essere comunque violata dai ladri, anche se i 7 giorni sono già passati. Se la tua risposta viene decifrata, ti preghiamo di indicarla nell'intestazione della tua risposta, insieme a un link alla risposta del ladro corrispondente.

Gli sbirri vincono avendo la presentazione senza crack con la A più corta . Se legato, la X più piccola verrà utilizzata come pareggio. Se è ancora in parità, vincerà la domanda precedente.

Ulteriori regole

  • Non è necessario utilizzare alcun built-in per hash, crittografia o generazione di numeri casuali (anche se si semina il 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.
code-golf  sequence  cops-and-robbers 
— AdmBorkBork
fonte
Inoltre, assicurati di modificare qualcosa in questa domanda, di aggiornare quello dei ladri.
— mbomb007,
E se un poliziotto nomina una funzione / variabile davvero grande rispetto al codice reale che genera la sequenza? Sarà possibile creare qualsiasi sequenza in questo caso con la sua distanza lev inferiore a quella(0.5*len(A))
— hashcode55
@ hashcode55 Due cose: 1) che probabilmente non sarà un buon candidato per vincere il thread della polizia. 2) se è enorme, offre anche un buon margine di manovra ai ladri.
— AdmBorkBork,
1
" Questo è il code-golf, quindi si applicano tutte le solite regole del golf " Questo significa che il codice A deve essere il più possibile giocato a golf o può essere intenzionalmente scritto in un modo troppo dettagliato / scomodo per renderlo più simile al codice B ?
— smls
7
— crackate

Risposte:

10

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

Questa risposta utilizza l'indicizzazione 1

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

Provalo online

Per chiunque sia interessato ci sono 27475 programmi Brain-Flak validi con distanza Levenshtein 4 da questo programma e 27707 con distanza 4 o inferiore. Quindi una soluzione di forza bruta sarebbe fattibile su un computer di livello consumer.

— Mago del grano
fonte
Probabilmente sarebbe più breve e più veloce da leggere se X = 4invece di Levenshtein distance of 4.
— mbomb007,
1
@ mbomb007 Personalmente mi confondo un po 'quando le sfide usano un mucchio di variabili lettera per sostituire le cose che stavo cercando di evitare confusione. L'ho reso più breve ora, si spera senza creare confusione.
— Wheat Wizard
scrollata di spalle . Se tutti leggono la domanda, dovrebbero capirla. Xè davvero l'unica variabile che devono conoscere.
— mbomb007,
@ mbomb007 Anche se, la domanda richiede anche un conteggio di byte.
— DLosc,
1
— DJMcMayhem
6

7 , 33 caratteri, 13 byte, X = 10, A000124 → A000142 , Sicuro

171720514057071616777023671335133

Provalo online!

La distanza di Levenshtein è misurata in termini di caratteri, quindi ho scritto il programma in termini di caratteri che contiene sopra (e provalo online !, compresa la lingua stessa, è felice di eseguire programmi codificati in ASCII). Tuttavia, il programma viene archiviato su disco utilizzando la codifica sub-byte 7, il che significa che il programma stesso è in realtà il seguente hexdump (quindi 13 byte di lunghezza):

00000000: 3cf4 2982 f1ce 3bfe 13dc b74b 7f         <.)...;....K.

(Poiché la distanza di Levenshtein è misurata in termini di caratteri, qui non devi necessariamente aggiungere / eliminare / modificare 10 byte , quindi è probabilmente meglio lavorare con l'ASCII originale.)

Il programma come scritto implementa A000124 (numeri triangolari + 1); qualsiasi crack deve implementare A000142 (fattoriali). Entrambi i programmi prendono input da stdin (come numeri decimali), scrivono il loro output su stdout e trattano un input di 1 come significato del primo elemento della sequenza (e un input di 2 come secondo elemento, ecc.).

Speriamo che l'altissimo valore X impedisca alle persone di forzare brutalmente il programma, questa volta (il che è sempre un rischio con le voci di poliziotti e ladri in 7).

La soluzione

177172051772664057074056167770236713351353

Provalo online!

Differenze dall'originale:

17 172051 405707 1 61677702367133513 3
17 7 172051 77266 405707 405 61677702367133513 5 3

Non ho preparato spiegazioni su come funzionano, quindi mi ci vorrà un po 'per ottenere una spiegazione, dato che dovrò capirlo da zero. Spero che alla fine ci sia una spiegazione.

4

Perl 6 , 10 byte, X = 1, A000012 → A001477

Cracked!

*[0]o 1***

  • S 1 = A000012 = 1,1,1,1,1,...= La sequenza di tutti 1. (0-indicizzati)

  • S 2 = A001477 = 0,1,2,3,4,...= Gli interi non negativi. (0-indicizzati)

Provalo online!

Confermato per funzionare con Perl 6 versione 2017.01 e con la versione Perl6 in esecuzione su TIO.

( A potrebbe essere ulteriormente giocato a 1***- spero che sia consentito anche così com'è.)

— LMS
fonte
3

Perl 6 , 13 byte, X = 1, A161680 → A000217

Sicuro!

{[+] [,] ^$_}
  • S 1 = A161680 = 0 0 1 3 6 10 15 21...= Zero seguito dai numeri triangolari.
  • S 2 = A000217 = 0 1 3 6 10 15 21 28 ...= I numeri triangolari.
  • Zero indicizzati.

Provalo online!

(Confermato per funzionare con la versione Perl 6 in esecuzione su TIO.)

Soluzione

{[+] [\,] ^$_}

Come funziona l'originale:

{           }  # A lambda.
          $_   # Lambda argument.                     e.g. 4
         ^     # Range from 0 to n-1.                 e.g. 0, 1, 2, 3
     [,]       # Reduce with comma operator.          e.g. 0, 1, 2, 3
 [+]           # Reduce with addition operator.       e.g. 6

Come funziona la soluzione:

{            } # A lambda.
           $_  # Lambda argument.                     e.g. 4
          ^    # Range from 0 to n-1.                 e.g. 0, 1, 2, 3
     [\,]      # Triangle reduce with comma operator. e.g. (0), (0,1), (0,1,2), (0,1,2,3)
 [+]           # Reduce with addition operator.       e.g. 10

Sfrutta il fatto che operatori numerici come l'addizione trattano un elenco come il suo numero di elementi, quindi nell'esempio è la somma 1 + 2 + 3 + 4 = 10.

E sì, il no-op "Riduci con virgola" nell'originale sta un po 'evitando le regole del code-golf, ma preferisco guardarlo come un algoritmo sciocco che è stato giocato il più possibile (spazi bianchi ecc.) Per Cos'è... :)

— LMS
fonte
Ciò sta implorando di essere forzato brutalmente, se avessi il tempo o l'inclinazione (e la conoscenza del perl).
— Rohan Jhunjhunwala,
Questo è sopravvissuto abbastanza a lungo per essere contrassegnato come sicuro
— fəˈnɛtɪk
2

Gelatina , 11 byte, X = 5, A005185 → A116881

ịḣ2S;
1Ç¡ḊḢ

Questo è un programma completo che accetta un numero intero come argomento della riga di comando e stampa un numero intero.

Entrambe le sequenze sono indicizzate come su OEIS, ovvero A005185 è 1 indicizzato e A116881 è 0 indicizzato.

Provalo online!

— Dennis
fonte
1

WolframAlpha, 18 byte, X = 1

Cracked by math_junkie!

(sum1to#of n^1)*2&

A volte WolframAlpha sarà effettivamente in grado di mostrare una funzione pura come questa in forma funzionale (altre volte viene confusa); ma può essere allegramente invocato con un dato input, ad esempio i (sum1to#of n^1)*2&@5rendimenti 30.

S1 = A002378 (numeri pronici)

S2 = A000537 (somma dei primi ncubi)

Entrambe le sequenze sono indicizzate 0.

— Greg Martin
fonte
— drogato di matematica,
1

Javascript, 15704 byte, distanza di 2, A059841 e A000004 - incrinato

Questa soluzione è estremamente lunga, quindi puoi trovare il codice completo in questo github gist.

La risposta originale (questa) è 1 indicizzata. (So ​​che è troppo lungo, è solo per divertimento.)

— Comunità
fonte
Cracked . Inoltre, aggiungere un codice assolutamente inutile! + [] - (! + []) Non è proprio nello spirito delle regole
— f 14n 14tɪk
Solo per questo, questa risposta sta causando alcuni problemi all'OP di questa sfida. Apparentemente provoca il blocco dell'intera pagina perché sembra JavaScript impreciso. Potresti forse inserire il codice in un link esterno? (Gist, pastedump, ecc.)
— DJMcMayhem
A dire il vero, l'ho messo da solo. Se preferisci avere il codice da qualche altra parte, sentiti libero di modificarlo di nuovo se ho superato i miei limiti.
— DJMcMayhem
Immagino che! + [] - (! + []) Lo faccia in modo che tu non possa semplicemente invertire la conversione. Ma parte dell'altra immondizia la allunga. Il codice equivalente è solo 15640 byte.
— fəˈnɛtɪk,
0

Javascript, 30 byte, Distanza di 4, A000290 , A000079 , - Incrinato!

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

Indicizzazione basata su 0

La soluzione di @Kritixi Lithos era in realtà diversa dalla mia

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

Provalo online

— fənɛtɪk
fonte
1
Questo è x**2e non2**x
— Kritixi Lithos,
Penso che sia A000290 , non A000079.
— Betseg,
@KritixiLithos dovrebbe essere entrambi. Ho cambiato il link sequenza errato in alto quando ho cambiato l'altra estremità.
— f 13nɛtɪk,
— Kritixi Lithos,
0

Javascript (ES6), la distanza è 1, A000079 e A000004 - incrinata

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

La risposta originale (questa) è basata su 0. Ora che è stato rotto, ecco la funzione B originale:

as=function(){ return 2*2**((1^1)*-1*~arguments[0]/11-(4-(as+[]).length%89))-(as+[]).length%7}
— Comunità
fonte
1
Sono stato in grado di far sì che il mio crack codegolf.stackexchange.com/a/109976/64505 si comportasse in modo incoerente tra due ambienti diversi.
— fəˈnɛtɪk,
0

Java 7, Levenshtein distanza di 4, A094683 , A000290 , Cracked

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;}

0-indicizzati.
Provalo qui!

— Peech
fonte
@LliwTelracs lo ha fatto per i primi 15 numeri interi non negativi, vedi la mia risposta aggiornata.
— peech,
— fəˈnɛtɪk,
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.