AVISO : este desafío ahora está cerrado. Cualquier nueva respuesta será ignorada y la respuesta aceptada no cambiará.

Desafío

Escriba un programa válido que, cuando solo se cambian, eliminan o agregan dos caracteres en el programa, cambia completamente la salida.

La salida modificada debe tener una distancia de Levenshtein de 15 o más desde su salida original.

La salida debe ser no vacía y finita. Por lo tanto, su programa debe finalizar en 1 minuto.

Su salida debe ser determinista, generando lo mismo cada vez que ejecute el programa. Tampoco debe depender de la plataforma.

No se permiten las funciones hash , como se construyen en los PRNG. Del mismo modo, sembrar un RNG no está permitido.

Después de un período de tres días, una presentación sin descifrar será segura. Para reclamar esta seguridad, debe editar su respuesta para mostrar la respuesta correcta. (Aclaración: hasta que reveles la respuesta, no estás seguro y aún puedes descifrarlo).

Formateo

Su respuesta debe estar en el siguiente formato:

# <Language name>, <Program length>

## Code

<code goes here>

## Original Output

<output goes here>

## Changed output

<changed output goes here>

Ladrones

El desafío de los ladrones es descubrir qué dos personajes has cambiado. Si un ladrón ha descifrado su solución, dejará un comentario sobre su respuesta.

Puedes encontrar el hilo de los ladrones aquí .

Victorioso

La persona con la solución sin descifrar más corta gana.

Tabla de clasificación

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

Pruébalo en línea.

Salida original

000010010101001010001101111000111011100110100100001011101101010100011111110010010010001111111111010000010011001110001010011111000010001001110111100000010110000010000111011011110101110010000011100111100

Salida modificada

11101101100011110001011010000100111011000010011101100000001010100111011010011011010111101000000011101111100000000110001000111110110110101111110100101110000101110100110011110000010101110

Solución

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

Pruébalo en línea.

Cómo funciona

Esto aprovecha cómo CJam imprime implícitamente toda la pila después de ejecutar el programa.

Simplemente volcar las representaciones de base 2 de unos pocos enteros en la pila hace que se impriman sin ningún separador, por lo que debería ser difícil averiguar dónde comienza uno de ellos y dónde termina otro.

El código original hace lo siguiente:

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 señala en los comentarios, ¡las representaciones binarias de 0! a las 8! se puede encontrar al comienzo de la salida (espacios añadidos para mayor claridad):

1 1 10 110 11000 1111000 1011010000 1001110110000 1001110110000000

El cambio previsto era reemplazar mQcon ci, que toma el módulo entero 65536, usando aritmética de caracteres de 16 bits (conversión a un carácter de 16 bits sin signo, luego de vuelta al número entero).

Esperaba que la idea de usar cpara reemplazar un operador matemático fuera lo suficientemente oscura.

Agrietado

Shakespeare, 1721 bytes

Intenté una respuesta de Shakespeare. No es breve, y tuve dificultades para cambiar la salida con solo 2 caracteres, pero creo que tuve bastante éxito. Buena suerte a todos. Como nota al margen, utilicé el "compilador" disponible en esta dirección y puede que no funcione con otra. (no funciona con el intérprete en línea) La salida no contiene caracteres no imprimibles.

Código

El cambio oculto.

Helen, una mujer joven con una notable paciencia.
Helena, una mujer joven igualmente de notable gracia.
Claudio, un hombre notable muy en disputa con Claudio.
Claudio, el adulador.
El arzobispo de Canterbury, el inútil.


          Acto I: los insultos y halagos de Claudio.

          Escena I: El insulto de Helen.

[Entran Claudio y Helena]

Claudio
 Eres tan peludo como la suma de un horrible y desagradable padre 
 gato viejo, polvoriento, podrido y gordo, y una gran guerra sucia y maldita.
 Eres tan estúpido como el producto de ti y un gordo maloliente 
 medio miserable sucio miserable vil hijo débil.

[Salen]

          Escena II: El cumplido de Helena.

[Entran Claudio y Helena]

Claudio
 Tú eres el soleado asombroso, orgulloso, saludable, pacífico, dulce alegría.
 Eres tan increíble como el producto de ti y de la bella
 encantador joven gentil guapo rico rico. Eres tan genial
 como la suma de ti y el producto de un aviso dorado justo bueno honesto 
 encantador rey noble y amoroso y un rico ángel dorado liso bordado.

[Salen]

          Escena III: El insulto de Claudio

