Escada de código, Policiais


36

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>


Não tenho certeza se entendi ... dado um código arbitrário no CJam que produz 1, como posso impedir que os ladrões adicionem )repetidamente para gerar o restante dos números? O mesmo seria válido para algumas línguas
Luis Mendo

2
Se isso for possível para qualquer programa que produz 1, parece que o CJam é uma má escolha da linguagem para esse desafio. Não há como impedir que ladrões façam isso.
Stewie Griffin

3
@LuisMendo Bem, isso certamente tornará isso mais interessante ...
LegionMammal978

1
@DanielJour Pode ser modificável até qualquer número, mas o número máximo que os ladrões precisam encontrar é 10. Essa regra está em vigor porque muitas submissões provavelmente podem ser estendidas até o infinito (em teoria), portanto, a pontuação com base no maior número alcançado não faria sentido.
Stewie Griffin

1
Você pode tentar desqualificar apenas uma entrada se o cabeçalho contiver crackedde alguma forma. É isso que o reprojeto userscript faz atualmente.
ETHproductions

Respostas:


1

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.


10

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 .


19
o_O O____o O_O o_O
TuxCrafting

Eu não tenho tanta certeza se este é realmente tão difícil de decifrar =)
flawr

Bem, com certeza não é fácil decifrar! Talvez pudesse fazer isso com papel e caneta (!)
Stewie Griffin

Tomo isso como um elogio :) Acho que você vai gostar da minha solução, mas não vou revelar nada até que ela esteja quebrada / segura.
flawr



8

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


1
Rachado . No começo eu pensei que era algo como $_=1;say;#-9, mas eu não conseguia descobrir como obter 10.
Riley

7

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.


1
Estou tão intrigado com isso. Eu aprendi sobre pseudo-hashes e atualizei minha memória em referência e remoção de referência, mas não consigo entender!
Dom Hastings

1
@DomHastings, ... e eu andei brincando com vários caracteres de demarcação para qe se ye m(principalmente tentando fazê-los terminar após a $b[0]tarefa), mas nada está funcionando para mim (ainda).
Msh210

Vocês estavam no caminho errado, mas, reconhecidamente, não há muita ajuda dada pelo idioma ou pela minha submissão quanto ao caminho certo (tive que deixar uma pista para evitar deixar uma lacuna muito grande, mas há muitas razões pelas quais um programa pode conter uma barra invertida, nem sempre está relacionado a referências).

Sinto como se estivesse frustrantemente perto. Eu tinha sub b{\@_}cimentado em minha mente e, apesar de ter experimentado, *bnão consegui! Obrigada pelo esclarecimento. Eu poderia ter encoberto isso na sua explicação, mas por que sub b{\@_}*b=b$b[0]não faz o mesmo?
Dom Hastings

Você está tentando fazer com que o elemento da matriz e o elemento hash compartilhem memória, portanto, é necessário mencionar os dois. O elemento da matriz é mencionado implicitamente quando você atribui uma referência à matriz ( \@_) *b, mas é necessário mencionar explicitamente o elemento de hash. Com *b=b$b[0], você basicamente está aliasando o novo $b[0](depois de alterar os @bpontos de onde ) para o $b[0]que existia no início do programa, o que é inútil.

5

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


Agradável! Eu passei muito tempo resolvendo esse problema, foi fácil, mas desafiador ao mesmo tempo.
Kritixi Lithos

5

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.


Código original:

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

2
Rachado . Eu suspeito que isso não é o que você estava procurando. (Eu estava tentando fazer algo usando regex, mas esta foi muito mais simples.)


4

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.



4

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.

Eu seria capaz de decifrá-lo se o '' 'estivesse na próxima linha. Tão perto ... :)
Kritixi Lithos

Rachado, mas você poderia explicar o que acontece 10, porque tive sorte com isso enquanto tentava coisas que poderiam funcionar.
Hedi

@Hedi Ninja me deu muito rápido, eu estava trabalhando nisso.
Erik the Outgolfer

@Hedi - o seu foi um crack não intencional. 10Acredito que a maneira de trabalhar para você é avaliar o código de geléia na cadeia de caracteres 9com um argumento de 0(o valor padrão da entrada), que você remove da fila (sem efeito) e depois incrementa.
Jonathan Allan

... na verdade, acho que o caminho 10está funcionando para você é avaliar o código de geléia na string 9com um argumento de []- o valor padrão da entrada 0, desenfileirado - que você incrementa., Como“1‘‘‘‘‘‘‘‘‘Ọv0Ḋ¤‘
Jonathan Allan

