AVISO - Este desafio está encerrado. Quaisquer novas respostas serão ignoradas e a resposta aceita não será alterada

Desafio

Escreva um programa válido que, quando apenas dois caracteres no programa forem alterados, removidos ou adicionados, altere completamente a saída.

A saída alterada deve ter uma distância de Levenshtein igual ou superior a 15 da sua saída original.

A saída deve ser não vazia e finita. Portanto, seu programa deve terminar dentro de 1 minuto.

Sua saída deve ser determinística, produzindo a mesma coisa sempre que você executa o programa. Também não deve depender da plataforma.

Quaisquer funções de hash não são permitidas , como são construídas nos PRNGs. Da mesma forma, semear um RNG não é permitido.

Após um período de três dias, um envio sem rachaduras ficará seguro. Para reivindicar essa segurança, edite sua resposta para mostrar a resposta correta. (Esclarecimento: Até que você revele a resposta, você não está seguro e ainda pode ser quebrado.)

Formatação

Sua resposta deve estar no seguinte formato:

# <Language name>, <Program length>

## Code

<code goes here>

## Original Output

<output goes here>

## Changed output

<changed output goes here>

Ladrões

O desafio dos ladrões é descobrir quais os dois personagens que você mudou. Se um ladrão tiver quebrado sua solução, ele deixará um comentário na sua resposta.

Você pode encontrar o tópico dos ladrões aqui .

Ganhando

A pessoa com a menor solução sem rachaduras vence.

Entre os melhores

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>site = 'meta.codegolf';postID = 5686;isAnswer = false;QUESTION_ID = 54464;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 bylength=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 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) { 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])+)\s*(?:[,;(]|\s-).*?([0-9]+)/.exec(h); var e = [[n++, m ? parseInt(m[2]) : 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.length == 100) g(p + 1); else { var s=[[uncracked_list, '#uncracked'], [safe_list, '#safe']]; for(var p=0;p<2;p++) u(s[p],bylength); jQuery('#uncracked_by_length').bind('click',function(){u(s[0],bylength);return false}); jQuery('#uncracked_by_creation').bind('click',function(){u(s[0],bycreation);return false}); } });}g(1);</script><link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><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;}</style><div class="main"><h3>Uncracked submissions</h3><table> <tr> <th>Language</th> <th class="score">Length</th> <th>User</th> </tr> <tbody id="uncracked"></tbody></table><div>Sort by: <a href="#" id="uncracked_by_length">length</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">Length</th> <th>User</th> </tr> <tbody id="safe"></tbody></table></div>

CJam, 13 bytes (seguro)

J{m!_)mQ%2b}/

Experimente online.

Saída original

000010010101001010001101111000111011100110100100001011101101010100011111110010010010001111111111010000010011001110001010011111000010001001110111100000010110000010000111011011110101110010000011100111100

Saída modificada

11101101100011110001011010000100111011000010011101100000001010100111011010011011010111101000000011101111100000000110001000111110110110101111110100101110000101110100110011110000010101110

Solução

J{m!_)ci%2b}/

Experimente online.

Como funciona

Isso tira proveito de como o CJam imprime implicitamente a pilha inteira após a execução do programa.

Simplesmente despejar as representações da base 2 de alguns números inteiros na pilha faz com que elas sejam impressas sem nenhum separador; portanto, deve ser difícil descobrir onde uma delas começa e a outra termina.

O código original faz o seguinte:

J{   e# For each I from 0 to 18, do the following:
  m! e#   Calculate the factorial of I.
  _) e#   Push a copy and add 1.
  mQ e#   Compute the result's integer square root.
  %  e#   Calculate the residue of the factorial divided by the square root.
  2b e#   Push the array of base 2-digits of the resulting integer.
}/   e#

Como @AndreaBiondo observa nos comentários, as representações binárias de 0! para 8! pode ser encontrado no início da saída (espaços adicionados para maior clareza):

1 1 10 110 11000 1111000 1011010000 1001110110000 1001110110000000

A alteração pretendida foi substituída mQpor ci, que leva o módulo inteiro 65536, usando aritmética de caracteres de 16 bits (conversão para um caractere de 16 bits não assinado e, em seguida, volta para o inteiro).

Eu esperava que a idéia de usar cpara substituir um operador matemático fosse suficientemente obscura.

Rachado

Shakespeare, 1721 bytes

Eu tentei uma resposta de Shakespeare. Não é curto, e tive dificuldades para alterar a saída com apenas 2 caracteres, mas acho que consegui muito bem. Boa sorte a todos. Como observação, usei o "compilador" disponível neste endereço e ele pode não funcionar com outro. (ele não funciona com o intérprete online) A saída não contém caracteres não imprimíveis.

Código

A mudança oculta.

