Il filo del ladro è qui

Il compito della polizia è scrivere una funzione o un programma che, quando viene fornito un input di se stesso, genera una stringa deterministica finita. Se al programma viene assegnato un input diverso, dovrebbe restituire un output diverso.

Regole:

• Le presentazioni sono costituite da
  • Nome della lingua
    • Se vengono usate delle bandiere, dovrebbero essere rivelate.
  • Conteggio dei byte del programma
  • Conteggio byte dell'output
  • Produzione
    • Se è particolarmente lungo, si prega di fornire un pastebin o qualcosa di simile
    • Se contiene elementi non stampabili, fornire un dump esadecimale.
    • Trailing newline e spazi bianchi dovrebbero essere inclusi nell'output
  • Da dove proviene l'input (STDIN, riga di comando, ecc. )
• Se applicabile, si può presumere che il byte che rappresenta EOF non sia presente nell'input, a meno che non si usi quel byte nel proprio programma.
• Se il tuo programma è incrinato, aggiungi un link alla risposta corrispondente nel thread del ladro nel tuo titolo.
• Il tuo programma non è sicuro fino a quando non è trascorsa una settimana e lo contrassegni così.
• Non approvo tecniche come il seeding random con input o funzioni hash crittografiche. Non riesco a fermarli, ma non accetterò una soluzione che utilizza uno di questi . Si noti inoltre che alcune di queste tecniche potrebbero avere collisioni, in cui una stringa diversa produce lo stesso output.
• Il tuo obiettivo è quello di avere l'output più breve. La soluzione sicura più breve pubblicata entro tre settimane dalla pubblicazione di questa domanda vince!

Il compito del ladro è trovare un programma di dimensioni pari o inferiore all'originale, che obbedisce anche alle regole di cui sopra.

Se un ladro decifra il tuo programma con una soluzione diversa da quella prevista, allora hai la possibilità di "decodificarlo" dimostrando che la soluzione del ladro non è corretta. Puoi farlo trovando un input per il programma del ladro che produrrà lo stesso output.

Esempio di presentazione:

Brainfuck, 10 byte, Punteggio: 10

]<.[<],>[,

Questa soluzione è , [>,] <[. <] Che inverte semplicemente l'input

In bocca al lupo!

7 , 31 caratteri, punteggio 30, sicuro ma forse rotto?

Un programma 7 è normalmente solo un numero, ma può contenere spazi bianchi, suddividendolo in più numeri. Questa presentazione consiste quindi di due numeri (che sono implicitamente concatenati dall'interprete 7), e allo stesso modo il programma accetta due numeri come input, tramite input standard. (I "31 caratteri" nell'intestazione sono la lunghezza totale dei due numeri, più un carattere di spazio bianco di separazione; le cifre che compongono i numeri sono interpretate come ottali quando usate come programma, ma decimali quando usate come input, e sono le cifre che sono le stesse nei due casi, non i numeri reali. Nota che è irrilevante sia quando trattato come un programma, sia quando trattato come un input, sia che tu li separi con uno spazio o una nuova riga; spero che non non invalidare l'invio.)

L'output previsto è il seguente numero (espresso qui in decimale, poiché è il formato di output utilizzato dall'interprete 7):

238363505302130098723162537059

Nota che l'interprete 7 collegato dal wiki di Esolang memorizza internamente numeri in unario, il che significa che è improbabile che tu abbia memoria sufficiente per eseguire effettivamente il programma su se stesso per vedere cosa fa. Ho verificato il programma elaborando manualmente il suo comportamento e testandolo su piccoli input per verificare che facesse quello che mi aspettavo. Un approccio alternativo sarebbe quello di scrivere un interprete che utilizza un metodo più efficiente per memorizzare i numeri.

Evitare le crepe qui è stato una vera seccatura, ma ora sono finalmente soddisfatto che nessun altro numero diverso da quelli del programma stesso sia in grado di produrre 238363505302130098723162537059 come output. ( MODIFICA 1 settimana dopo: potrei essermi sbagliato, a seconda di come interpreti la domanda; vedi sotto ) .

Soluzione

Il programma originale era:

711170237403706
111723603700633

Questo programma richiede due numeri $x$ e $y$ , e calcola il risultato dell'espressione $3xy-y-2$ (cioè $y(3x-1)-2$ ). Se eseguiamo questo calcolo su $x=711170237403706$ e $y=111723603700633$ , otteniamo un risultato di $238363505302130098723162537059$ come richiesto .

Si pensava che nessun altro input avrebbe dato il risultato desiderato perché:

L'ingresso deve essere scelto in modo tale che $y(3x-1)-2=238363505302130098723162537059$ , ovvero $y(3x-1)=238363505302130098723162537061$ (aggiungendo 2 su entrambi i lati). Questo numero è un semiprime, con solo due fattori: $111723603700633$ e $2133510712211117$ . Solo uno di questi numeri, $2133510712211117$ , può essere espresso nella forma $3x-1$ (dando $(3 \times 711170237403706)-1=2133510712211117$ ). Quindi possiamo identificare in modo univoco quale numero è$x$ e quale è$y$ , il che significa che funziona solo un input.

Tuttavia, a seconda di come si interpreta la domanda, potrebbe esserci un secondo input che produce l'output desiderato (invalidando così questa soluzione):

$1$$1$$3x-1$$x$$79454501767376699574387512354$$1$$8$$9$) che non sono nel set di caratteri per 7 programmi. Quindi, se l'input è limitato allo stesso set di caratteri del programma, questa soluzione è valida; ma se è consentito l'input contenente caratteri esterni al set di caratteri del programma, questa soluzione non è valida.

