Dos marca la diferencia: policías


60

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>


@BetaDecay ¿Cómo define una función hash?
isaacg

1
@xnor Teóricamente, pero el número de posibilidades aumenta enormemente a medida que aumenta la duración del programa y, por lo tanto, puede llevar mucho tiempo
Beta Decay

1
@RedPanda Sí, creo que sí
Beta Decay

55
@isaacg Decidí cambiar la fecha segura a tres días
Beta Decay

44
¿Sería posible poner el código de la tabla de clasificación en menos líneas para que ocupe menos espacio visual?
isaacg

Respuestas:


6

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.


Guau. ¿Cómo se te ocurre esto?
The_Basset_Hound

Traté de descifrar esto durante bastante tiempo. Descubrí parte del patrón modificado, pero me faltaba algo. Ahora es seguro, supongo.
Andrea Biondo

@AndreaBiondo Es ahora. Gracias por recordarme.
Dennis

@Dennis Me di cuenta de que era _)mQnecesario cambiarlo a f(x!)tal que f(x!) > x!por x <= 8y f(x!) < x!para x >= 9, porque x!obviamente estaba siendo modulado por un número que dejaba intactos los factoriales de 0 a 8 en la salida. No me di cuenta de que 9!era el primer factorial más grande que 2^16. Muy buen desafío de todos modos.
Andrea Biondo

39

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

99
Realmente maravilloso Esta historia trajo lágrimas a mis ojos.
Alex Van Liew

66
@AlexVanLiew Me llevó mucho tiempo escribir. Es mi obra maestra!
AboveFire


Muy buena respuesta
orgulloso Haskeller

24

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.


Tenga en cuenta que ciertamente podría extender el código por una cantidad ridícula de caracteres para que sea más difícil encontrar el lugar (s) donde los dos caracteres deben agregarse / eliminarse / cambiarse
Fatalize

Creo que han pasado 3 días para este, así que si publicas la respuesta, estás a salvo.
isaacg

@isaacg Correcto, editó la respuesta
Fatalize

12

Agrietado

Rubí, 14

Código

x=9;puts x*9*9

Salida original

729

Salida modificada

99999999999999999

44
Esto se ve tan inocente. Lo he intentado y lo he intentado, pero no sé de dónde sacar el 17 ...
Dennis

1
Pensé que eran 18 9, así que iba por algo así '99'*2. wc, ¡me traicionaste!
Alex Van Liew

@AlexVanLiew 18 sería fácil. Culpe a su caparazón por agregar un salto de línea.
Dennis

@Dennis ¿Cómo lo harías con 18? No pude resolverlo (pero tampoco conozco a Ruby).
Alex Van Liew


12

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


2
Bien hecho. Esto duró más de lo que pensé.
Dennis

10

Agrietado

Prólogo, 10 bytes

Código

X is 1/42.

Salida original

X = 0.023809523809523808.

Salida modificada

X = -2.


2
Por alguna razón estoy totalmente por alto el hecho de que esto también puede resolverse de esta manera: X is 1//4-2., que es mucho más fácil de ver que mi solución original que @ SP3000 agrietado ...
Fatalize

10

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.


1
He editado su publicación para reflejar que se trata de una presentación específica de Python 2, debido a los paréntesis faltantes printy la multiplicación de rangeun entero. Sin embargo, parece que MemoryError
obtengo

1
Dado que esto no es código golf, podría reducir la carga de memoria mediante el uso en xrangelugar de rangey creo que itertoolstiene un generador de generador que repite una secuencia xvarias veces.
Alex Van Liew

1
@AlexVanLiew Pero el puntaje es el golf de código en cierto sentido, el más corto sin descifrar. Dicho esto, sin embargo, hay un espacio innecesario y un par de padres ... ¿ o son necesarios? ;)
Sp3000

2
En mi opinión, esta respuesta no parece interesante si esto se basa solo en cambiar los números involucrados (no sabemos si este es el caso), porque en ese caso probablemente puedas hacerlo más corto y la única forma de que se rompa es simplemente por fuerza bruta, no por inteligencia.
Fatalize