Helen, uma jovem mulher com uma paciência notável.
Helena, uma jovem igualmente de extraordinária graça.
Claudio, um homem notável muito em disputa com Cláudio.
Cláudio, o bajulador.
O arcebispo de Canterbury, o inútil.


          Ato I: Insultos e bajulação de Cláudio.

          Cena I: O insulto de Helen.

[Entre Cláudio e Helen]

Cláudio:
 Tu és tão cabeludo quanto a soma de um horrível e sem pai nojento 
 empoeirado velho gato podre de rins gordurosos e uma grande guerra amaldiçoada e suja.
 Tu és tão estúpido quanto o produto de ti e um fedorento gordo 
 filho medíocre e miserável e vil e fraco.

[Exeunt]

          Cena II: O elogio de Helena.

[Entre Claudio e Helena]

Claudio:
 Tu és o ensolarado maravilhoso orgulhoso saudável pacífico doce alegria.
 Tu és tão incrível quanto o produto de ti e a bonita
 adorável jovem gentil, bonito e rico herói. Tu és tão grande
 como a soma de ti e o produto de um prompt de ouro justo bom honesto 
 charmoso rei nobre amoroso e um rico e rico anjo dourado bordado.

[Exeunt]

          Cena III: O insulto de Claudio

[Entre Cláudio e Helen]

Helen:
 Tu és tão estúpido quanto a soma da soma de ti e um gato e eu.
[Sai Helen]

[Digite Claudio]

Cláudio:
 Tu és tão estúpido quanto a soma de ti e o produto da 
 produto de mim e Helen e Helena

[Exeunt]

          Cena IV: A contagem regressiva final

[Entre no Arcebispo de Cantuária e Cláudio]

Cláudio:
 Tu és a soma de você e um gato.

O Arcebispo de Canterbury:
 Eu sou melhor do que um bom caminho?

Cláudio:
 Caso contrário, voltemos ao insulto de Claudio.

[Saia do Arcebispo de Canterbury]

[Digite Claudio]

Cláudio:
 Abra seu coração!
 Abra seu coração!
[Exeunt]

Saída Original

11324620811132462081

Saída alterada

11

J, 76 bytes (seguro)

Código

,:|.,.<,:>><|.,:>,.<|.>,:<<|.>|.,:,.<,.<,:,.<,:>|.<,:>,.|.<,:,.|.<<,:>126$a.

Saída Original

┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐│
││┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐││
│││┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐│││
││││┌──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐││││
│││││     ┌┬┐├┼┤└┴┘│─ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}│││││
││││└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘││││
│││└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘│││
││└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘││
│└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘│
└──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

Saída alterada

┌──────────────────────┐
│┌────────────────────┐│
││┌──────────────────┐││
│││┌────────────────┐│││
││││┌──────────────┐││││
│││││┌───────────┬┐│││││
││││││0 0 0 0 0 0│││││││
│││││└───────────┴┘│││││
││││└──────────────┘││││
│││└────────────────┘│││
││└──────────────────┘││
│└────────────────────┘│
└──────────────────────┘

EDIT: Solução {:adicionada (mostrada entre ###)

,:|.,.<,:>><|.,:>,.<|.>,:<<|.>|.,:,.<,.<,:,.<,###{:###:>|.<,:>,.|.<,:,.|.<<,:>126$a.

Faz uso do {::mapa da mônada . A maior parte do restante do código é lixo inútil.

Rachado

Ruby, 14

Código

x=9;puts x*9*9

Saída Original

729

Saída alterada

99999999999999999

Rachado

Bash, 15 bytes

echo {{{1..9}}}

Saída original

{{1}} {{2}} {{3}} {{4}} {{5}} {{6}} {{7}} {{8}} {{9}}

Saída modificada

1 2 3 4 5 6 7 8 9

Rachado

Prolog, 10 bytes

Código

X is 1/42.

Saída Original

X = 0.023809523809523808.

Saída alterada

X = -2.

Rachado

Python 2, 43 bytes

Código

print (sum(range(054321)*9876)*87654)/01234

Saída Original

334960491355406

Saída alterada

222084148077792

A Distância Levenshtein é 15 exatamente. Tanto o original quanto o alterado são executados em menos de 1 minuto no meu computador.

Rachado

BrainFuck, 504 bytes

Ninguém deveria precisar analisar um código de cérebro. Esta é uma versão modificada de um código anterior, mas qualquer alteração em um código Brainfuck faz uma grande diferença na saída. Eu uso o intérprete em http://esoteric.sange.fi/brainfuck/impl/interp/i.html para testar meu código. Boa sorte !

Código

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

Saída Original

 ___
/   \
|   |
\___/

Saída alterada

}}}\}}}|.}}}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\\}}|.}.|///\

Nota: A saída alterada contém vários caracteres STX (ASCII 2) e EOT (ASCII 4)