Spiegazione

Ecco come funziona la soluzione prevista:

711170237403706 111723603700633
7 7 7 Separatori di elementi stack
 111 023 403706 111723603700633 Elementi di stack iniziali
 111 Numero 3, in unario
     023 I / O DSL per "inserire un numero"
         403706 111723603700633 Programma principale
(Implicito: esegue una copia dell'elemento principale del programma, preservando l'originale)
         40 Scambia {023} sopra {programma}, sfuggendolo
           3 I / O usando {023}; pop {programma}
     0 I / O: numerico
      23 Immettere un numero, copiando {111} tante volte
            706 Aggiungi "6" al numero (decrementandolo)
                11 Spingere due elementi stack vuoti
                  17236 Push a stack element "23" (senza caratteri di escape)
                       0 Esci {23}, consumando un elemento vuoto
                        3 I / O usando {23}; pop {l'elemento sotto}
                    23 Copia l' input della parte superiore dello stack più volte
                         7006 Aggiungi "66" (ovvero sottrai 2)
                             3 Output {come numero}
                              3 Uscire dal programma (a causa dello stack basso)

17066612345$3$$123451234512345$

Node.js v10.9.0 , 40 byte, Punteggio: 40, Cracked

Ingresso

Questa è una funzione che accetta esattamente un parametro.

Produzione

&`nij.9=j.,)r31n=+(=ooj`[o.o.)1.s](>=6>t

A Pear Tree , 46 byte di ASCII, punteggio 0, Cracked

L'input è preso dall'input standard. L'output previsto (sull'output standard) è una stringa vuota (ovvero quando il programma viene fornito come argomento, nessun output deve essere stampato).

In altre parole, la sfida qui è scrivere un programma A Pear Tree che non produca nulla sull'output standard quando viene fornito su input standard e che generi qualcosa sull'output standard quando viene fornito qualcosa di diverso su se stesso sull'input standard, usando no più di 46 byte. (Sono riuscito a farlo mantenendo anche il programma in ASCII stampabile, nonostante A Pear Tree utilizzi frequentemente caratteri non ASCII e non stampabili.) Questo è effettivamente il compito di scrivere un programma autoidentificante , con un formato di output specifico (ovvero stringa nulla quando l'autoidentificazione ha esito positivo); tuttavia, A Pear Tree ha almeno due colpi di scena che rendono il compito un po 'più difficile di quanto sembri se fatto in questo linguaggio specifico (motivo per cui l'ho scelto per la mia presentazione da poliziotto).

La mia soluzione

La mia soluzione è leggermente diversa dal crack:

eval(k=q(print$\=$_="eval(k=q($k))"ne$_;MZpa))

Provalo online!

Invece di usare exit, ho invece impostato $_(output implicito) e $\(newline dopo output, incluso output implicito) sulla stringa nulla se c'è una corrispondenza (e su 1se non c'è corrispondenza). A printè ancora richiesto perché l'output implicito è abilitato solo se c'è almeno un byte di input (quindi, dobbiamo stampare esplicitamente qualcosa se ci viene data una stringa vuota come input, che è distinta dal programma).

Ogni programma A Pear Tree deve contenere un checksum da qualche parte (questo è il MZpain questa soluzione). Sia la mia soluzione che il crack scelgono i nomi delle variabili (e variano altri dettagli minori del codice) al fine di rendere il checksum costituito interamente da lettere ASCII.

Perl 5 -p0777, 10 byte, punteggio 10, sicuro