3
Agrietado. ¡Esa era una diversión!
isaacg

8

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

3
Eres malo. ¡Pero lo encontraré!
RedPanda

@RedPanda Mi código tiene una estructura. ¡Al menos no es al azar! ¡Buena suerte!
AboveFire

¿hay alguna no imprimible en la salida?
orgulloso Haskeller

@proudhaskeller Sí, lo siento, editaré la publicación, hay un montón de caracteres STX (ASCII 2) y EOT (ASCII 4)
AboveFire


8

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

Gráficos de Mathematica

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.



@abligh Nice! :)
Dr. belisarius

1
¿Cuál fue la respuesta del otro? Soy muy curioso.
Brain Guider

7

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.



3
El gran aviso para mí fue notar que la parte real de su salida modificada es pi / 2. A partir de ahí, no fue difícil adivinar la solución.
David Zhang el

7

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.


66
Esto es criminal
Alex Van Liew

Qué ... ¡Realmente quiero saber cómo funciona esto! ;)
Beta Decay


@BetaDecay Podría explicar cómo funciona el original, pero no la versión de Dennis. Me pregunto cómo Mauris quiso resolverlo ...
Alex Van Liew

¡Plátanos santos! WTF!
Brain Guider

7

Agrietado

Pyth, 8 bytes

Código:

%CG^3y21

Salida inicial:

51230235128920219893

Salida modificada:

58227066

1
La salida modificada es igual CG mod (2^21 * 28). No conozco a Pyth, así que no puedo ver cómo cambiarme (3 ^ (2 * 21))a eso ...
Lynn

1
Además, CGes igual sum(256**n * (122-n) for n in range(26)).
Lynn

1
La salida modificada también es igual a CG mod (2^21 * 28 * 2*n), donde 1 <= n <= 4, así como para n=6y n=12. Además, CGes solo el alfabeto en minúsculas interpretado como un número base 256. Me pregunto si hay otro módulo con base 3?
Alex Van Liew

%CG^2 26o %CG^4y13, pero ambos tienen una distancia de 3 ...
Jakube


6

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.


El hecho de que 4669 = 667 * 7 y que el último elemento del rango (01234) sea 667 es sospechoso para mí ...
Fatalize

Si imprime [m<<min(m,n)for m in R for n in R]en el intérprete, obtendrá algunos patrones esquemáticos de ruido blanco realmente espeluznantes.
Alex Van Liew


6

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.


¿Son 40 tildes y luego 19 tildes? ¿Y supongo que esto se ejecuta en el intérprete?
Alex Van Liew


2
Un resumen de lo que encontré hasta ahora: no hay combinación de reemplazar xcon y, ycon xo cambiar el dígito en el rangeresultado en 19 tildes. También experimenté insertando un -antes de cualquiera xo y, y cambiando %a uno de + - / *, en vano. Ahora estoy bastante seguro de que se requieren 1 o 2 inserciones.
mbomb007

1
Bien, mi primer enlace ahora lo descifra correctamente.
Alex Van Liew

2
Agregué una pequeña explicación, en realidad creo que esta fue realmente inteligente. No sé si alguna vez he visto una comprensión fija, y también confiar en que Python se filtró yen el ámbito de cobertura fue un buen toque.
Alex Van Liew

6

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


¡Bien hecho! No pensé que sería tan fácil ser descifrado.
Razvan

6

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)

Creo que esto es seguro ahora, así que si deseas editar tu publicación
Decaimiento Beta

@BetaDecay estoy!
Baconaro

5

Agrietado

APL , 7 bytes

Código

-/3⍴157

Salida original

157

Salida modificada

0.11479360684269167J0.37526348448410907

¿Es eso Jen la evidencia de salida que es un número complejo?
mbomb007

@ mbomb007 Sí, se aJbrefiere al número complejo a + bi.
Dennis


4

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.




2
(nota al margen - esto probablemente debería haber sido dos respuestas)
Sp3000