4

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.


Rachado. Estou curioso para ver qual solução você tinha em mente. :)
Martin Ender

@MartinEnder Como comentei sua resposta, gostaria de deixar minha solução oculta por um tempo, caso outra pessoa queira tentar uma solução mais portátil. Tudo bem?
James Holderness

Claro, tudo bem. :)
Martin Ender

"15:**-6-.@dá 1, mas não tenho certeza se o fato de "colocar 32 em cima (devido a espaços implícitos) é um artefato do intérprete TIO ou parte das especificações do Befunge, porque, ao tentar alguns intérpretes, parece que nem todos os intérpretes fazem isso. Sua solução pretendida depende desse comportamento?
Sp3000 15/11/16

@ Sp3000 Essa não era a minha solução pretendida, mas é perfeitamente válida o Befunge - os intérpretes que não oferecem suporte estão incorretos. Se você postar uma resposta com o resto da sequência, eu definitivamente consideraria isso uma fenda completa.
precisa

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.


@StewieGriffin Este é o meu primeiro post neste site e não conheço as normas. Eu tenho mais um desafio de R - um pouco mais complicado, eu acho. Posso adicionar outra resposta? Ou anexá-lo a este?
22716 Gregor

Adicionando um novo, ele está perfeitamente bem (como um separado) 😊 bem-vindo ao site Ste #
Stewie Griffin

Eu quebrei aqui ?
Tensibai

@Tensibai Cracked :)
Gregor


3

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

...


Muito agradável! Rachado . Não tem certeza se eu reproduzi seu código?
Stewie Griffin

@StewieGriffin Well done! Eu deveria ter revelado mais personagens ... :-D
Luis Mendo

1
Droga, isso foi inteligente :) Pena que você não poderia dizer que era MATLAB ... Mais um personagem provavelmente teria tornado muito mais difícil ... Eu gostei embora ... usei 25 minutos completos :)
Stewie Griffin

@ Stewie Sim, você fez bom uso de recursos que não são do Matlab! :-)
Luis Mendo

3

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


rachado (finalmente =), mas provavelmente não com sua abordagem original, certo?
flawr

Bom, acrescentou minha abordagem em uma tag saqueador :)
Stewie Griffin

2
Oh, sua solução é realmente inteligente !!!
flawr

3

Oitava, 19 bytes, 10 números, quebrado

__sca__1_)___'-_6_'

_ é o personagem oculto.

Solução pretendida:

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



Eu não conseguia lembrar de nenhuma função com sca. Vindo de você, eu deveria ter pensado funções matriciais :-)
Luis Mendo

Há uma razão pela qual eu fiz uma lista completa de nomes de função Octave =)
flawr



3

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.



@ ais523 Muito bem!
Arnauld

3

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



3

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.



3

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


d'oh ... um muito curto para write ()
masterX244

Não ajudou ... lacuna errada. E que ponto e vírgula após a primeira abertura frustrado amother ideia
masterX244


3

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


Eu adicionei um crack para a versão pretendida. Vou tentar encontrar uma maneira de chegar à sua solução para 10: console.log(atob|"0Xc0"-0xB6|("Zp=="))Eu acho
Hedi 16/11

Atualizei minha resposta com o que deveria ser o crack pretendido.
Hedi

3

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!


Rachado - divertida, mas sim não há realmente muitas opções: P
SP3000

@ Sp3000 Sim, eu queria ter certeza de que ninguém pudesse apagar o que estava acontecendo STDOUTe imprimir um número, mas acho que o reduzi muito. Ah bem.
FlipTack

A revelação sysdefinitivamente tornou muito mais simples, pois dava um bom ponto de partida para a pesquisa: P
Sp3000 20/16

2

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


2

Oitava, 24 bytes, 9 números, quebrado

_a__repmat(__one___,__)_

_ é um personagem oculto.

(Inspirado pelo desafio de @ LuisMendo .)


Oh, você é rápido demais !!!
flawr


2

Oitava, 25 bytes, 9 números. Rachado

__a__repmat(__one___,__)_

_ é um personagem oculto.


@StewieGriffin Sorry !! Apenas 9. Meu erro. Eu realmente sinto muito. Editado
Luis Mendo


1
Desculpe = P Eu vou postar um substituto =)
flawr

@ Stewie Tem sido minha culpa, desculpe! Vou postar uma versão modificada mais tarde, desde a minha solução original é diferente
Luis Mendo

Para o registro, meu crack era idêntico ao de flawr. Publiquei outra de oitava aqui .
Stewie Griffin
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.