Nota: Este desafio está concluído. As inscrições ainda são bem-vindas, mas não podem vencer.

Este é o tópico dos policiais. A linha dos ladrões vai aqui .

Escreva um código que produz o número inteiro 1. Se você adicionar, remover ou substituir um único caractere (de sua escolha), o código deverá gerar o número inteiro 2. Altere mais um caractere (o mesmo ou outro) e o código deve ser exibido 3. Continue dessa maneira o máximo que puder, mas no máximo até 10. Formatos de saída padrão, como ans = 1são aceitos. Você pode ignorar a saída para STDERR (ou equivalente).

Você deve revelar o idioma, a contagem de bytes do seu código inicial, o número de números inteiros para os quais trabalha e um número opcional de caracteres do código inicial. Nota: Você não precisa revelar nenhum personagem, mas lembre-se de que revelar personagens pode tornar mais difícil para os ladrões, pois eles devem usar o mesmo personagem na mesma posição. Você pode escolher qual caractere usar para denotar caracteres não revelados (por exemplo, sublinhado), mas certifique-se de especificar isso.

Os policiais podem fornecer o código sem quebra após uma semana e chamar a submissão de "SAFE". O envio vencedor será o envio mais curto e sem rachaduras que produz o número 10. Se nenhum envio sem rachaduras conseguir imprimir 10, o código mais curto que produz 9 vencerá e assim por diante. Observe que os ladrões não precisam fazer as mesmas alterações que você e não precisam reproduzir o código exato (a menos que você revele todos os caracteres). Eles devem reproduzir apenas a saída.

As inscrições postadas depois de 24 de novembro são bem-vindas, mas não qualificadas para a vitória (porque provavelmente haverá menos ladrões por aí).

Exemplo de postagem:

A postagem a seguir é um envio no idioma MyLang, tem 9 bytes de comprimento e funciona para os números de 1 a 8.

MyLang, 9 bytes, 8 números

Esta submissão funciona para 1 - 8. caracteres Não Revelados são indicadas com um sublinhado: _.

abc____i

Entre os melhores

Isenção de responsabilidade: a tabela de classificação não é testada e os envios sem rachaduras podem não aparecer na lista.

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

Hexagonia , 18 bytes, 10 números, SEGURO

Esta submissão funciona para 1 - 10. caracteres Não Revelados são indicadas com um sublinhado: _.

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

Você pode experimentar o Hexagony online aqui.

Minha solução:

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

Hex para saída 1:

Experimente Online!

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

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

1. Na <borda da memória é 0, por isso aparece.
2. Exitos 1
3. Salta para 5
4. Salta 8, mas é revertida <e pega 8o caminho de volta.
5. Bate 5novamente
6. Salta sobre 1
7. Atinge o <ponto, o valor da memória é 1585 que, mod 256, passa a ser ASCII1
8. Finalmente imprime e sai com ;@.

Hex para saída 2:

Experimente Online!

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

Isso segue o mesmo caminho, mas, no caminho de volta, atinge um valor )que aumenta a borda da memória para 1586 ou 2.

Hex para saída 3-9:

Experimente Online!

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

1. Atinge o 2
2. Agora, a borda da memória é positiva quando chega <, então diminui.
3. A ]muda o ponteiro de instrução, mas é imediatamente volta com[
4. ) incrementa para 3
5. ! Impressões 3
6. $sobra dos dois primeiros números, então pulamos o final ( @)
7. 1 altera a borda da memória, mas isso não importa agora.
8. < reflete o ponteiro de volta.
9. Novamente 1, não importa, porque chegamos @ao final do programa.

Retina , 2 bytes, 10 números, Rachado

_1

Funciona de 1 a 10, _é um personagem oculto. Isso não deve ser muito difícil, mas espero que forneça um quebra-cabeça um tanto interessante. :)

Você pode experimentar o Retina online aqui.

Oitava, 55 bytes, 10 números, quebrado

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

_ é o personagem desconhecido.

Solução

(o=@(O,o)(@(O,o)o{2-O}())(0<O,{@()o(O-1)+1,@()1}))(0,o)% então alterando o último 0para 1,2,3etc

Dado x, isso calcula recursivamente x+1. É composto principalmente de duas funções anônimas. Um fornece uma ifdeclaração para ancorar a recursão:

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

Isso está apenas abusando do fato de que um valor booleano é avaliado como 0ou 1. Essa função aceita um valor booleano e uma matriz de células de duas funções e avalia uma ou outra dessas duas funções, dependendo do valor booleano. A segunda parte é a recursão real:

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

como uma função anônima é anônima, você não pode acessá-la diretamente do itsefl. É por isso que precisamos de um segundo argumentofprimeiro. Posteriormente, forneceremos um identificador para a função em si como um segundo argumento, para que uma função final tenha a seguinte aparência:

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

Então, nessa notação, minha submissão se torna:

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

Eu perguntei sobre âncoras de recursão para funções anônimas no MATLAB há algum tempo no stackoverflow .

Python 2, 9 bytes, 10 números, quebrado

print 8/8

