Dos marca la diferencia: ladrones

29

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
Decaimiento Beta
fuente
1
@ mbomb007 ¿Puede abstenerse de editar esta publicación, porque me dificulta saber dónde estoy cuando actualizo la clasificación
Beta Decay

Respuestas:

10

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 10 (2.44 × 10 242545 ) = log 10 (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
Dennis
fuente
11
Uno no simplemente vence a Dennis en CJam
Fatalize
¿Cómo descubriste qué números usar?
Alex Van Liew
@AlexVanLiew Fuerza bruta. Actualmente estoy escribiendo una explicación. Solo quería publicar el crack antes de que alguien más lo hiciera.
Dennis
@ Dennis: bastante justo. Estaba intentando este pero no conozco a CJam; Pensé que la solución prevista implicaba usar realmente ~fen algún lugar del programa.
Alex Van Liew
1
@Mauris La pregunta dice que solo se cambian dos caracteres en el programa (el énfasis es mío), así que asumí que esto estaba bien. De todos modos, factorizar el número fue la parte difícil.
Dennis
15

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
Razvan
fuente
12

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
isaacg
fuente
Sí, casi exactamente como lo tuve (el mío era print sum(range(054321)*9876)*87#654)/01234)
Azul
¡Listo, listo! ¡Me alegra que alguien lo haya entendido y que haya sido más interesante que "jugar con números"!
Alex Van Liew
11

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.

plannapus
fuente
2
¿Puedes aclarar qué personajes fueron cambiados? No es exactamente fácil verlo de un lado a otro.
mbomb007
Maldición, 15 minutos tarde. Felicidades.
Sumyrda - Restablece a Mónica el
2
Jeebus H. Christ. ¡Buen trabajo!
rayryeng - Restablece a Mónica el
1
@ mbomb007 Espero que mi edición lo haya aclarado. AboveFire: lo siento :)
plannapus
3
@plannapus Jaja, está bien, pero la forma prevista de borrarlo era reemplazar la palabra "rey" por "cerdo". Con este cambio, Helena era igual a 0 y "la suma de ti y el producto del producto de mí". y Helen y Helena "era igual a 1. Hice una lista de todas las palabras que podrían invertirse con dos letras y usé muchas de ellas en mi código (por ejemplo: alegría-> cerdo-> hijo, guerra-> gato, road-> toad, Hero-> Hell, curse-> monedero, helen-> helena, claudio-> claudius y muchos otros) Lo único que puede cambiar un programa de Shakespeare con 2 caracteres es el cambio de una variable, el cambio de un sustantivo y el cambio de un goto.
AboveFire
10

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.
Sp3000
fuente
Solución correcta
Fatalize
7

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":"?");}
El numero uno
fuente
Esa es la solución que tenía en mente. Buena atrapada. Por cierto, si el argumento se carga en la celda de memoria 1, esto no funcionará. Simplemente no puedo pensar en ningún sistema que haga eso que también pueda ejecutar los diversos idiomas interpretados en esa página.
LambdaBeta
6

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.

Alex Van Liew
fuente
no Eso no es. print len('~'*sum([(x,y)[x%2]for x in[y for y in range(6)]]))vuelve 21. Simplemente asigne el código a una variable y luego imprima si es igual a la cadena que desea. Si ves True, lo descifraste.
mbomb007
Extraño. _me traicionó, supongo.
Alex Van Liew
@ mbomb007 Lo tengo.
Alex Van Liew
Me tienes. Bien hecho.
rp.beltran
6

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

isaacg
fuente
Bien hecho señor.
rayryeng - Restablece a Mónica el
¡¡Muy bien hecho!!
Luis Mendo
5

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.

samgak
fuente
5

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.

Stewie Griffin
fuente
4

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":"?");}
Jakube
fuente
Vaya, parece que introduje un (¿falla de seguridad?) Durante mi golf. Lo meditaré ociosamente para ver si puedo solucionarlo. Buena captura sin embargo.
LambdaBeta
4

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

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[>.+<-]
Sp3000
fuente
@muddyfish Enlacé esta respuesta en mi segundo comentario, pero todavía estoy esperando la confirmación de Kurousagi
Sp3000
4

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)
Alex Van Liew
fuente
1
¡Me tienes por 1 minuto! bien jugado
AboveFire
1
Jaja me tienes, disfruta el crack gratis
Caín
@Cain Fue oo intencional
The_Basset_Hound
1
@BassetHound Quiero decir, fue más un experimento social, para ver si la gente se molestaría en aprender un lenguaje oscuro para el crack. Sin embargo, debería haber hecho más difícil tomar un trabajo real.
Caín el
4

