Nota: questa sfida è terminata. Le iscrizioni sono ancora benvenute ma non possono vincere.

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

Scrivi un codice che genera l'intero 1. Se aggiungi, rimuovi o sostituisci un singolo carattere (di tua scelta), il codice dovrebbe generare l'intero 2. Cambia un altro carattere (lo stesso o un altro) e il codice dovrebbe essere emesso 3. Continuare così per quanto è possibile, ma fino a un massimo di 10. ans = 1Sono accettati formati di output predefiniti come . È possibile ignorare l'output su STDERR (o equivalente).

Devi rivelare la lingua, il conteggio dei byte del tuo codice iniziale, il numero di numeri interi per cui lavora, nonché un numero opzionale di caratteri del codice iniziale. Nota: non devi rivelare alcun personaggio, ma ricorda che i personaggi rivelatori potrebbero rendere più difficile per i ladri in quanto devono usare lo stesso personaggio nella stessa posizione. Puoi scegliere quale personaggio utilizzare per indicare i caratteri non rivelati (ad esempio il trattino basso), ma assicurati di specificarlo.

Gli sbirri possono fornire il codice non crackato dopo una settimana e chiamare l'invio "SICURO". L'invio vincente sarà l'invio non crackato più breve che produce il numero 10. Se nessun invio non crackato è in grado di stampare 10, vincerà il codice più corto che produce 9 e così via. Nota che i ladri non devono apportare le stesse modifiche a te, e non devono riprodurre il codice esatto (a meno che non riveli tutti i caratteri). Devono solo riprodurre l'output.

Le iscrizioni pubblicate dopo il 24 novembre sono benvenute ma non sono idonee per la vittoria (perché probabilmente ci saranno meno ladri in giro).

Esempio di post:

Il seguente post è un invio nella lingua MyLang, è lungo 9 byte e funziona per i numeri 1 - 8.

MyLang, 9 byte, 8 numeri

Questa sottomissione funziona per 1 - 8. caratteri Non Rivelati sono indicate con un carattere di sottolineatura: _.

abc____i

Classifica

Dichiarazione di non responsabilità: la classifica non viene testata e gli invii non crackati potrebbero non essere visualizzati nell'elenco.

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><style>table th,table td{padding: 5px;}th{text-align: left;}.score{text-align: right;}table a{display: block;}.main{float: left;margin-right: 30px;}.main h3,.main div{margin: 5px;}.message{font-style: italic;}#api_error{color: red;font-weight: bold;margin: 5px;}</style> <script>QUESTION_ID=99546;var safe_list=[];var uncracked_list=[];var n=0;var bycreation=function(x,y){return (x[0][0]<y[0][0])-(x[0][0]>y[0][0]);};var byscore=function(x,y){return (x[0][1]>y[0][1])-(x[0][1]<y[0][1]);};function u(l,o){jQuery(l[1]).empty();l[0].sort(o);for(var i=0;i<l[0].length;i++) l[0][i][1].appendTo(l[1]);if(l[0].length==0) jQuery('<tr><td colspan="3" class="message">none yet.</td></tr>').appendTo(l[1]);}function m(s){if('error_message' in s) jQuery('#api_error').text('API Error: '+s.error_message);}function g(p){jQuery.getJSON('//api.stackexchange.com/2.2/questions/' + QUESTION_ID + '/answers?page=' + p + '&pagesize=100&order=desc&sort=creation&site=codegolf&filter=!.Fjs-H6J36w0DtV5A_ZMzR7bRqt1e', function(s){m(s);s.items.map(function(a){var he = jQuery('<div/>').html(a.body).children().first();he.find('strike').text('');var h = he.text();if (!/cracked/i.test(h) && (typeof a.comments == 'undefined' || a.comments.filter(function(b){var c = jQuery('<div/>').html(b.body);return /^cracked/i.test(c.text()) || c.find('a').filter(function(){return /cracked/i.test(jQuery(this).text())}).length > 0}).length == 0)){var m = /^\s*((?:[^,;(\s]|\s+[^-,;(\s])+).*(0.\d+)/.exec(h);var e = [[n++, m ? m[2]-0 : null], jQuery('<tr/>').append( jQuery('<td/>').append( jQuery('<a/>').text(m ? m[1] : h).attr('href', a.link)), jQuery('<td class="score"/>').text(m ? m[2] : '?'), jQuery('<td/>').append( jQuery('<a/>').text(a.owner.display_name).attr('href', a.owner.link)) )];if(/safe/i.test(h)) safe_list.push(e);else uncracked_list.push(e);}});if (s.items.length == 100) g(p + 1);else{var s=[[uncracked_list, '#uncracked'], [safe_list, '#safe']];for(var i=0;i<2;i++) u(s[i],byscore);jQuery('#uncracked_by_score').bind('click',function(){u(s[0],byscore);return false});jQuery('#uncracked_by_creation').bind('click',function(){u(s[0],bycreation);return false});}}).error(function(e){m(e.responseJSON);});}g(1);</script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=7509797c03ea"><div id="api_error"></div><div class="main"><h3>Uncracked submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="uncracked"></tbody></table><div>Sort by: <a href="#" id="uncracked_by_score">score</a> <a href="#" id="uncracked_by_creation">creation</a></div></div><div class="main"><h3>Safe submissions</h3><table> <tr> <th>Language</th> <th class="score">Score</th> <th>User</th> </tr> <tbody id="safe"></tbody></table></div>