Não há caracteres ocultos. Você pode quebrá-lo sem força bruta?

Perl, 12 bytes, 10 números, rachado!

Os sublinhados representam caracteres desconhecidos.

____;say__-9

Provavelmente fácil, e não me surpreenderia se houvesse várias soluções. Ainda assim, pode ser divertido decifrar.

(A solução pretendida era a mesma do crack. Isso é fundamentalmente apenas um problema de atribuir 10 a uma variável em quatro caracteres, o que é surpreendentemente difícil no Perl; ao contrário de muitos idiomas de golfe, ele não tem uma variável que comece com utilidade em 10.)

Perl, 46 bytes, 10 números, seguro

O problema

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

Os problemas mais curtos tendem a ser resolvidos rapidamente, então pensei em tentar um mais longo. Os mais longos também tendem a ficar rachados se as pessoas deixarem uma folga suficiente para esgueirar-se por algo impertinente sayou não exit, então todas as lacunas aqui são curtas. Caracteres ocultos são representados usando_ .

Minha solução

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

Para imprimir 2, 3, etc., até 9, sempre a mudar o número atribuído a $b{0} na segunda linha (isto é $b{0}=2, $b{0}=3, etc.). O programa para 9 fica assim:

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

Depois, para produzir 10, comente a primeira linha acrescentando um #caractere a ela.

Explicação

A primeira coisa a se notar é que a solução não é realmente eficiente, além de remover o espaço em branco: se colocarmos em um espaço em branco mais legível, obtemos o seguinte:

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

Normalmente, quando você acessa os argumentos de uma sub-rotina no Perl, faz isso copiando-os de @_. Há uma boa razão para isso: @_alias os argumentos que a sub-rotina é fornecida (por exemplo, (sub { $_[0] = 3 })->($x)atribuirá a$x ), algo que normalmente não é desejável.

Embora @_possa parecer mágico, na verdade, ele está apenas usando um recurso padrão dos componentes internos do Perl (que está prontamente disponível no XS, mas só aparece em alguns casos estranhos no Perl puro, como @_ele próprio): uma matriz não armazena seus elementos diretamente , mas sim por referência. Assim, quando chamamos bna segunda linha abaixo, o Perl gera uma matriz (chamando-a @_) cujo primeiro elemento é uma referência ao mesmo armazenamento que $b{0}usa. (Os valores de hash também são armazenados por referência; $ _ [0] e $ b {0} estão referenciando o mesmo armazenamento neste momento.) Como @_não está fazendo nada de especial do ponto de vista interno, podemos fazer uma referência para isso, como poderíamos com qualquer outra matriz, fazendo com que ela sobrevivesse à sub-rotina em que está definida.

Variáveis ​​Perl também se referem ao armazenamento de dados por referência. Há muito tempo, as pessoas costumavam usar código como *x = *y;definir $xum alias para $y(via fazendo com que eles fizessem referência à mesma coisa), da mesma forma @xque um alias para @y, %xcomo um alias para %ye assim por diante. Isso acaba com a invariante de que variáveis ​​com nomes semelhantes não precisam agir de maneira semelhante; portanto, o Perl moderno fornece uma alternativa; atribuir uma referência a um tipo de barra de texto substitui apenas a variável que corresponde ao tipo da referência (portanto *x = \%y, o alias %xapontaria para o mesmo armazenamento, %ymas deixaria, digamos, (que é uma referência de matriz que mantém a matriz anteriormente chamada ativa) , para que acontece é que$x paz). Essa sintaxe não se importa em saber se o armazenamento para o qual você está usando o alias tem um nome; portanto, quando atribuímos o valor de retorno deb@_*b@bé alterado para alias a lista de argumentos da chamada para b(enquanto permanece %binalterada). Isso significa, notavelmente, que $b[0]e $b{0}agora aponte para o mesmo armazenamento, e atribuir a um mudará o outro. Tudo a partir de então é completamente direto.

A documentação do Perl realmente não fala sobre esse tipo de detalhe, então não estou surpreso que alguém tenha entendido; a natureza de @_não ser exatamente como outras matrizes não é algo realmente enfatizado, e a maioria dos estilos de codificação visa minimizar os efeitos que isso tem, em vez de amplificá-los.

JavaScript, 30 bytes, 10 números, quebrado

alert(Array(_)________.length)

Não deve ser muito difícil, mas espero que seja apenas o suficiente para oferecer um desafio. :) Os caracteres não revelados estão marcados com _.

Perl, 14 bytes, 10 números, Rachado

say_!"___"%""_

Trabalhos de 1 a 10. _são caracteres ocultos.

Eu acho que isso não deve ser muito difícil de quebrar. Eu tenho um mais difícil, por 22 bytes, vou postar se este estiver quebrado.

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

E substituir o "!"por uma corda do comprimento do número que deseja imprimir, por exemplo !, !!, !!!, etc.

No entanto, o ais523 encontrou outra maneira:

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

JavaScript, 22 bytes, 10 números, quebrado

Provavelmente fácil de quebrar.

alert(__14_337__xc_de)