CJam, por Basset Hound

25me

Calcula e 25 . 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.

Dennis
fuente
Jeje, fue fácil. Especialmente para un dios CJam. Correcto.
The_Basset_Hound
4

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)
jimmy23013
fuente
¡Bien hecho! Tenía m<<m in(m,n), pero lo principal era cambiar elmin a in.
Sp3000
4

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
rayryeng - Restablece a Monica
fuente
Gracias por tu comentario sobre mi respuesta (ahora eliminada). Publiqué uno nuevo (muy similar) que se puede descifrar usando WolframAlpha. Creo que es más justo.
Dr. belisarius
4

Perl, sobretodo

Descripción

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

Código

print sin 95x7
Dom Hastings
fuente
3

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

Alex Van Liew
fuente
1
Integer.MAX_VALUEInteger.MAX_VALUE+1Integer.MIN_VALUE
Bien
Oh, sabes que? Lo intenté, +1pero como lo estaba haciendo en Python, simplemente rodó mucho, jajaja. Ese fue mi primer pensamiento, en realidad.
Alex Van Liew
3

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)

orgulloso Haskeller
fuente
3

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`))
Sp3000
fuente
3

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)])
Dennis
fuente
Si eso es correcto. Aún así, en realidad era algo más profundo, pero parece que podrías evitarlo con este truco. Pensaré en otra cosa y volveré.
Razvan
3

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)

isaacg
fuente
Bueno, esa no era la solución prevista, mi arenque rojo era una solución real
Caín
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]
Alex Carlsen
fuente
No, el valor de Claudio no es 1 xD. Mejor suerte la próxima vez.
AboveFire
@AboveFire - crud ... Voy a echarle otro vistazo cuando llegue a casa, realmente pensé que lo tenía :(
Alex Carlsen
Esa también fue mi primera suposición, pero aún no tuve la oportunidad de probarlo. De todos modos, la única parte que aún no entendí es la del arzobispo, así que lo veré cuando llegue a casa.
Sumyrda - Restablece a Mónica el
3

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
mbomb007
fuente
Agradable. Técnicamente agregué tanto la M como la, por lo que el argumento medio fue 0.25 pero creo que terminan teniendo el mismo resultado de todos modos. Se pensó que el uso de algunas funciones financieras podría confundir a los programadores, pero la documentación lo reveló. Buen trabajo
JimmyJazzx
3

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))'
Luis Mendo
fuente
3

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
mbomb007
fuente
3

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.

Xrott
fuente
He dejado un comentario sobre la respuesta del policía. Por cierto, esto no funciona para mí. La dirección que obtengo es 0x321a40c6d0, para una salida final de 22.
Dennis
No estoy seguro de por qué estás obteniendo 22 ... en todo lo que probé fue 18 o 26.
TreFox
@Dennis Pruébalo en la demostración oficial de lua.
Xrott
¡Ajá, estaba tan cerca! Sabía que necesitaba el global load, y sabía que se _Grefería a la tabla de símbolos global ... Simplemente no puse los dos juntos.
Alex Van Liew
3

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.

isaacg
fuente
3

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 26 × 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 n .

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 26 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 26 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
Dennis
fuente
¡Correcto! Bien hecho.
isaacg