Esagonia , 18 byte, 10 numeri, SICURO

Questa sottomissione funziona per 1 - 10. Non Rivelati i caratteri sono indicate con un carattere di sottolineatura: _.

.__{_]5[$@.;=@$!!1

Puoi provare Hexagony online qui.

La mia soluzione:

1:   .<[{8]5[$@.;=@$!!10
2:   .<[{8]5[$@);=@$!!10
3:   2<[{8]5[$@);=@$!!10
4:   3<[{8]5[$@);=@$!!10
5:   4<[{8]5[$@);=@$!!10
6:   5<[{8]5[$@);=@$!!10
6:   7<[{8]5[$@);=@$!!10
8:   7<[{8]5[$@);=@$!!10
9:   8<[{8]5[$@);=@$!!10
10:  9<[{8]5[$@);=@$!!10

Esagonale per uscita 1:

Provalo online!

Full Hex:
  . < [ 
 { 8 ] 5
[ $ @ . ;
 = @ $ ! 
  ! 1 0

Important parts:
  . < .
 . 8 . 5
. $ @ . ;
 . . $ .
  . 1 .

1. Al <limite della memoria è 0, quindi si alza.
2. Colpi 1
3. Salta a 5
4. Salta 8, ma è invertito< e 8riprende la via del ritorno.
5. Colpi 5 nuovo
6. Salta 1
7. Colpisce il < a questo punto, il valore della memoria è 1585 che, mod 256, sembra essere ASCII1
8. Finalmente stampa ed esce con ;@.

Esagonale per uscita 2:

Provalo online!

Important parts:
  . < .
 . 8 . 5
. $ @ ) ;
 . . $ .
  . 1 .

Questo segue lo stesso percorso, ma sulla via del ritorno colpisce un )che incrementa il bordo della memoria a 1586, o2 .

Esagonale per uscita 3-9:

Provalo online!

Important parts:
  2 < [
 . . ] .
. $ . ) .
 . @ . !
  . 1 .

1. Colpisce il 2
2. Ora il limite della memoria è positivo quando arriva < , quindi si abbassa.
3. Il ] cambia il puntatore all'istruzione, ma si viene subito indietro con[
4. ) incrementi a 3
5. ! stampe 3
6. $ viene lasciato tra i primi due numeri, quindi saltiamo alla fine (@ )
7. 1 cambia il bordo della memoria, ma non importa adesso.
8. < riflette il puntatore indietro.
9. Ancora una volta 1non importa perché abbiamo colpito @per terminare il programma.

Retina , 2 byte, 10 numeri, Cracked

_1

Funziona da 1 a 10, _è un personaggio nascosto. Questo non dovrebbe essere troppo difficile, ma spero che fornisca un puzzle un po 'interessante. :)

Puoi provare Retina online qui.

Ottava, 55 byte, 10 numeri, incrinato

(o__(O_o_(@(__o)o__-O}_)_(0<O,{_(_o_O-1)+1_@(_1}_)(__o_

_ è il personaggio sconosciuto.

Soluzione

(o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o)% poi cambiando l'ultimo 0in 1,2,3ecc.

Dato x, questo calcola ricorsivamente x+1. È composto principalmente da due funzioni anonime. Uno fornisce ifun'affermazione per ancorare la ricorsione:

if_ = @( boolean, outcomes) outcomes{ 2 - boolean}();

questo sta solo abusando del fatto che un valore booleano valuta 0o 1. Questa funzione accetta un valore booleano e una matrice di celle di due funzioni e valuta l'una o l'altra di queste due funzioni in base al valore booleano. La seconda parte è l'effettiva ricorsione:

plus_one = @(n,f) if_(0<n ,{@()f(n-1)+1, @()1})

poiché una funzione anyonmous è anonima, non è possibile accedervi direttamente da itsefl. Ecco perché abbiamo bisogno di un secondo argomentofprimo. In seguito forniremo un handle alla funzione stessa come secondo argomento, quindi un'ultima funzione sarebbe simile

plus_one_final = @(n)plus_one(n,plus_one);

a questa : Quindi in questa notazione la mia presentazione diventa:

(plus_one=@(n,f)(@(boolean,outcomes)outcomes{2-boolean}())(0<n,{@()f(n-1)+1,@()1}))(n,f)

Ho chiesto informazioni sugli ancoraggi di ricorsione per funzioni anonime in MATLAB qualche tempo fa su StackOverflow .

Python 2, 9 byte, 10 numeri, crackato

print 8/8

Nessun carattere nascosto. Puoi spezzarlo senza forzare brutalmente?

Perl, 12 byte, 10 numeri, Cracked!

I trattini bassi rappresentano personaggi sconosciuti.

____;say__-9

Probabilmente abbastanza facile, e non mi sorprenderebbe se ci fossero più soluzioni. Tuttavia, potrebbe essere divertente rompere.

(La soluzione prevista era la stessa del crack. Questo è fondamentalmente solo un problema nell'assegnare 10 a una variabile in quattro caratteri, il che è sorprendentemente difficile in Perl; a differenza di molti linguaggi del golf, non ha una variabile che inizia utile da 10.)

Perl, 46 byte, 10 numeri, sicuro

Il problema

__b_b_\__}_b_b_b_0_;
$b[0]=10;$b{0}=1;say$b[0]

I problemi più brevi tendono a risolversi rapidamente, quindi ho pensato di provarne uno più lungo. I più lunghi tendono anche a rompersi se le persone lasciano abbastanza spazio per intrufolarsi in qualcosa di cattivo sayo simile exit, quindi tutti gli spazi vuoti qui sono brevi. I caratteri nascosti vengono rappresentati usando_ .

La mia soluzione

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=1;say$b[0]

Per stampare 2, 3, ecc., Fino a 9, continuare a modificare il numero assegnato a $b{0} nella seconda riga (ad es $b{0}=2. $b{0}=3, Ecc.). Il programma per 9 è simile al seguente:

sub b{\@_}*b=b$b{0};
$b[0]=10;$b{0}=9;say$b[0]

Quindi per produrre 10, commenta la prima riga anteponendole un #personaggio.

Spiegazione

La prima cosa da notare è che la soluzione non è davvero golf a parte rimuovere lo spazio bianco: se lo disponiamo con uno spazio più leggibile, otteniamo questo:

sub b { \@_ }
*b = b $b{0};
$b[0] = 10;
$b{0} = 1;
say $b[0];

Normalmente, quando si accede agli argomenti di una subroutine in Perl, lo si fa copiandoli da @_. C'è una buona ragione per questo: @_alias gli argomenti forniti dalla subroutine (quindi, per esempio, (sub { $_[0] = 3 })->($x)verranno assegnati a$x ), qualcosa che normalmente non è desiderabile.

Sebbene @_possa sembrare magico, in realtà sta solo usando una funzionalità standard degli interni Perl (che è prontamente disponibile da XS ma si presenta solo in alcuni casi strani in Perl puro, come se @_stesso): un array non memorizza i suoi elementi direttamente , ma piuttosto per riferimento. Pertanto, quando chiamiamo bnella seconda riga in basso, Perl genera un array (chiamandolo @_) il cui primo elemento è un riferimento allo stesso archivio che $b{0}utilizza. (I valori di hash sono anche memorizzati per riferimento; $ _ [0] e $ b {0} fanno entrambi riferimento allo stesso archivio a questo punto.) Poiché @_non sta facendo nulla di speciale da un punto di vista interno, possiamo prendere un riferimento ad esso, proprio come con qualsiasi altro array, facendolo sopravvivere alla subroutine in cui è definito.

Le variabili Perl si riferiscono anche alla memorizzazione dei dati per riferimento. Molto tempo fa, le persone usavano il codice come *x = *y;impostare $xcome alias $y(facendo loro riferimento alla stessa cosa), allo stesso modo @xcome un alias @y, %xcome un alias %ye così via. Ciò rompe piuttosto l'invariante che le variabili con nomi simili non devono agire in modo simile, quindi il moderno Perl offre un'alternativa; l'assegnazione di un riferimento a un typeglob sovrascrive solo la variabile che corrisponde al tipo di riferimento (quindi *x = \%yalias farebbe %xriferimento allo stesso archivio %yma lascerebbe, diciamo, $xsolo). Questa sintassi, in particolare, non importa se l'archiviazione a cui stai alias ha un nome, quindi quando assegniamo il valore restituito dib(che è un riferimento di matrice che mantiene @_viva la matrice precedentemente chiamata ) *b, ciò che accade è che@bviene modificato in alias l'elenco degli argomenti nella chiamata a b(lasciando %binvariato). Ciò significa, in particolare, che $b[0]e $b{0}ora indicano lo stesso spazio di archiviazione e l'assegnazione a uno cambierà quindi l'altro. Tutto da allora in poi è completamente semplice.

La documentazione di Perl non parla davvero di questo tipo di dettagli, quindi non sono sorpreso che qualcuno abbia avuto il crack; la natura di @_non essere come gli altri array non è qualcosa che è davvero enfatizzato, e la maggior parte degli stili di codifica mira a minimizzare gli effetti che questo ha piuttosto che amplificarli.

JavaScript, 30 byte, 10 numeri, crackato

alert(Array(_)________.length)

Non dovrebbe essere troppo difficile, ma speriamo che sia abbastanza difficile fornire una sfida. :) I caratteri non rivelati sono contrassegnati con _.

Perl, 14 byte, 10 numeri, Incrinato

say_!"___"%""_

Funziona da 1 a 10. _ sono personaggi nascosti.

Penso che questo non dovrebbe essere troppo difficile da decifrare. Ne ho uno più difficile, per 22 byte, lo posterò se questo è rotto.

say"!"=~y"%""c

E sostituire la "!"da una stringa di lunghezza del numero che si desidera stampare, per esempio !, !!,!!! , etc.

Tuttavia, ais523 ha trovato un altro modo:

say"!"+1#"%""r

JavaScript, 22 byte, 10 numeri, crackato

Probabilmente piuttosto facile da decifrare.

alert(__14_337__xc_de)

_ essere un personaggio nascosto

Ottava, 17 byte, 10 numeri, Cracked

_od(3_13_13_7_1_)

Soluzione originale

mod(3*1361357,10)
...
mod(3*1361357,17)
mod(3*1361397,17)
mod(9*1361397,17)

_ è il personaggio nascosto.

Gelatina , 7 byte , 10 numeri, incrinata

“1‘ỌȮḊ‘

Nessun carattere jolly.

Il crack ottenuto (per usare una valutazione con una discussione) è stato, come molti sembrano essere in questo thread, non quello previsto.

La crepa prevista era:

“1‘ỌȮḊ‘ - (prints 1)
“1‘     - code page index list of characters "1": [49]
   Ọ    - cast to ordinals: ['1']
    Ȯ   - print (with no line feed) and return input: effectively prints "1"
        -     (but if left at this would then implicitly print another "1")
     Ḋ  - dequeue: []
      ‘ - increment (vectorises): []
        - implicit print: prints ""

“1‘ỌŒḊ‘ - (prints 2)
“1‘Ọ    - as above: ['1']
    ŒḊ  - depth: 1
      ‘ - increment: 2
        - implicit print: prints "2"

“1‘ỌŒḊ‘‘ - (prints 3)
“1‘ỌŒḊ‘  - as above: 2
       ‘ - increment: 3
         - implicit print: prints "3"

... keep adding an increment operator to print 4 - 10.

Befunge-93, 11 byte, 10+ numeri, Cracked

Questa presentazione funziona per almeno 1 - 10. I caratteri non rivelati sono indicati con □.

□□5:**-□-.@

Provalo online

Devo dire che sono rimasto impressionato dal fatto che due persone potrebbero trovare soluzioni indipendenti per questo, nessuna delle quali era quella che mi aspettavo. Mentre Martin è arrivato per primo, sto dando la "vittoria" a Sp3000 in quanto la loro soluzione è più portatile.

Questa era la mia soluzione prevista però:

g45:**-2-.@
g45:**-1-.@
g45:**-1\.@
g45:**-1\+.@
g45:**-2\+.@
...
g45:**-7\+.@

Poiché un underflow dello stack in Befunge viene interpretato come 0, il ggiusto legge da 0,0 restituendo il valore ASCII di 'g', ovvero 103. 45:**-sottrae 100, dandoti 3. Quindi 2-ti dà 1.

Per la terza iterazione, il -(sottrarre ) viene modificato in \un'istruzione (di scambio), quindi il 3 diventa la voce dello stack più in alto. E nell'iterazione quattro, +viene inserita un'istruzione (aggiungi), aggiungendo così il 3 all'1 dando 4.

R, 21 bytes, 10 numbers Cracked

__i___________i______

Works for 10 numbers. _ is hidden character.

Original solution:

which(letters%in%"a")
which(letters%in%"b")
etc.

Ruby, 16 bytes, 10 numbers, cracked by xsot

x=##/=#%#
)
###x

# is any character.

Octave, 32 bytes, 10 numbers. Cracked

_n_(isprime(floor(s____i__ i____

_ is a hidden character.

You can try Octave online here.

Original solution:

1: nnz(isprime(floor(sqrt(i):pi')))

2: nnz(isprime(floor('sqrt(i):pi')))

3: nnz(isprime(floor('sqrt(i):pia')))

4: nnz(isprime(floor('sqrt(i):piaa')))

...

Octave, 17 bytes, 10 numbers, Cracked

_i_(__i__(2_5_))

Unrevealed characters are marked with _.

Intended solution:

    fix(asind(2/59))
    fix(asind(3/59))
    fix(asind(4/59))
    fix(asind(5/59))
    fix(asind(6/59))
    fix(asind(7/59))
    fix(asind(8/59))
    fix(asind(9/59))
    fix(asind(9/55))
    fix(asind(9/50))

Octave, 19 bytes, 10 numbers, cracked

__sca__1_)___'-_6_'

_ is the hidden character.

Intended solution:

pascal(10)('a'-96)'

05AB1E, 5 bytes, 10 numbers, cracked!

Not very hard, but a fun one :)

_[==_

_ is a random character. Uses the CP-1252 encoding. Try it online!

05AB1E, 6 bytes, 10 numbers, cracked

Attempt 2, this time without the three-char string :p.

_ [==_

_ is a random character. Uses the CP-1252 encoding. Try it online!

JavaScript, 22 bytes, 10 numbers, cracked

alert(0_6_4_>_0_2_0_7)

_ is the hidden character.

Hint about the intended solution

The character that needs to be changed to generate all numbers is always the same.

JavaScript 21 Bytes, 10 Numbers Cracked

alert(b_oa_"3____1"))

Unrevealed characters are marked with _

Cracked

My Version:

alert(btoa|"3"&("1"))
alert(btoa|"3"^("1"))
alert(btoa|"3"^("0"))
alert(btoa|"3"^("7"))
alert(btoa|"2"^("7"))
alert(btoa|"1"^("7"))
alert(btoa|"0"^("7"))
alert(btoa|"0"^("8"))
alert(btoa|"0"^("8"))
alert(btoa|"2"^("8"))

Python 3, 19 bytes, 10 numbers, cracked

print(??bin()?????)

Unrevealed characters are marked with ?. Tested in Python 3.5.2.

Python 3, 16 bytes, 10 numbers, cracked

print(?%??f?r?t)

Unrevealed characters are marked with ?. This is probably a bit easy since there's only five question marks, but I'm hoping it'll be a fun one.

C#, 90 bytes, 10 numbers, cracked

using ______________________________________________;class C{static void Main(){_______;}}

I honestly have no idea how hard this is to crack.

Edit: Oops, transcription error. One _ too few after using.

Now cracked by Hedi, who found the intended (barring the class name) solution.

JavaScript 33 Bytes, 10 Numbers Cracked x2

Oops I post posted my line for generating 10 Which Hedi cracked as though it was for 1

alert(_to__"_Xc0__0_B6____Zp=="))

Version intended to post for generating 1

alert(_to__"_Xc0__0_Bf____Zp=="))

Unrevealed characters are marked with _

alert(btoa|"0Xc0"-0xBf|!("Zp=="))
alert(btoa|"0Xc0"-0xBe|!("Zp=="))
alert(btoa|"0Xc0"-0xBd|!("Zp=="))
alert(btoa|"0Xc0"-0xBc|!("Zp=="))
alert(btoa|"0Xc0"-0xBb|!("Zp=="))
alert(btoa|"0Xc0"-0xBa|!("Zp=="))
alert(btoa|"0Xc0"-0xB9|!("Zp=="))
alert(btoa|"0Xc0"-0xB8|!("Zp=="))
alert(btoa|"0Xc0"-0xB7|!("Zp=="))
alert(btoa|"0Xc0"-0xB6|!("Zp=="))

Python, 10+ numbers, 61 bytes, Cracked!

Here was the code I posted:

try:x
except:print(__import__('sys').??c??n??()[????b????e???

The original code was:

try:x
except:print(__import__('sys').exc_info()[2].tb_lineno)

Basically, it throws an error ('x' is not defined) and then prints the line the error was found on. So, just keep adding newlines at the beginning to increment the number.

I knew it wouldn't be hard to crack - I just wanted a funny way to print numbers - but I wasn't expecting Sp3000 to get it so fast, that's some pro skills!

05AB1E, 11 bytes, Cracked!

3628801__0_

Works from 1-10. _ is a hidden character.

Intended Solution:

3628801R¬0+ # 1
3628801R¬1+ # 2
3628801R¬2+ # 3
3628801R¬3+ # 4
3628801R¬4+ # 5
3628801R¬5+ # 6
3628801R¬6+ # 7
3628801R¬7+ # 8
3628801R¬8+ # 9
3628801R¬9+ # 10

Octave, 24 bytes, 9 numbers, cracked

_a__repmat(__one___,__)_

_ is a hidden character.

(Inspired by @LuisMendo's challenge.)

JavaScript, 9 bytes, 10 numbers, Cracked

alert(__)

_ is the hidden character.

Octave, 25 bytes, 9 numbers. Cracked

__a__repmat(__one___,__)_

_ is a hidden character.