[Entran Claudio y Helena]

Helen
 Eres tan estúpido como la suma de la suma de ti y un gato y yo.
[Salga, Helen]

[Entra Claudio]

Claudio
 Eres tan estúpido como la suma de ti y el producto de la 
 producto de mí y Helen y Helena

[Salen]

          Escena IV: La cuenta regresiva final

[Entra el arzobispo de Canterbury y Claudio]

Claudio
 Eres la suma de ti y un gato.

El arzobispo de Canterbury:
 ¿Soy mejor que un buen camino?

Claudio
 Si no, volvamos al insulto de Claudio.

[Salga del arzobispo de Canterbury]

[Entra Claudio]

Claudio
 ¡Abre tu corazón!
 ¡Abre tu corazón!
[Salen]

Salida original

11324620811132462081

Salida modificada

11

J, 76 bytes (seguro)

Código

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

Salida original

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

Salida modificada

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

EDITAR: Solución {:agregada (mostrada entre ###)

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

Hace uso de la mónada {::Mapa . La mayor parte del resto del código es basura inútil.

Agrietado

Rubí, 14

Código

x=9;puts x*9*9

Salida original

729

Salida modificada

99999999999999999

Agrietado

Bash, 15 bytes

echo {{{1..9}}}

Salida original

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

Salida modificada

1 2 3 4 5 6 7 8 9

Agrietado

Prólogo, 10 bytes

Código

X is 1/42.

Salida original

X = 0.023809523809523808.

Salida modificada

X = -2.

Agrietado

Python 2, 43 bytes

Código

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

Salida original

334960491355406

Salida modificada

222084148077792

La distancia de Levenshtein es 15 exactamente. Tanto el original como el modificado se ejecutan en menos de 1 minuto en mi computadora.

Agrietado

BrainFuck, 504 bytes

Nadie debería necesitar analizar un código de brainfuck. Esta es una versión modificada de un código anterior, pero cualquier cambio en un código Brainfuck hace una gran diferencia en la salida. Uso el intérprete en http://esoteric.sange.fi/brainfuck/impl/interp/i.html para probar mi código. Buena suerte !

Código

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

Salida original

 ___
/   \
|   |
\___/

Salida modificada

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

Nota: La salida modificada contiene varios caracteres STX (ASCII 2) y EOT (ASCII 4)

Aquí está la versión con códigos ASCII entre paréntesis en lugar de caracteres no imprimibles:

(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)|///\

agrietado

Wolfram Language (Mathematica o WolframAlpha), 3 bytes

Código

8.!

Salida original

40320.

Salida modificada

2.67182 - 0.891969 I

Para aquellos que lo prueban en WolframAlpha, el resultado aparece como

Eliminé mi respuesta anterior porque funcionaba solo en Mathematica y no en WolframAlpha . Eso puso a los ladrones detrás de un muro de pago (en lugar de las barras merecidas), lo que no era justo.

Agrietado

MATLAB / OCTAVE, 7 bytes

Código:

cos(pi)

Salida original:

ans =

     -1

Salida modificada:

ans =

   1.5708 - 0.8814i

Esto da una distancia de Levenshtein de exactamente 15.

Agrietado

CJam, 8 personajes

Código

"~f":i:#

Salida original

17290024234092933295664461412112060373713158853249678427974319674060504032816100667656743434803884485234668769970047274563123327020396104330878852891146011372048615474145637592955298601510765168228550988848615653376

Salida modificada

La salida después de la modificación está aquí . Ambos toman menos de un minuto en mi computadora portátil de 2 GHz.

Explicación

La gente parece asombrada de cómo funciona esto. El código funciona así:

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

Esto calcula 126 ^ 102. La solución fue:

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

Esto calcula ((125 ^ 9) ^ 126) ^ 102, que tiene cientos de miles de dígitos de largo.

Agrietado

Pyth, 8 bytes

Código:

%CG^3y21

Salida inicial:

51230235128920219893

Salida modificada:

58227066

Agrietado

Python 2, 58 bytes

Código

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

Salida original

2444542772018013876036977350299418162656593659528311114655474359757543862791958572561591492595632222632192542272836836649846934427359810217936317967768095940470375690509652583392001888886352103127515963142

Salida modificada

4669

Esa regla de 15 distancias seguramente hizo las cosas difíciles. Espero que esto vaya bien.

Agrietado

Python 2, 50 bytes

Código original

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

Salida original:

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

Salida modificada:

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

No demasiado corto, y tal vez no demasiado difícil, realmente no lo sé. Intentaré encontrar algo mejor pronto.

Agrietado

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;

Salida original

2

Salida modificada

-1.1306063769532

GolfScript, 15 bytes (seguro)

Código

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

Código modificado

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

Salida original

47784725839872000000

Salida modificada

557154

Explicaciones:

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 modificado

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)

Agrietado

APL , 7 bytes

Código

-/3⍴157

Salida original

157

Salida modificada

0.11479360684269167J0.37526348448410907

Agrietado

C, 53 bytes

Código

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

Salida original

Expected Output

Salida modificada

?

Probablemente demasiado fácil, pero quién sabe. (Nota: técnicamente depende del sistema, pero el tipo de sistema en el que falla también fallaría en todas las otras presentaciones aquí, así que pensé que era un punto discutible).

Agrietado

Editar

Cometí un error. Nuevo código que es más seguro para el ataque obvio:

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

mismas salidas Nuevo tamaño de 65 bytes. Esperemos que sea más difícil ... aunque probablemente sea demasiado fácil.

Agrietado por issacg

MATLAB, 20 bytes

Código

format long
sin(i^pi)

Salida original

0.331393418243797 - 1.109981778186163i

Salida modificada

0.220584040749698 - 0.975367972083631i

Agrietado

Octava, 20 bytes

format long;
cos(1)*1

Salida:

0.540302305868140

Salida modificada:

111

CJam, 28 bytes (seguro)

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

Pruébalo en línea .

Salida original

7705397905065379035618588652533563996660018265606606763127193120855297133322151462150247488267491212817218321670720380456985476811737021068519164822984561148339610474891720342171053455881107227302663880445203851079295537592154028123394687360216561235621729967011148112746984677807932995700334185726563970223018774

Salida modificada

16650180159137697345989048346412185774444335111603430666402604460993564226370500963166158223117360250140073061887053326627468495236957122711656527124216908303912850181595147494475577084810653496778801228980874902968634143062

Solución

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

Pruébalo en línea.

Cómo funciona

Fui un poco por la borda con este ...

El código original hace lo siguiente:

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

El cambio previsto se reemplaza (icon Wci.

Esto deja intacta la cadena repetida y empuja 65535 (al convertir a un carácter de 16 bits sin signo, luego de nuevo a entero), de modo que los primeros elementos de la secuencia de Fibonacci rezagada se vuelven

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

y el ciclo se repite 126 veces.

Javascript, 47 (seguro)

Código

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

Salida original

11.948938595656971

Salida modificada

3.679331284911481

La distancia es exactamente 15.

Probado en Chrome e IE.

Solución

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

Esto utiliza el operador de asignación de desplazamiento de bits i>>=1para hacer que el intervalo de bucle no sea lineal. Además, esto tiene la propiedad divertida de que alguien que intenta forzar una solución con fuerza bruta se encontrará con varias variaciones que se ejecutan infinitamente.

Agrietado

Fantom , 26

Código

Float.makeBits(1123581321)

Salida original

5.55122931E-315

Salida modificada

124.24518585205078

Seguridad a través de la oscuridad, si nadie conoce el idioma, nadie puede descifrarlo. Levenshtein Distancia de 15. Ejecutarlo en fansh.

Agrietado

CJam, 6 personajes

25mse7

Salida original

-1323517.5009777304

Salida modificada

72004899337.38588

Esto puede ser demasiado fácil. :PAGS

Agrietado

Java, 149 caracteres

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

Salida original

174542852132661

Salida modificada

106906909674100

Insinuación:

Random.java

Brainfuck, 100 bytes

Código

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

Salida original

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Salida modificada

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

Nota: Posiblemente fácil de descifrar. Pero entonces, nada es fácil en Brainfuck.

agrietado

Perl moderno 5, 70

Código

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

Salida original

Una sola línea nueva.

Salida modificada

 mile mile mile mile mile mile mile mile mile mile

La salida comienza con un espacio y termina con una nueva línea.

Agrietado

Matlab, 12 bytes

Código

-sin(2:.5:3)

Salida original

-0.9093   -0.5985   -0.1411

Salida modificada

0.4228    0.7032    0.9228

perl, 12 bytes

agrietado

Código

print sin 97

Salida original

0.379607739027522

Salida deseada

-0.64618863474386

Agrietado

SWI-Prolog, 54 bytes

Código

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

Salida original

true.

123456123456
true.

Salida modificada

true.

false.