@ Sp3000 Puede que tenga razón, aunque el objetivo del original era tener la misma solución, simplemente me concentré demasiado en el problema del recuento impar * (donde puede convertir el medio en un /) y no consideré el más fácil * 0 cambio.
LambdaBeta

4

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

Probé un montón de ideas en el intérprete de Octave en línea. Aún nada. He intentado cosas como el uso de sinh, asin, tan, pi^i, etc ...
mbomb007

@ mbomb007 - Aquí también estoy perdido ... ¡y soy el quinto más alto en StackOverflow en MATLAB en general!
rayryeng - Restablece a Mónica el



4

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.


Esto es seguro ahora, ¿no?
Beta Decay

@BetaDecay Usé el mismo truco en ambas respuestas de CJam, así que tuve que esperar para publicar ambas soluciones a la vez. Está a salvo ahora.
Dennis

Una vez que averigüé qué era esto, me di cuenta de que había tantas cosas que podrían modificarse que ni siquiera me molesté en tratar de forzarlo ... buen trabajo :)
Sp3000

4

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.


3

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.


Supongo que necesito aprender Fantom ...
AboveFire


3

Agrietado

CJam, 6 personajes

25mse7

Salida original

-1323517.5009777304

Salida modificada

72004899337.38588

Esto puede ser demasiado fácil. :PAGS


¿Agrietado? El resultado es ligeramente diferente en mi navegador (y completamente diferente con el intérprete de Java).
Dennis

@Dennis No estoy completamente seguro de por qué, pero los cambios son correctos.
The_Basset_Hound

3

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



3

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.


2
¿Hay caracteres no imprimibles en la salida?
Sp3000

Parece que algunos fueron comidos, pero todavía quedan muchos no imprimibles cuando trato de copiar y pegar, así que supongo que esto es todo
Sp3000

@ Sp3000 Er- no, no debería haber ninguna no imprimible. ¿Qué intérprete estás usando?
Kurousagi

El método tampoco es igual al mío, sigue intentándolo.
Kurousagi

55
Si puede publicar los códigos ASCII reales de la salida, sería increíble.
Alex Van Liew

3

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.


@AlexVanLiew ¡ Tenga en cuenta que hay un espacio antes del primer m!
Dennis

@ Dennis ¡Oh no! Sabía que no podía ser tan simple.
Alex Van Liew

No estoy seguro, pero creo que lo tengo ...
Dom Hastings

@DomHastings ¡Sí! Bien resuelto Como alguien comentó sobre su solución, el carácter adicional puede ser un espacio extra en cualquier lugar. Dije Perl 5 "moderno" porque se eachaplica a una matriz solo desde alguna versión.
msh210

2
Si él no lo hubiera resquebrajado, ¿hubieras dicho "lo perdiste por una milla"? :RE
mbomb007


3

perl, 12 bytes

agrietado

Código

print sin 97

Salida original

0.379607739027522

Salida deseada

-0.64618863474386

1
Puedo confirmar que no es casi con toda seguridad print sin xx, print sin xx97o print sin 97xxdonde xxes cualquier par de números.
Alex Van Liew


@DomHastings de hecho, bien hecho. Por interés, ¿cómo hiciste eso?
Abligh

3
Después de leer el comentario de @ AlexVanLiew, he probado un número similar 9.?7, 9.7?etc, pero se dio cuenta que tenía que ser un operador. Intenté todo lo que se me ocurrió en fragmentos como si perl -e 'print map{sin((+"9${_}")x7).$/}1..9'finalmente obtuviera la combinación correcta.
Dom Hastings

@DomHastings tardó +1 por tu crack entonces.
Abligh

3

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.

Traté de hacer que un intérprete de SWI-Prolog funcionara el otro día, pero no pude, así que apuñalaré en la oscuridad; si elimina el Ey Fen las printdeclaraciones, ¿obtiene lo que desea?
Alex Van Liew

@AlexVanLiew Recibo errores de sintaxis de eso
Sp3000

@AlexVanLiew Incorrecto
Fatalize

Ah bueno. Merece un intento.
Alex Van Liew

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.