_ sendo um personagem oculto

Oitava, 17 bytes, 10 números, Rachado

_od(3_13_13_7_1_)

Solução original

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

_ é o personagem oculto.

Geléia , 7 bytes , 10 números, rachado

“1‘ỌȮḊ‘

Nenhum curinga.

A falha alcançada (usar uma avaliação com um argumento) não foi, como muitos parecem estar nesse segmento, a pretendida.

O crack pretendido foi:

“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 bytes, 10+ números, Rachado

Este envio funciona para pelo menos 1 - 10. Caracteres não revelados são indicados com □.

□□5:**-□-.@

Experimente online

Devo dizer que fiquei impressionado que duas pessoas pudessem encontrar soluções independentes para isso, nenhuma das quais era o que eu estava esperando. Enquanto Martin chegou lá primeiro, estou dando a "vitória" ao Sp3000 pois a solução deles é mais portátil.

Esta foi a minha solução pretendida:

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

Como um estouro de pilha no Befunge é interpretado como 0, gapenas lê 0,0, retornando o valor ASCII de 'g', ou seja, 103. 45:**-subtrai 100, fornecendo 3. Em seguida, 2-fornece 1.

Na terceira iteração, o -(subtrai ) é alterado para uma \instrução (swap), para que o 3 se torne a entrada mais alta da pilha. E na iteração quatro, uma +instrução (add) é inserida, adicionando assim o 3 ao 1 que dá 4.

R, 21 bytes, 10 números Rachado

__i___________i______

Funciona para 10 números. _é um personagem oculto.

Solução original:

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

Ruby, 16 bytes, 10 números, quebrado por xsot

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

# é qualquer personagem.

Oitava, 32 bytes, 10 números. Rachado

_n_(isprime(floor(s____i__ i____

_ é um personagem oculto.

Você pode experimentar o Octave on-line aqui .

Solução original:

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')))

...

Oitava, 17 bytes, 10 números, Rachado

_i_(__i__(2_5_))

Caracteres não revelados são marcados com _ .

Solução pretendida:

    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))

Oitava, 19 bytes, 10 números, quebrado

__sca__1_)___'-_6_'

_ é o personagem oculto.

Solução pretendida:

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

05AB1E , 5 bytes, 10 números, com defeito !

Não é muito difícil, mas divertido :)

_[==_

_é um caractere aleatório. Usa a codificação CP-1252 . Experimente online!

05AB1E , 6 bytes, 10 números, quebrado

Tentativa 2, desta vez sem a sequência de três caracteres: p.

_ [==_

_é um caractere aleatório. Usa a codificação CP-1252 . Experimente online!

JavaScript, 22 bytes, 10 números, quebrado

alert(0_6_4_>_0_2_0_7)

_ é o personagem oculto.

Dica sobre a solução pretendida

O caractere que precisa ser alterado para gerar todos os números é sempre o mesmo.

JavaScript 21 bytes, 10 números rachados

alert(b_oa_"3____1"))

Caracteres não revelados são marcados com _

Rachado

Minha versão:

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 números, quebrado

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

Caracteres não revelados são marcados com ?. Testado em Python 3.5.2.

Python 3, 16 bytes, 10 números, quebrado

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

Caracteres não revelados são marcados com ?. Provavelmente é um pouco fácil, já que existem apenas cinco pontos de interrogação, mas espero que seja divertido.

C #, 90 bytes, 10 números, quebrado

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

Sinceramente, não tenho ideia do quão difícil é quebrar.

Edit: Opa, erro de transcrição. Um _pouco depoisusing .

Agora resolvido por Hedi , que encontrou a solução pretendida (exceto o nome da classe).

JavaScript 33 bytes, 10 números rachados x2

Opa, eu postei minha linha por gerar 10 Que Hedi rachou como se fosse 1

alert(_to__"_Xc0__0_B6____Zp=="))

Versão destinada a ser postada para gerar 1

alert(_to__"_Xc0__0_Bf____Zp=="))

Caracteres não revelados são marcados com _

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+ números, 61 bytes, Rachado!

Aqui estava o código que eu postei:

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

O código original era:

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

Basicamente, gera um erro ('x' is not defined ) e depois imprime a linha na qual o erro foi encontrado. Portanto, continue adicionando novas linhas no início para aumentar o número.

Eu sabia que não seria difícil decifrar - eu só queria uma maneira engraçada de imprimir números - mas não esperava que o Sp3000 o obtivesse tão rápido, são algumas habilidades profissionais!

05AB1E, 11 bytes, rachado!

3628801__0_

Trabalhos 1-10. _é um personagem oculto.

Solução pretendida:

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

Oitava, 24 bytes, 9 números, quebrado

_a__repmat(__one___,__)_

_ é um personagem oculto.

(Inspirado pelo desafio de @ LuisMendo .)

JavaScript, 9 bytes, 10 números, Rachado

alert(__)

_ é o personagem oculto.

Oitava, 25 bytes, 9 números. Rachado

__a__repmat(__one___,__)_

_ é um personagem oculto.