Aqui está a versão com códigos ASCII entre parênteses, em vez de caracteres não imprimíveis:

(2)}}}(2)\}}}|(2).}}}.(2)|///\\(4)}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)///\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|/(4)/\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|///\\(4)}}|(2).(4)}(4).(2)|///\

rachado

Wolfram Language (Mathematica ou WolframAlpha), 3 bytes

Código

8.!

Saída Original

40320.

Saída alterada

2.67182 - 0.891969 I

Para aqueles que tentam no WolframAlpha, o resultado aparece como

Eu apaguei minha resposta anterior porque funcionava apenas no Mathematica e não no WolframAlpha . Isso colocou os ladrões atrás de um paredão (em vez das barras merecidas), o que não era justo.

Rachado

MATLAB / OCTAVE, 7 bytes

Código:

cos(pi)

Saída original:

ans =

     -1

Saída alterada:

ans =

   1.5708 - 0.8814i

Isso fornece uma distância de Levenshtein de exatamente 15.

Rachado

CJam, 8 caracteres

Código

"~f":i:#

Saída original

17290024234092933295664461412112060373713158853249678427974319674060504032816100667656743434803884485234668769970047274563123327020396104330878852891146011372048615474145637592955298601510765168228550988848615653376

Saída alterada

A saída após a modificação está aqui . Ambos levam menos de um minuto no meu laptop de 2GHz.

Explicação

As pessoas parecem maravilhadas com o modo como isso funciona. O código funciona assim:

"~f"       Push a string
    :i     Convert to a list of bytes [126 102]
      :#   Fold with # (power)

Isso calcula 126 ^ 102. A solução foi:

"}\t~f"
       :i     Convert to a list of bytes [125 9 126 102]
         :#   Fold with # (power)

Isso calcula ((125 ^ 9) ^ 126) ^ 102, que tem centenas de milhares de dígitos.

Rachado

Pitão, 8 bytes

Código:

%CG^3y21

Saída inicial:

51230235128920219893

Saída alterada:

58227066

Rachado

Python 2, 58 bytes

Código

R=range(01234);print sum(m<<min(m,n)for m in R for n in R)

Saída Original

2444542772018013876036977350299418162656593659528311114655474359757543862791958572561591492595632222632192542272836836649846934427359810217936317967768095940470375690509652583392001888886352103127515963142

Saída alterada

4669

Essa regra das 15 distâncias certamente tornava as coisas difíceis. Espero que isso corra bem.

Rachado

Python 2, 50 bytes

Código original:

'~'*sum([(x,y)[x%2]for x in[y for y in range(8)]])

Saída original:

'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'

Saída modificada:

'~~~~~~~~~~~~~~~~~~~'

Não muito curto, e talvez não muito difícil, eu realmente não sei. Vou tentar encontrar algo melhor em breve.

Rachado

PHP, 164 bytes

Código

$S_U_M_M_E_R = 1;
$A_U_T_U_M_N = 2;
$T_I_M_E = 1;

if ($T_I_M_E == $S_U_M_M_E_R) {
    $A_C_=$T_I_=$O_N= 'SWIM' ? 'TAN' : 'DRINK';
}

print $T_I_M_E * $A_U_T_U_M_N;

Saída Original

2

Saída alterada

-1.1306063769532

GolfScript, 15 bytes (seguro)

Código

10,{1+3?}%{*}*]

Código alterado

107,{1+3?}%{^}*]

Saída Original

47784725839872000000

Saída alterada

557154

Explicações:

10,             # numbers from 0 to 10
   {1+3?}%      # add one and raise to the cube. (%=for each)
          {*}*] # take the product and place it in a list(useless)`

Código alterado

107,             # numbers from 0 to 107
    {1+3?}%      # add one and raise to the cube. (%=for each)
           {^}*] # xor them and place it in a list(useless)

Rachado

APL , 7 bytes

Código

-/3⍴157

Saída original

157

Saída alterada

0.11479360684269167J0.37526348448410907

Rachado

C, 53 bytes

Código

main(a,_){puts(_*_*_*_*_-1?"Expected Output":"?");}

Saída Original

Expected Output

Saída alterada

?

Provavelmente fácil demais, mas quem sabe. (Nota: é tecnicamente dependente do sistema, mas o tipo de sistema no qual ele falha também falharia com todos os outros envios aqui, então achei que era um ponto discutível).

Rachado

Editar

Eu cometi um erro. Novo código que é mais seguro para o ataque óbvio:

main(a,_){puts(_*_-1||_*_*_-1||_*_*_*_-1?"Expected Output":"?");}

mesmas saídas. Novo tamanho de 65 bytes. Esperançosamente mais difícil ... embora ainda seja provavelmente fácil demais.

Rachado por issacg

MATLAB, 20 bytes

Código