W)9r46<(k

L'ultimo carattere qui è "sposta fuori", codice carattere 14 (decimale) / 0E (esadecimale). Tutti gli altri sono ASCII stampabili.

Poiché stiamo usando l'argomento I / O implicito di Perl -p0777, l'input proviene dall'input standard e l'output passa all'output standard.

Soluzione

Il programma procede come segue:

NUL-pad input per almeno 10 caratteri, quindi XOR con la stringa svgOUT_TOP

il che significa che il programma stesso, l'unico input che produce l'output desiderato, è:

$ _ ^ = Abc | $ ^

Provalo online!

Spiegazione

Perl ha un numero di variabili per scopi speciali. Ad esempio, quando si utilizza -p0777per l'I / O implicito, $_viene immesso all'inizio del programma e emesso alla fine del programma.

La maggior parte di queste variabili ha un valore predefinito molto semplice. Tuttavia, il valore predefinito di $^, il formato di inizio pagina attualmente selezionato, è la stringa molto più lunga STDOUT_TOP. Come tale, possiamo usarlo come metodo di offuscamento molto conciso tramite XORing $^con il valore che vogliamo offuscare (in questo caso, il programma).

Al fine di nascondere la spia _TOPalla fine, ho riempito il programma stesso di 10 caratteri aggiungendo un abc|, il che significa che tutti i personaggi di STDOUT_TOPsarebbero stati XORed con qualcosa; la scelta di abc|all'inizio è stata un modo semplice per mantenere l'output per lo più stampabile (e per rendere più difficile individuare che stavo XORing con una stringa composta principalmente da lettere maiuscole, perché in ASCII, XOR in minuscolo è in minuscolo).

Python 3, 50 byte incrinati

Input e output da / a stdin / -out. L'output è diverso per ogni input diverso. Output univoco quando viene fornito il codice sorgente:

218216195196222130136136132192197195196130241204136209197216206130201131244155157154215136138204197216138201138195196138195196218223222130131247131131

(Sono 150 cifre)

In bocca al lupo!

05AB1E , 35 byte, Punteggio: 7

Ingresso:
dastdin

Produzione:
QÕ Ƿe

Cubix , 18 byte, Punteggio 18, sicuro

È un peccato che questa sfida non abbia attirato più attenzione, ma a volte è così. Stavo per lasciare questo non sicuro, ma ho deciso di pubblicare la soluzione prima di dimenticarmene.

Questo dovrebbe essere abbastanza facile da decifrare.

Ingresso dastdin

Produzione

$`*2aJPJ#74(o);89

Modifica: dovrei dire che questo si aspetta che la fonte sia nella sua forma abbreviata ... e ora ho notato che c'è un byte mancante (non stampabile) dal risultato che ho rotto quando ho pubblicato. Dovrebbe copiarlo ora. I valori esadecimali sono24 60 2a 13 32 61 4a 50 4a 23 37 34 28 6f 29 3b 38 39

Il concetto era di rimuovere stampare il primo carattere e quindi rimuovere l'indice inverso dal carattere, ad es. [Chars] - [0, len ([chars]) .. 2]

Il codice è

$r;#AoW\U-@</u.?;;

che mappa sul cubo seguente

    $ r
    ; #
A o W \ U - @ <
/ u . ? ; ; . .
    . .
    . .

Provalo qui

Gelatina , 14 byte, Punteggio: 21, Sicuro

Sia il programma che le dimensioni dell'output vengono contati utilizzando la tabella codici Jelly.

Ingresso

Primo argomento da riga di comando.

Produzione

-§ḋẇ"*YdĖDƘ>Ẉed€Ç+æạɦ

Soluzione

ØJiⱮÄÆNPḃØ⁵ịØJ

Provalo online!

JavaScript Firefox, <10 byte, Punteggio: 52, dall'input dell'argomento funzione, Cracked

ZnVuY3Rpb24gYnRvYSgpIHsKICAgIFtuYXRpdmUgY29kZV0KfQ==


btoa

btoa(btoa) codifica la seguente stringa:

function btoa() {
    [native code]
}

che dà:

"ZnVuY3Rpb24gYnRvYSgpIHsKICAgIFtuYXRpdmUgY29kZV0KfQ=="

_{appena copiato}

GCC 61-> 61 byte

70 4F 92 73 08 D4 03 E7 65 DC D6 89 B5 AD BA 90 
97 26 31 10 F6 FA 0A 30 8F 24 69 0A A7 8B 59 9E 
A2 42 D5 67 B8 12 3A 1E 9D 25 80 F9 6B 25 32 C2 
EE 46 3F 8D 7E 0C 73 0F F0 93 C6 68 50

Programma completo, porta input da stdin e output a stdout

Perl 6, 43 byte, Punteggio: 15, dallo stdin

49671296789805

Pepe , 23 byte, punteggio: 23, crackato da MickyT

Ingresso:

standard

Produzione:

RDCbn@?K]<[G98765TSR^PO

J , 26 byte, Punteggio: 52, Sicuro

Il programma non è un REPL, ma uno script completo che accetta stdin e stampa esplicitamentestdout .

Ingresso

Input standard.

Produzione

6fc42353c98217ef5a2908a3c63d090aa9a55b2558b61294e06a

No, non è un metodo di crittografia.

Soluzione

echo]hfd]257x#.3&u:stdin''
                   stdin'' Take the whole input
               3&u:        Convert to codepoints
         257x#.     Convert base 257 to integer
     hfd]           "Hex from Decimal"
echo]               Print to stdout

Provalo online!

Fusto , 6 byte, Punteggio: 6

Ingresso

Da stdin, usando?

Produzione

5\x1c"\x1c"9

Ricorda che quelle sono sequenze di escape per byte non stampabili. Sostituisci le fughe con i caratteri letterali. Testo non elaborato disponibile qui

Buona fortuna con questo! Ci vediamo la prossima settimana!

 Perl 6, 31 byte, Punteggio: 39, da stdin - Cracked

Incrinato qui

().1111111111112222235abcegijkmnorstvy

Soluzione grezza. Potrebbe sopravvivere.