Questo è il filo della polizia. Il filo dei ladri va qui .

Scrivi un programma o una funzione composta solo da caratteri ASCII stampabili (che esclude tab e newline) che genera almeno 5 caratteri ASCII stampabili in ordine crescente (dallo spazio alla tilde / da 32 a 126). I personaggi possono essere emessi più volte, purché siano adiacenti l'uno all'altro. Viene accettata una singola riga finale finale. È necessario fornire l'output completo e per ogni 6 caratteri nel codice è necessario fornire un carattere nel codice, nella posizione in cui appare. Se il tuo codice ha 5 o meno caratteri, devi rivelare solo la lunghezza. Non devi rivelare più di 1 carattere per 6 nel tuo codice.

Quindi, se il tuo codice alphaprintergenera l'alfabeto da az, devi rivelare 2 caratteri del tuo codice (usa il trattino basso per gli altri), ad esempio:

al__________  // or
__p__p______  // or
__________er

Regole / specifiche:

• Non è possibile aggiungere spazi bianchi finali che non hanno una funzione.
• Non puoi usare i commenti (ma i ladri possono usare i commenti quando decifrano il codice)
• Non sono consentite primitive crittografiche integrate (include rng, crittografia, decrittografia e hash).
• Nelle lingue in cui l' output predefinito è simile a MATLAB:, ans =quindi viene accettato, purché sia chiaramente indicato e indicato che ans =viene emesso. Dovrebbe anche essere chiaramente indicato se questo fa parte del "risultato crescente" o no.
• L'output deve essere deterministico
• L'uso di una lingua non libera non è accettato
• L'output non deve essere composto da caratteri consecutivi. Entrambi abcdee abcdgsono output validi.
• I caratteri non devono essere distinti purché l'output contenga almeno 5 caratteri. aaaaae aaaccsono validi.
• Le risposte che presuppongono un ambiente REPL non sono considerate programmi o funzioni validi e pertanto non sono consentite.
• STDERR non è considerato un output valido, ma i dati possono essere scritti su STDERR.

Se i personaggi rivelati sono sottolineati, è necessario identificarlo come mostrato di seguito. In questo caso, il secondo e il sesto carattere vengono evidenziati, mentre gli altri sono sconosciuti.

_____________
 |   |

Nota: i ladri devono solo trovare un codice che produca lo stesso output. Anche la lingua, la lunghezza della soluzione dei ladri e la posizione dei personaggi rivelati devono corrispondere.

Il tuo punteggio è il numero di caratteri nel tuo codice. Il vincitore sarà l'invio con il punteggio più basso che non è stato crackato in 7 giorni. Solo gli invii pubblicati nel 2015 (UTC) sono idonei per la vittoria. Le iscrizioni pubblicate successivamente sono benvenute, ma non possono vincere.

Per richiedere la vincita devi rivelare il codice completo (dopo 7 giorni).

Il tuo post dovrebbe essere formattato in questo modo (nn è il numero di caratteri):

Lingua, nn caratteri

Produzione:

abcdefghijklmnopqrstuvwxyz

Codice (12 caratteri):

al__________

Se il codice è crackato, inserire [Cracked] (collegamento al cracker) nell'intestazione. Se l'invio è sicuro, inserisci "Sicuro" nell'intestazione e rivela il codice completo nella tua risposta. Solo le risposte che hanno rivelato il codice completo saranno idonee per la vittoria.

Esagonia , 8 personaggi, sicuro

_______.

stampe

123456

Puoi provare Hexagony online

Soluzione

`&)!."@.

L' `è proprio depistaggio per rendere il codice assomigliare richiede lato di lunghezza 3. A meno che l'interprete viene eseguito con -dl'apice inverso è semplicemente spogliato dal codice sorgente prima di determinare il layout. Successivamente, il codice si inserisce nella lunghezza laterale 2:

 & )
! . "
 @ .

Ciò sposta il puntatore di memoria (MP) attorno a un esagono della griglia di memoria, copiando il valore sul bordo successivo, incrementandolo e stampandolo.

Ecco come appare la griglia di memoria, con l'MP che inizia la posizione contrassegnata:

Inizialmente tutti i bordi sono zero. Il primo &è no-op, ma )incrementa il bordo e !stampa il 1. Quindi "torna a sinistra (il bordo etichettato 2 ). Lì, &copia un valore. Poiché il bordo è attualmente pari a zero, il vicino sinistro (nella direzione dell'MP) verrà copiato, ovvero il 1foglio appena stampato. )lo incrementa, !stampa il 2. Questo continua fino a quando visitiamo nuovi bordi e stampiamo tutte le cifre fino a 6. Quando abbiamo raggiunto il bordo abbiamo iniziato, &copierà la destra vicino di casa, invece (perché il valore bordo è positivo), in modo che il bordo diventa 0ancora una volta, e il flusso di controllo salta l'ultima fila, dove@ termina il programma.

Provalo online.

Perl, 46 caratteri (sicuro)

Produzione:

((()))*++,---../00011123445556667779::;;<<==??@@AAACEFGHHHIKKMMNOOOPPQQQRRSSSVWXXYY[[[\]]]^^^```aaeeffggghjjjnpppqqrttuwxxyzz{{{

Codice:

print _______________________________________;

In qualche modo sono riuscito a eliminare l'originale nel giro di una settimana, ma penso che sia giusto:

print chr()x(($i=($i*41+7)%97)&3)for(40..123);

Brainfuck, 48 personaggi, incrinato da Mitch Schwartz

L'ho fatto per i ladri. Non sarà sicuramente la proposta vincente :)

____[_____[_______]__]___[___________]___[_____]

Questo produce:

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Soluzione:

++++[>++++[>++++<-]<-]+++[>++++++++<-]>++[>+.<-]

L'ho provato qui .

Suggerimento: non cercare di trovare programmi generati dai generatori online ahah. Questo è stato scritto a mano e può essere risolto solo dal pensiero logico :)

CJam, 13 caratteri

_____________
  ||

stampe

7LLMYahnsuv

Puoi provare CJam online.

Soluzione

{`__Jf^er$}_~

Pensavo che basare un poliziotto su un quine generalizzato fosse piuttosto intelligente e nuovo. Nel momento in cui l'ho pubblicato, me ne sono reso conto __e ersono completamente inutili, motivo per cui ho pubblicato il poliziotto CJam a 8 byte per un punteggio più competitivo. Pietu l'ha risolto piuttosto rapidamente, quindi temevo che avrebbe capito anche questo. Suppongo che la traslitterazione dei caratteri inutilmente contorta lo abbia salvato.

Ad ogni modo, il codice prende i suoi caratteri (tranne il _~), XOR ognuno con 19 per offuscamento e poi li ordina.

Questo poliziotto mi ha portato alla "scoperta" dello xorting , anche se in realtà non lo sto usando qui (e probabilmente sarebbe quasi impossibile usarlo con un breve quine generalizzato).

Noisy 3SP , 89 caratteri (sicuro)

0 _____________________________ _ _ _ _ _ _ _ _ _ __2_2__________________________________

Programma originale:

0 0 0 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 0 3 2 2 2 2 0 3 0 1

Questo programma stampa

 !"#$$

(nota lo spazio principale) e nient'altro!

