Para el desafío de la policía principal, haga clic aquí

AVISO : este desafío ahora está cerrado. Las grietas que se publiquen ahora no se contarán en la tabla de clasificación y la respuesta aceptada no cambiará.

Reto

Dado el programa original, su salida y la salida del programa modificado, debe averiguar qué caracteres deben cambiarse, eliminarse o agregarse para obtener la salida esperada.

Cuando descifre el código de alguien, deje un comentario con un enlace a su crack en su respuesta.

Formateo

# [<language>, <username of program owner>](<link to answer>)

## Description

<description of change and how you found it>

## Code

<changed code>

Victorioso

La persona que ha encontrado la mayor cantidad de soluciones gana.

Tabla de clasificación

13 grietas:

• Dennis

8 grietas:

• Alex Van Liew

5 grietas:

• Sp3000
• isaacg

3 grietas:

• Luis Mendo
• jimmy23013
• Dom Hastings

2 grietas:

• mbomb007
• Sluck49

1 grieta:

• El numero uno
• Jakube
• Orgulloso Haskeller
• David Zhang
• samgak
• paul.oderso
• rayryeng
• mgibsonbr
• n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳
• Stewie Griffin
• abligh

CJam, por Mauris

Descripción

El código original de Mauris hace lo siguiente:

"f~"     e# Push that string on the stack.
    :i   e# Cast each to integer. Pushes [102 126].
      :# e# Reduce by exponentiation. Pushes 102^126.

Ningún otro operador matemático de CJam produciría un número tan grande para entradas pequeñas, por :#lo que no puede modificarse. Dado que #, cuando se usa para exponenciación, solo toma enteros como entrada, :ino se puede eliminar también. Esto deja solo un lugar para modificar la entrada: la cadena "f~".

No importa cuántos caracteres contenga la cadena, el resultado será una torre de poder asociativa a la izquierda. CJam admite caracteres en el rango de 0 a 65535 (con la excepción de los sustitutos), por lo que tenemos que expresar la salida como b ^{n × k × j} , donde b , n , k y j son enteros en ese rango.

El logaritmo decimal del número entero que resulta del código modificado es ligeramente más pequeño que log ₁₀ (2.44 × 10 ²⁴²⁵⁴⁵ ) = log ₁₀ (2.44) + 242545 , por lo que podemos dividir este valor por los logaritmos de todas las bases posibles para encontrar los valores adecuados para n × k × j .

De hecho:

$ cjam <(echo '65536,2>{2.44AmL242545+1$AmL/i:I#s8<"24399707"=}=SIN')
5 347004

Comparar los primeros 8 dígitos resultó ser suficiente.

Esto significa que podemos expresar la salida como 5 ^347,004 = 15625 ^57,834 = 125 ^{9 × 102 × 126} , por lo que es suficiente reemplazar "f~"con "㴉"o"} f~" .

Código

"㴉":i:#

o

"}  f~":i:#

Tenga en cuenta que los espacios en el código ASCII en realidad deberían ser un tabulador.

Intentar ejecutar este código en el intérprete en línea es probablemente una mala idea, pero así es como puede verificar los resultados desde la línea de comandos:

$ wget -q https://bpaste.net/raw/f449928d9870
$ cjam <(echo '[15625 57834]:c`":i:#") > mauris.cjam
$ cat mauris.cjam; echo
"㴉":i:#
$ cjam mauris.cjam | diff -s - f449928d9870
Files - and f449928d9870 are identical
$ echo -en '"}\tf~":i:#' > mauris-ascii.cjam
$ cat mauris.cjam; echo
"}  f~":i:#
$ cjam mauris-ascii.cjam | diff -s - f449928d9870
Files - and f449928d9870 are identical

Ruby, histocrat

Descripción

Se cambió x para ser una matriz en lugar de escalar agregando *

Cambió el último 9para que sea una cadena en lugar de un número agregando?

El resultado está hecho de una matriz con un único elemento ( [9]) multiplicado 9 veces y luego implosionado con un "9"separador.

Código

x=*9;puts x*9*?9

Pitón 2, pez lodoso

Descripción

A través de pruebas y tribulaciones que implican factorizar grandes números y buscar factores consecutivos, me di cuenta de que cambiar el 87654 a 58116 sería suficiente. Entonces, factoricé 58116 como 87 * 668. Luego me di cuenta de que 01234 = 668, así que solo necesitaba cambiar 87654 a 87 y eliminar el 01234 por completo. Esto se logra con un comentario.

Código

print (sum(range(054321)*9876)*87)#654)/01234

Shakespeare, Above Fire

En la escena III, uno tiene que cambiar a Claudio en Claudio en el siguiente fragmento:

[Enter Claudio]

Claudius:
 Thou art as stupid as the sum of thee and the product of the 
 product of me and Helen and Helena

[Exeunt]

Código modificado:

The Hidden Change.

Helen, a young woman with a remarkable patience.
Helena, a likewise young woman of remarkable grace.
Claudio, a remarkable man much in dispute with Claudius.
Claudius, the flatterer.
The Archbishop of Canterbury, the useless.


          Act I: Claudius's insults and flattery.

          Scene I: The insulting of Helen.

[Enter Claudius and Helen]

Claudius:
 Thou art as hairy as the sum of a disgusting horrible fatherless 
 dusty old rotten fat-kidneyed cat and a big dirty cursed war.
 Thou art as stupid as the product of thee and a fat smelly 
 half-witted dirty miserable vile weak son.

[Exeunt]

          Scene II: The complimenting of Helena.

[Enter Claudio and Helena]

Claudio:
 Thou art the sunny amazing proud healthy peaceful sweet joy.
 Thou art as amazing as the product of thee and the pretty
 lovely young gentle handsome rich Hero. Thou art as great 
 as the sum of thee and the product of a fair golden prompt good honest 
 charming loving noble king and a embroidered rich smooth golden angel.

[Exeunt]

          Scene III: The insulting of Claudio

[Enter Claudius and Helen]

Helen:
 Thou art as stupid as the sum of the sum of thee and a cat and me.
[Exit Helen]

[Enter Claudio]

Claudio:
 Thou art as stupid as the sum of thee and the product of the 
 product of me and Helen and Helena

[Exeunt]

          Scene IV: The Final Countdown

[Enter The Archbishop of Canterbury and Claudius]

Claudius:
 Thou art the sum of you and a cat.

The Archbishop of Canterbury:
 Am I better than a fine road?

Claudius:
 If not, let us return to the insulting of Claudio.

[Exit The Archbishop of Canterbury]

[Enter Claudio]

Claudius:
 Open your heart!
 Open your heart!
[Exeunt]

Usando el compilador vinculado por @AboveFire, esto imprime 11.

Prólogo, Fatalizar

Descripción

Añadir dos \s. \es negación bit a bit y \/es bit a bit o.

Código

X is \1\/42.

MATLAB / OCTAVE, Stewie Griffin

Un poco de aritmética compleja.

acos(i)

C, LambdaBeta

Descripción

Conviértete main(a,_)en main(_). El primer argumento de main es el argcque se inicializa como 1.

Código

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

Python 2, rp.belrann

Cambie la comprensión de la lista más externa a una comprensión establecida. Crédito parcial a @ mbomb007, que eliminó todas las soluciones "aburridas" (intercambiar xy cambiar y, ajustar operadores, cambiar el rango).

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

Explicación:

En el original, [(x,y)[x%2]for x in[y for y in range(8)]]genera la siguiente lista:

[0, 7, 2, 7, 4, 7, 6, 7]

Esto se debe a que en Python 2.7, la ycomprensión en la lista interna se filtra en el ámbito de cobertura en su último valor conocido (que, al final de un rango, es 7). Entonces, en la tupla, ysiempre es 7. x, sin embargo, pasa por la lista como normal, que va de 0 a 7. Cuando xes par, elige el valor de x, cuando es impar, elige y(que siempre es 7). Noté que si incluía exactamente un 7 y todos los demás valores de x, obtenía 19; entonces me di cuenta de que podía transformar la comprensión externa en una comprensión establecida, lo que eliminaría todos los valores duplicados y me dejaría con exactamente 19.

Esto fue bastante inteligente, no creo que haya usado antes una comprensión fija. Prestigio.

Jonas, Matlab / Octave

Descripción

Noté que la respuesta era i^pi, así que solo tuve que convertirme sinen un nop.

Código

0i+(i^pi)

s-> 0, n->+

Bash, Dennis

Código original:

echo {{{1..9}}}

Salida original:

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

Código modificado:

echo {,{1..9},}

Salida modificada:

1 2 3 4 5 6 7 8 9

Explicación:

En Bash puede generar una lista de elementos separados por comas dentro de un par de llaves, así:

echo {a,b,c}

huellas dactilares

a b c

Entonces, el código modificado está imprimiendo una lista de nada, los números 1..9, nada.

MATLAB, Luis Mendo

Código original:

-sin(2:.5:3)    
ans =    
   -0.9093   -0.5985   -0.1411

Nueva respuesta:

psi(2:.5:3)
ans =
    0.4228    0.7032    0.9228

Descripción:

Cambiado -sina psi, la función de polígama en MATLAB. El -signo se sustituye por py nse elimina.

C, LambdaBeta

Descripción

Cambie -1a *0para que el resultado de la multiplicación sea 0(un valor falso).

Código

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

Brainfuck, Kurousagi

Descripción

Retire el primero >y cambie el primero <a.

Probado en brainfuck.tk . Tenga en cuenta que la salida no coincide con el post de Kurousagi exactamente , debido a SE comiendo caracteres no imprimibles.

Código

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

Fantom, Caín

La seguridad a través de la oscuridad es una forma de seguridad muy pobre (especialmente cuando los dos métodos están uno al lado del otro en los documentos de Fantom y cualquiera que sepa cómo es un flotador sabrá inmediatamente qué hacer).

Float.makeBits32(1123581321)

CJam, por Basset Hound

25me

Calcula e ²⁵ . Pruébalo en línea.

El intérprete en línea da un resultado ligeramente diferente en mi navegador, lo que parece ser un problema de redondeo.

El intérprete de Java imprime 7.200489933738588E10, que es el resultado deseado, pero en un formato diferente.

Python 2, Sp3000

Descripción

Cambiado 01234a 0x1234y minpara 9in.

El hecho de que 4669 = (01234-1)*sum(m<<m in R for m in R)es engañoso.

Código

R=range(0x1234);print sum(m<<9in(m,n)for m in R for n in R)

MATLAB / Octave, Stewie Griffin

Descripción

Esto requería negar la entrada a la función anónima g, así como cambiar el factor de escala de la gfunción a 2 en lugar de 7:

Código

>> f=@(x)x^.7;g=@(x)2/f(x);g(-7)

ans =

  -0.3011 - 0.4144i

Perl, sobretodo

Descripción

Agregar operador de repetición de cadena, x e inserte un dígito adicional

Código

print sin 95x7

Java, TheNumberOne

Descripción

El programa es una implementación única Random.next()con una semilla inicial de Integer.MAX_INTy todos los números hexadecimales convertidos a decimal. Cambiar la semilla al complemento de MAX_INTgenera la salida:

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

(dado que debe haber exactamente dos cambios, elija cualquier tipo de cambio sin operación: agregar un espacio en algún lugar, un punto y coma adicional, etc.)

Brainfuck, AboveFire

este programa es una modificación de este código, me responde una cookie. esa respuesta funciona primero calculando previamente una tabla de códigos ascii útiles de caracteres útiles, y luego tiene tres declaraciones condicionales formadas por tres bucles a los que se ingresa teniendo un1 posición correcta.

El comienzo de cómo rompí el código es que el patrón de repetición en la salida modificada es principalmente lo que se imprime si ingresas el tercer bucle con la tabla desplazada a la izquierda.

++++++++++[->++++++++<]>>++++++[-<---------->]<-------[----------->>>-<<+<[->->+<<]]>>>+<<>>>+++[->++++++++++<]>(<)++ .<+++++++++[->>>>>>>++++++++++<+++++<++++++++++++++<++++++++++<+++++<++++++++++<<]++++++++++>>+++++...>++>++>-->+>(>)++++<<<<<<<.<<<[->>>>>>.<<>>>>>.<<<<<.>>>>>.<<<<<>>>.<<<<.>>>>>.<<<<.>>>>>.<<<<<.>>>>.<<<<<.>>>>.<<...>.<<<<<<]>[->>>>>.<<...>>>.<<<<.>>>>>.<<<<...>>>>.<<<<<.>>>>.<<...>.<<<<<]>[->>>>.<<>>>>>>.<<<<<<..>>>.<<<<.>>>>>.<<<<>>>>>>.<<<<<<.>>>>>>.<<<<<<>>>>.<<<<<.>>>>.<<...>.<<<<]

(los caracteres adicionales están marcados con paréntesis)

Pitón 2, pez lodoso

Descripción

Cambie <<a <>(versión obsoleta de !=) y 0x156a 0156, el punto de código para "n"(que aparece 3 veces en la cadena de longitud 23'<built-in function sum>' ).

Código

print sum((ord(i)<>0156 for i in `sum`))

JavaScript, por Razvan

Descripción

La salida modificada es claramente el número natural de Euler, al que se puede acceder como Math['E'] .

Al cambiar ''a '3'y 32a 36, String.fromCharCodegenera elE .

Código

a=1,b=a*2,c=a+b,d=[a+b];while(c>b)c-=a;for(i=1;i<=c;i++)d.push(i);i='3'+c*d['length']*d['length'];alert(Math[String.fromCharCode(i.charCodeAt(0) * i.charCodeAt(1) / 36)])

Fantom, Caín

Descripción

La indexación de la matriz ya está configurada, así que solo necesito hacer un 55. Honestamente, la parte más difícil fue descargar el idioma.

Código

[7115432d/9,219.or(64),37,55,55][3]

(Insertó una coma, 0-> 3)

Shakespeare, Above Fire

NO CORRECTO - lo siento :(

Lo investigaré más cuando llegue a casa del trabajo. En el valor original de Claudio es 1132462081 y el valor de Claudio es 1

En la escena final, el valor de Claudio se imprime dos veces,

[Enter Claudio]

Claudius:
 Open your heart!
 Open your heart!

abre tu corazón x2 = valor de impresión de la otra persona en el escenario (Claudio). Entonces, si cambia Claudius a Claudio (2 caracteres), se imprimirá el valor de Claudius, que es 1, dos veces

The Hidden Change.

Helen, a young woman with a remarkable patience.
Helena, a likewise young woman of remarkable grace.
Claudio, a remarkable man much in dispute with Claudius.
Claudius, the flatterer.
The Archbishop of Canterbury, the useless.


          Act I: Claudius's insults and flattery.

          Scene I: The insulting of Helen.

[Enter Claudius and Helen]

Claudius:
 Thou art as hairy as the sum of a disgusting horrible fatherless 
 dusty old rotten fat-kidneyed cat and a big dirty cursed war.
 Thou art as stupid as the product of thee and a fat smelly 
 half-witted dirty miserable vile weak son.

[Exeunt]

          Scene II: The complimenting of Helena.

[Enter Claudio and Helena]

Claudio:
 Thou art the sunny amazing proud healthy peaceful sweet joy.
 Thou art as amazing as the product of thee and the pretty
 lovely young gentle handsome rich Hero. Thou art as great 
 as the sum of thee and the product of a fair golden prompt good honest 
 charming loving noble king and a embroidered rich smooth golden angel.

[Exeunt]

          Scene III: The insulting of Claudio

[Enter Claudius and Helen]

Helen:
 Thou art as stupid as the sum of the sum of thee and a cat and me.
[Exit Helen]

[Enter Claudio]

Claudius:
 Thou art as stupid as the sum of thee and the product of the 
 product of me and Helen and Helena

[Exeunt]

          Scene IV: The Final Countdown

[Enter The Archbishop of Canterbury and Claudius]

Claudius:
 Thou art the sum of you and a cat.

The Archbishop of Canterbury:
 Am I better than a fine road?

Claudius:
 If not, let us return to the insulting of Claudio.

[Exit The Archbishop of Canterbury]

[Enter Claudio]

Claudio: << changed Claudius to Claudio
 Open your heart!
 Open your heart!
[Exeunt]

VBA por JimmyJazzx

Cambiado IRRa MIRRy cambió 5a una, modo hay 3 parámetros.

Encontré esto mientras buscaba cómo IRRfunciona la función de Excel . Había un artículo: Cómo la función MIRR de Excel puede arreglar la función IRR . Eso me avisó. Intento inteligente, sin embargo. Nunca había usado VBA antes, así que eso también fue interesante.

Sub q()
Dim a(2) As Double
a(0)=-5
a(1)=10
msgBox MIRR(a,0.2,3)
End Sub

Matlab / Octave, Jonas

Descripción

En la última línea, agregue 'para transformar arg'en la cadena 'arg', que luego se interpretará como números ASCII. Y luego agregue otro 'al final para mantener el formato de columna.

Lo casi innecesario 'en el código original era la pista principal. Además, en retrospectiva, el hecho de que argse definió por separado (en lugar de directamente dentro delsin línea) debería haber parecido sospechoso.

Código

format long
arg = [.1 .2 .3];
sin('arg'*exp(9))'

bc, abligh

Simplemente insertó los operadores matemáticos. Tomó alrededor de 1 minuto para resolver una vez que miré qué era bc y qué operaciones matemáticas tenía. Lo primero que pensé fue en la división, pero no había factores comunes que se vieran bien. Entonces inmediatamente fui por exponenciación y módulo. Al menos 15 dígitos fueron necesarios para el módulo b / c de la salida esperada. Después de eso, lo adiviné dos veces y lo encontré.

4518^574%615489737231532

Lua, TreFox

Descripción

"_G" es la tabla global, por lo que "_G.load" se refiere a la función global "load". La conversión de una función en una cadena da como resultado la devolución de la dirección de la función, que luego se convierte en la longitud de la cadena por el operador de longitud "#".

Código

G={load="lfkjgGsHjkU83fy6dtrg"}
print(#tostring(_G.load))

Además, dado que esta es mi primera publicación aquí, no puedo hacer un comentario sobre la respuesta original.

Python, rp.beltran

Descripción

Noté que las letras necesarias siempre eran 2 delante de un dígito. cambiando el tercero \wpara \dobtener todas las letras correctas, excepto los espacios. \Dfue el único \grupo que pude encontrar que permitía letras y espacios.

Código

import re;''.join(re.findall('\D(?=\w\d)','t74q joh7 jv f9dfij9j bfjtf0e nnjen3j nnjrb6fgam3gtm5tem3hj s3eim7djsd3ye d5dfhg5un7ljmm8nan3nn6n k m2ftm5bsof5bf r5arm4ken8 adcm3nub0 nfrn6sn3jfeb6n d m6jda5 gdif5vh6 gij7fnb2eb0g '))

w-> D, w-> den la expresión regular.

Pyth, Isaac

Descripción

El código original hace lo siguiente:

 CG      Convert "abcdefghijklmnopqrstuvwxyz" from base 256 to integer, yielding
         156490583352162063278528710879425690470022892627113539022649722.
   ^3y21 Compute 3^(2 * 21).
%        Calculate the modulus.

Desde 156490583352162063278528710879425690470022892627113539022649722 - 58227066 da 156490583352162063278528710879425690470022892627113538964422656 , que es igual a 2 ²⁶ × 3 × 7 × 7477 × 381 524 422 711 × × 17007550201751761 2288745700077000184147 , la salida deseada se puede obtener mediante la sustitución ^3y21con algo que se evalúa como un divisor de este producto y es mayor que 58.227.066 .

El ^en el código original sugiere que podríamos usarlo para calcular una potencia de 2 , el 3 que podríamos calcular un divisor de ajuste de la forma 3 × 2 ⁿ .

Ambos son engañosos. Las soluciones con una distancia Levenshtein de 3 ( %CG^2 26, %CG^y2 13, %CG^4y13) o 4 (%CG.<3y13 ) se encuentran fácilmente, pero la solución a una distancia de 2 requiere un enfoque diferente.

El alfabeto en minúsculas ( G) tiene 26 letras, por lo que su conjunto de potencia (el conjunto de todas las secuencias estrictamente crecientes de letras minúsculas) tiene 2 ²⁶ elementos. Al reemplazar y2conyG , calculamos este conjunto de potencia.

Podemos recuperar la longitud del conjunto reemplazando 3conl , lo que nos deja ^lyG1, es decir, 2 ²⁶ elevado a la primera potencia.

Código

%CG^lyG1

Tenga en cuenta que esto solo funcionará en una computadora con suficiente memoria disponible (aproximadamente 6.43 GiB, según time), por lo que no funcionará con el intérprete en línea.

A continuación, le mostramos cómo puede verificar los resultados desde la línea de comandos:

$ \time -v pyth -c '%CG^lyG1'
58227066
        Command being timed: "pyth/pyth.py -c %CG^lyG1"
        User time (seconds): 30.73
        System time (seconds): 2.12
        Percent of CPU this job got: 100%
        Elapsed (wall clock) time (h:mm:ss or m:ss): 0:32.85
        Average shared text size (kbytes): 0
        Average unshared data size (kbytes): 0
        Average stack size (kbytes): 0
        Average total size (kbytes): 0
        Maximum resident set size (kbytes): 6742564
        Average resident set size (kbytes): 0
        Major (requiring I/O) page faults: 0
        Minor (reclaiming a frame) page faults: 2269338
        Voluntary context switches: 1
        Involuntary context switches: 58
        Swaps: 0
        File system inputs: 0
        File system outputs: 0
        Socket messages sent: 0
        Socket messages received: 0
        Signals delivered: 0
        Page size (bytes): 4096
        Exit status: 0