format long
sin(i^pi)

Saída Original

0.331393418243797 - 1.109981778186163i

Saída alterada

0.220584040749698 - 0.975367972083631i

Rachado

Oitava, 20 bytes

format long;
cos(1)*1

Resultado:

0.540302305868140

Saída alterada:

111

CJam, 28 bytes (seguro)

"jK=\~"5*)ib257b~{G$5$+}*]Jb

Experimente online .

Saída original

7705397905065379035618588652533563996660018265606606763127193120855297133322151462150247488267491212817218321670720380456985476811737021068519164822984561148339610474891720342171053455881107227302663880445203851079295537592154028123394687360216561235621729967011148112746984677807932995700334185726563970223018774

Saída modificada

16650180159137697345989048346412185774444335111603430666402604460993564226370500963166158223117360250140073061887053326627468495236957122711656527124216908303912850181595147494475577084810653496778801228980874902968634143062

Solução

"jK=\~"5*Wcib257b~{G$5$+}*]Jb

Experimente online.

Como funciona

Eu fui um pouco exagerado com este ...

O código original faz o seguinte:

"jK=\~"5* e# Push "jK=\~jK=\~jK=\~jK=\~jK=\~".
)i        e# Pop the last character and cast it to integer.
b257b     e# Convert the remainder of the string from that base to base 257.
~         e# Dump all resulting base-257 digits on the stack:
          e# 137 72 124 88 81 145 85 32 28 251 118 230 53 13 245 147 256 116 187 22 224
{         e# Do the following 224 times:
  G$5$+   e#   Add copies of the 5th and 17th topmost integers on the stack
          e#   (recurrence of a lagged Fibonacci sequence).
}*        e#
]         e# Wrap the entire stack in an array.
Jb        e# Convert from base 19 to integer.
          e# The resulting integer is printed implicitly.

A alteração pretendida está sendo substituída (ipor Wci.

Isso deixa a sequência repetida intocada e empurra 65535 (convertendo para um caractere de 16 bits não assinado e, em seguida, volta para número inteiro), para que os primeiros elementos da sequência de Fibonacci atrasada se tornem

87 225 162 210 73 196 142 219 175 61 40 147 0 93 75 55 103 116 237 188 108 122 176 133 135 240 251 155 224 82 181 75 23 87 139 49 148 169 84 109 110 166 52 103 83 185 78 73

e o loop é repetido 126 vezes.

Javascript, 47 (seguro)

Código

for(var i=64460,x=773;i>=1324;)x=i--/x;alert(x)

Saída Original

11.948938595656971

Saída alterada

3.679331284911481

A distância é exatamente 15.

Testado no Chrome e IE.

Solução

for(var i=64460,x=773;i>>=1<324;)x=i--/x;alert(x)

Isso usa o operador de atribuição de deslocamento de bits i>>=1para tornar o intervalo do loop não linear. Além disso, isso tem a propriedade divertida de que alguém que tenta forçar uma solução brutal terá várias variações que são executadas infinitamente.

Rachado

Fantom , 26

Código

Float.makeBits(1123581321)

Saída Original

5.55122931E-315

Saída alterada

124.24518585205078

Segurança através da obscuridade, se ninguém conhece o idioma, ninguém pode decifrá-lo. Levenshtein Distância de 15. Execute em fansh.

Rachado

CJam, 6 caracteres

25mse7

Saída original

-1323517.5009777304

Saída alterada

72004899337.38588

Isso pode ser muito fácil. : P

Rachado

Java, 149 caracteres

class T{public static void main(String[]a){System.out.print(((Integer.MAX_VALUE^25214903917L)&281474976710655L)*25214903917L+11L&281474976710655L);}}

Saída Original

174542852132661

Saída Modificada

106906909674100

Dica:

Random.java

Brainfuck, 100 bytes

Código

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

Saída original

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Saída alterada

[
  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ

Nota: Possivelmente fácil de quebrar. Mas então, nada é fácil em Brainfuck.

rachado

Perl moderno 5, 70

Código

@array = (qw smiles) x 11;
s/.*// foreach @array;
print "@array\n";

Saída Original

Uma única nova linha.

Saída alterada

 mile mile mile mile mile mile mile mile mile mile

A saída começa com um espaço e termina com uma nova linha.

Rachado

Matlab, 12 bytes

Código

-sin(2:.5:3)

Saída original

-0.9093   -0.5985   -0.1411

Saída alterada

0.4228    0.7032    0.9228

perl, 12 bytes

rachado

Código

print sin 97

Saída original

0.379607739027522

Saída desejada

-0.64618863474386

Rachado

SWI-Prolog, 54 bytes

Código

assert(d(E,F):-(print(E),print(F))). d(123456,123456).

Saída Original

true.

123456123456
true.

Saída alterada

true.

false.