Spiegazione (* n si riferisce all'ennesima cella in memoria):

0 0 0                                Increment *0 to 3 (via the 0s in *0, *1, and *2)
2 (32 times)                         Increment *3 to 32 (via the 0 in *2 and the 3 in *0)
                                      (Note that *3 mod 256 is the character that prints)
0                                    Increment *32 (via the 3 in *0 and the 32 in *3)
3                                    Increment *1 (via the 32 in *3 and the 1 in *32)
                                      (Note that printing is on when *1 mod 2 is 1,
                                       which means " " prints right here)
2 (4 times)                          Increment *3 to 36 (printing '!"#$')
0                                    Increment *36 (via *3) (printing "$" again)
3                                    Increment *1 to 2 (via *36) (printing turns off)
0                                    Increment *36 to 2 (via *3)
1                                    Increment *0 to 4 (via *2)

Gli ultimi due comandi risultano sufficienti per impedire che 1 venga mai incrementato di nuovo nei passaggi successivi del programma, il che significa che nulla viene mai più stampato, anche se continuerà a impostare tutti gli indirizzi di memoria da * 36 in poi al valore 36 per sempre .

JavaScript (ES6), 60 caratteri, crackato dall'utente81655

Non promettente per vincere, ma spero divertente da decifrare:

e_e_______a__a____e___e________e__o___________o______o______

Questa è una funzione che restituisce:

    :ERacddeeeeeeffiinnnoorrrrst
^^^^ -> 4 whitespaces

modificare

user81655 lo ha decifrato carattere per carattere:

e=e=>{try{a}catch(e){return[...e.toString()].sort().join``}}

Matlab Octave, 27 caratteri, sicuro

Sfida

Per quanto riguarda le nuove restrizioni linguistiche: funziona anche in Octave.

____________3_3___4_3______

Output (in Octave): ( ans =non fa parte dell'output, il primo carattere dell'output è ")

ans = """""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq

Output (in Matlab): ( ans = \n\nnon fa parte dell'output, l'output è solo l'ultima riga)

ans =

"""""""""""""""""""""""""""""""""""""""""""########$$$$$$%%%%&&&&'''(()))**++,,-../001223456789:;<=>?@BCDFGHJKMNPRTUWY[]_acehjloq

Soluzione

[fix((0:.07/3:3).^4+34),'']

Fondamentalmente stiamo guardando questa funzione, convertita in valori ASCII.

R, 60 byte, rotto dal plannapus

Produzione:

0123456789ABCDEFGHTUVWXYZdefghijklmnopqrstuvw

Codice:

___(_(_:_____________]_____________6]_______s_4_____,___=___

Penso che questo non sarà così difficile. Vedremo.

Jolf , 27 personaggi, Cracked di Adnan

________W___________--_____
                         |

stampe

abcdefghijklmnopqrst

Interprete .

Codice originale:

on*2toHEWn)oH+H `pl$--$n}_H
on                          set n
  *2t                        to twenty
     oHE                    set H to the empty string
        Wn)                 while(n){
           oH+H             append to H
                `pl$--$n     get the nth character of the alphabet, decrement n before
                        }   }
                         _H print H reversed

Complimenti ad Adnan! Mi fai paura.

Qui puoi testare il tuo invio per vedere quanti caratteri devono essere rimossi.

setInterval(function(){r=document.querySelector("textarea").value;document.getElementById("output").innerHTML=r.length/6-r.split("").filter(function(x){return x=="_"}).length|0},20)

*{font-family:Consolas,monospace}textarea{width:100%;resize:none;height:auto;min-height:1.2em;}b{color:red;}

<textarea>Example Program</textarea><div>You must reveal <b id="output">n</b> characters.</div>

Fortran, 45 caratteri, sicuro

Uscita completa:

 !"$)0<Ka|

Il gatto ha tentato di romperlo qui

Codice (45 caratteri):

pr_gr_m____________________/___3____________

Codice programma:

program t;print*,(char(i**3/8+33),i=1,9);end

PHP, 46 caratteri, sicuro

Fonte:

for(_______________________=________________);

Emette una stringa lunga 84 caratteri:

!!"#$%&'()*+,-./0123456789::;<=>?@AABCDEEFGHIIJKLLMNNOPPQRRSTTUUVWWXXYYZZ[[\\]]^^__`

Suggerimento

Che cosa hai detto? Mia cugina è coinvolta?

Codice rivelato

Questo metodo è relativamente semplice poiché stampa fino a 64 caratteri a partire da chr(32). La parte oscura è che l'iteratore inon viene incrementato linearmente. Viene incrementato dal proprio valore di coseno che si tradurrà in caratteri ripetuti e mancanti.

for(;$i<64;)echo chr(32+$i+=cos(deg2rad($i)));
for(_______________________=________________);

CJam, 8 byte, crackato da Pietu1998

__:_____

stampe

%*;a|~

Puoi provare CJam online .

05AB1E , 13 personaggi, incrinato dalla chintopia

Sono un idiota. Ho dimenticato di implementare la funzione di alimentazione (-_-｡). Ecco il codice offuscato:

__D____<_____

Il mio codice originale era:

99DF2}r<F*}bR

Spiegazione:

99DF2}r<F*}bR

99            # Pushes 99
  D           # Duplicates the top item
   F }        # Creates a for loop: For N in range(0, 99)
    2         # Pushes 2 (this will be done 99 times)
      r       # Reverses the stack
       <      # Decrement on the last item
        F }   # Creates a for loop: For N in range(0, 98)
         *    # Multiplies the last two item of the stack, which now looks like
              # [2, 2, 2, 2, 2, 2, 2, 2, ...]. Basically we're calculating 2^99
           b  # Converts the last item to binary
            R # Reverses the last item of the stack

Questo produrrà:

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Sì, sono 99 zero seguiti da un 1.

Nota , ho implementato una funzione di alimentazione in questo momento. Quindi questo potrebbe essere fatto in sei byte:

Y99mbR

Python 3.4, 127 caratteri

Questo è il mio primo post in rame. Penso / spero che non sia troppo difficile o troppo ovvio.

Il codice offuscato:

_______inspect__________________getsource_____________________________________________print__________c*s_______________________

crea questo output (ci sono 5 spazi all'inizio; la lunghezza totale è di 7740 caratteri):

     """"""""""""(((((((((((((((((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))**********************...................................................................................................................;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;==============================[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooopppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppprrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Pyth, 17 personaggi, crackato da Pietu1998

Produzione:

""''''''''''''''''''''0000000000111111111122222222223333333333XXXXXXXXXX[[[[[[]]]]]]

Codice:

___________#____1

La mia soluzione:

Sjkm^dT%"'%#X"291

La soluzione di Pietu1998:

S`u]G6*T`t"#X0231

Malbolge, 254 personaggi, incrinato da Adnan

Codice:

_____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ _____ __

Produzione:

`AB\cd`

In un certo senso ho barato mettendo uno spazio per ogni 6 ° personaggio. Oh bene...

Codice crackato di Adnan:

('&%: ^"!65 4Xzyx w4-Qs rpo'K mlk"' ~Dfdc ba}v< ::8[Z XnVlq }0/mO ,*MbK JH^6# 4`C|0 ?U=Sw uPsaq L4on2 Mjjh, ged)c '<$$p ]!};Y WiVxS eRQ>= ).K]l Ij"Fh gfedc b,=;z L\q%H X3E2C /ng-k N*KJI 8%6#D ~2^Ai >g<<d tUr`6 oJ"!1 /|{CU f)d>b <A_^! \};Yj yUxTS dtsr` ML

Il codice originale:

bCBA@ ?>=<; :9876 54321 0/.-, +*)(' &%$#" !~}|{ zyxwv utsrq ponml kjihg fedcb a`_^] \[ZYX WVUTS RQPON MLKJI HGFED CBA@? >=<;: 9y165 43210 /.-,+ *)('& }C#"! ~wv<z \xwvu tsrqp onmlk jihgf e^$ba `_^W\ UyYXW VUTSR QPONM FKJIH GFEDC BA@9] =<;:9 27654 3210) M:

Ho barato di nuovo usando un generatore text-to-Malbolge per questo codice.

Mathematica 10.1, 98 caratteri, sicuro

L'output è qui . L'intero output ha 838.316 caratteri e una nuova riga finale.

Codice:

Print[""<>Chara__________________________________________________________________________________]

Sì, questo deve essere eseguito in 10.1. _{(suggerimento)} Il programma originale:

Print[""<>Characters@ToCamelCase@ExampleData@{"Text","DonQuixoteIEnglish"}~SortBy~ToCharacterCode]

MATL , 8 caratteri, sicuro

Speriamo che la versione stabile del compilatore che funzioni in Octave arrivi presto. Nel frattempo, questo commit GitHub funziona e, in particolare, esegue il codice originale che produce l'output indicato

Questa presentazione conta come pubblicata il 28 dicembre 2015, alle 15:30 UTC

Produzione:

$**0016688??@HHQ

Codice (8 caratteri):

_:______

Soluzione

6:9tX*Sc

Cosa fa:

6:9          % numeric vector [6 7 8 9]
t            % duplicate
X*           % Kronecker tensor product
S            % sort in ascending order 
c            % convert to char. Implicit display

Labyrinth , 5 bytes, Cracked by Adnan

_____

stampe

000000

Il mio codice originale era:

<!!@ 

Nota lo spazio finale.

Suppongo che avrei dovuto cercare più personaggi e svelarne uno !, perché la soluzione di Adnan cresce in modo lineare quando si aggiunge altro !, mentre la mia cresce in modo quadratico.

PHP, 28 caratteri

<?=________________________;

Emette la stringa

abcdefghijklmnopqrstuvwxyz

ES6, 17 personaggi, incrinato da Cᴏɴᴏʀ O'Bʀɪᴇɴ

__=____=_________

Questa è una funzione che restituirà la stringa

11233

JavaScript, 83 caratteri, crackato da Martin Büttner

Produzione

Hi~~~

Codice

_=____r____=u____=__s__=_________=__________________u_______A__________e______"_~_"

L'output è nella console JS di un browser come Chrome / Firefox.
Codice originale (che potrebbe non essere valido):

q=w=e=r=t=y=u=i=o=p=s=d=f=g=h=j=k=l=z=x=c=v=b=n=m="Huh"[0]+"Alarms in here"[7]+"~~~"

Pyth, 6 personaggi, crackizzati da Pietu1998

Codice:

S_____

Produzione:

.0113345678888999

Puoi provare Pyth qui

JavaScript ES6, 134 caratteri

Eh ragazzo, è stato divertente. In bocca al lupo!

_=_=_____l____.______.________(___}__;___=______ru____"_____+_[________]______!____]__[_________e________.__U_________)__________\_____

Uscite:

((((((()))))))+...000000000000000000002233=>AAAAAAAAAAABBBBBCCCCCCCCCCCCCCCCCCDDDDDDDEEEEEEEEEEEEEEEEEEEFFFFFFFGHIIIIIIIIIIIIIIIIJJJJLLMMNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOPRRRRRRRSSSSTTTTTTTTTTTTTTTTTTTTTTTUUUUUUUUUVVVVVVXXY[[[[[[[[]]]]]]]]````ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeffffffffffffffffffffffffffffffffffffffffffffffffffffffffiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiinnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu{{{{{{}}}}}}

CJam, 12 personaggi, Cracked di jimmy23013

Produzione

#$%&'()*+,-./:;<=>?@[\]^_`

Codice

_:____#_____

Seriamente , 7 byte, incrinato da Martin Büttner

______S

Produzione:

   deeknnoow

Non dovrebbe essere troppo difficile, anche se il risultato non è esattamente quello che ti aspetteresti.

Python 3, 58 personaggi, incrinato da Mitch Schwartz

Codice:

______________print(_______(_______________________)_____)

stringa di importazione; print (''. join (ordinato (string.printable)) [5:])

Produzione:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Befunge, 11 personaggi, crackato (in funge-98) da MegaTom

Produzione:

1223788

Codice offuscato:

________.__

Tutta una riga, poiché le regole vietano le nuove righe. Testato utilizzando http://www.quirkster.com/iano/js/befunge.html .

Modifica: questo è legalmente crackato dal momento che non ho specificato una versione, ma nota che c'è ancora una soluzione Befunge-93.

Perl 5, 30 byte, incrinato da Adnan

Codice:

print_________________________

Produzione:

9:;@AFGHLMNRSTYZ_`a

Cracked:

Adnan ha trovato una crepa banale : ovviamente, non ho pensato a questo enigma abbastanza bene. Ne ho composto un altro invece.

Python 2, 62 caratteri, Cracked by Adnan

______________________________________________________________
         | |   ||                  |  |  ||

Sembra un po 'un tavolo.

Questo genera la stringa abcde.

Codice di Adnan:

print "ab_c_de___".replace("_","")#___________________________

Il mio codice:

f=lamda _,__,___:"abcde"+'f'*sum(_,__,___)*000;print f(1,2,3);