"¡Hola Mundo!" (Hilo de ladrones)

11

Este es el hilo de los ladrones. El hilo de la policía está aquí .

Su desafío es tomar una presentación sin descifrar del hilo de la policía y encontrar, para qué entrada o entradas, el programa se imprimirá Hello, World!y una nueva línea. La capitalización, el espaciado y la puntuación deben ser exactos.

Comenta sobre el envío del policía cuando hayas descifrado su código.

MD XF
fuente

Respuestas:

12

Bash por Sisyphus

Código original:

[[ ! "${1////x}" =~ [[:alnum:]] ]]&&[[ $# = 1 ]]&&bash -c "$1"

Entrada:

__=; (( __++, __-- ));
(( ___        = __,        ___++));
(( ____       = ___,       ____++));
(( _____      = ____,      _____++));
(( ______     = _____,     ______++));
(( _______    = ______,    _______++));
(( ________   = _______,   ________++));
(( _________  = ________,  _________++));

${!__##-} <<<\$\'\\$___$______$_______\\$___$______$_____\\$___$_______$__\\$___$_______$_________\'\ \$\'\\$___$___$__\\$___$______$_______\\$___$_______$______\\$___$_______$______\\$___$_______$_________,\ \\$___$____$_________\\$___$_______$_________\\$___$________$____\\$___$_______$______\\$___$______$______\\$__$______$___\'

Explicación:

Esto codifica "echo Hello, World!" como secuencias de escape octal (\ xxx).

Excepto que tampoco puede usar números, por lo que la primera parte acumula variables para los números 0-7. Puede usarlos para construir una cadena con secuencias octales que evaluarán para darle el comando real.

Pero evaltambién es alfanumérico. Entonces, en cambio, esto canaliza esa cadena como entrada a otra instancia de bash. $0contiene el nombre del comando utilizado para invocar Bash, que generalmente es solo bash(o -bashpara un shell de inicio de sesión) si lo está ejecutando normalmente (a través de TIO o pegándolo en un terminal). (Esto, por cierto, significa que si intentas ejecutar esto pegándolo en un script, las cosas saldrán terriblemente mal, ya que intenta bifurcarse varias veces).

Pero de todos modos, no se puede decir $0directamente. En su lugar, $__contiene el nombre de $0("0"), y puede utilizar la expansión indirecta para acceder a él (se ${!__}refiere al contenido de $0).

Y eso, finalmente, te da todas las piezas que necesitas.

ArchDelacy
fuente
¡Bienvenido a Programming Puzzles & Code Golf! He dejado un comentario sobre la respuesta del policía. Enlace TIO para los interesados: tio.run/##jc/…
Dennis
¡Agradable! Mi solución parecía diferente, pero usaba la misma idea: construir una cadena octal y usar la sintaxis de comillas simples en dólares, y usar indirección. Bien hecho =)
Sísifo
4

05AB1E , Adnan

•GG∍Mñ¡÷dÖéZ•2ô¹βƵ6B

-107

Pruébalo en línea!

¿Cómo?

•GG∍Mñ¡÷dÖéZ•        - big number
             2ô      - split into twos (base-10-digit-wise)
               ¹β    - to base of input
                   B - convert to base (using 012...ABC...abc...):
                 Ƶ6  -   107 (ToBase10(FromBase255(6))+101 = 6+101 = 107)
Jonathan Allan
fuente
Base negativa ... bonita ...
Erik the Outgolfer
3

totalmente humano , Python 2

Una solución es

'Uryyb, Jbeyq!' 
Ad Hoc Garf Hunter
fuente
¿Explicación? ----
MD XF
3

Pyth : Sr. Xcoder

"abcdefghijklmnopqrstuvwxyz"

Ges el incorporado para el alfabeto en minúsculas. El código verifica la igualdad contra eso.

totalmente humano
fuente
1
Nice crack :)))
Mr. Xcoder
3

Jalea: EriktheOutgolfer

〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ〡㋄ⶐ✐сᑀ⟙ⶐⶐ〡ސЀᶑ

Jalea , 11 bytes

sLƽ$Xṙ5O½Ọ

Pruébalo en línea!

Explicación

El código original se puede explicar como tal:

sLƽ$Xṙ5O½Ọ  Main link; argument is z
s            Split z into n slices, where n is:
    $
  ƽ         The integer square root of
 L                                      the length of z
     X       Random of a list. Returns a random row of the input put into a square
      ṙ5     Rotate the list left 5 times
        O    Get codepoints
         ½   Floating-point square root
          Ọ  From codepoints

Entonces, solo toma "¡Hola, mundo!" y obtener puntos de código, cuadrarlos, volver a los puntos de código, rotar a la derecha 5 veces, y luego cuadrar y aplanar el resultado.

Hiperneutrino
fuente
3

Octave por Stewie Griffin

No estoy seguro de si esta es la solución correcta (en TIO imprime el \00personaje), pero en mi octave-clishell se ve así:

Cáscara de octava

También en el desafío original dice que no imprima nada (o el carácter nulo) , por lo que si nada es lo mismo, \00entonces debería estar bien.

[72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33, 0]

Pruébalo en línea!

ბიმო
fuente
Pero ese no es el aspecto del desafío, si es así, esto sería mucho más fácil (reemplazar el último 0con a 10).
ბიმო
@BruceForte Eso es lo que pregunta el desafío: "Su desafío es escribir un programa o función que, con cierta entrada, imprima la cadena exacta Hello, World!y una nueva línea". Es una cita exacta del desafío. Y de hecho, eso hace que la respuesta sea trivial.
hvd
@hvd Sí, pero si miras la imagen del OP, su solución no lo hace, de ahí viene la confusión principal.
ბიმო
1
@HyperNeutrino FWIW esto es lo que creo que es el estilo de solución previsto.
Jonathan Allan
3

JavaScript (ES6) Por Ephellon Dantzler

{length:1, charCodeAt:()=>(e='Hello, World!', String.fromCharCode=()=>'')}

Pruébalo en línea!

Eso fue bastante fácil.

Me di cuenta de que no sería posible generar ninguna entrada de cadena Hello, World!porque todo lo que está dentro String.fromCharCodesolo devolverá múltiplos de 4 y !tiene un código char de 33. Así que claramente solo tenemos que hackear todo el programa. Hackear los elementos integrados en JavaScript es trivial si uno no trata de detenerlos (e incluso si lo hace, generalmente hay muchas soluciones alternativas ...).

Voile
fuente
3

JavaScript (ES6), Voile

Proxy simple que solo devuelve el carácter deseado cada 3 veces que se llama.

var i = 0;
var string = "Hello, World!";
var proxy = new Proxy([], {
  get: function(target, property) {
    if (!(++i%3)) {
      return string[property];
    }
    return [1];
  }
});

Pruébalo en línea!

Birjolaxew
fuente
2
Sí, esta es la solución prevista :) Proxy necesita más amor.
Voile el
3

Ruby, por Histocrat

La entrada mágica es: 1767707618171221 30191World!

Pruébalo en línea.

Explicación:

  • el número 1767707618171221es primo y, escrito en base 36, lo es "hello". Cuando se escribe con mayúscula, esto produce "Hello", que se imprime usando$><<
  • la línea $><<", #$'"if/30191/busca el número 30191en la entrada y escribe en stdout una cadena compuesta por una coma, un espacio y cualquier cosa que esté en la entrada después de 30191(usando el $POSTMATCH, que se refiere aquí por su variante corta $').
Cristian Lupascu
fuente
3

Lua 5.1 por tehtmi

Pase esto como el primer argumento:

C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))

Suponiendo que el código original está en un archivo tehtmi.lua, ejecute (en bash o un shell similar):

lua tehtmi.lua 'C=("").char;_G[C(112,114,105,110,116)](C(72,101,108,108,111,44,32,87,111,114,108,100,33))'

También funciona en Lua 5.3, que es lo que usa TIO, entonces, ¿por qué no lo prueba en línea ? No he probado en una implementación que utiliza el núcleo "PUC-Rio's Lua 5.1" (porque realmente no puedo encontrar ninguna información), pero mi solución probablemente también funcione allí.

¿Cómo?

Ejecuta el primer argumento como código, pero solo si contiene menos de 5 caracteres en minúscula.

El truco es correr print("Hello, World!"). Otra forma de ejecutar esto es mediante el uso _G["print"]("Hello, World!"), que solo utiliza cadenas.

Pero no podemos usar la cadena directamente debido a la restricción de recuento en minúsculas, sin embargo, puede ejecutar ("").charpara obtener la función string.char, que puede convertir de una serie de bytes a una cadena. Lo asigné a una variable en mayúscula (para que no lleguemos al límite) para que podamos usarlo para construir tanto printlas Hello, World!cadenas como las que se pueden usar como se indica arriba.

Neui
fuente
Ah, bien hecho! Estaba pensando en usar en nextlugar de charlo que no funciona en Lua 5.3 debido a la aleatorización del orden de iteración.
tehtmi
3

JavaScript (ES6) por Voile

La entrada debe ser una cadena que contenga esto:

e(
`\
_\
=\
>\
"\
H\
e\
l\
l\
o\
,\
 \
W\
o\
r\
l\
d\
!\
"\
+\
\`
\`
`)

Pruébalo usando esto:

const e=eval,p=''.split,c=''.slice,v=[].every,f=s=>(t=c.call(s),typeof s=='string'&&t.length<81&&v.call(p.call(t,`\n`),l=>l.length<3)&&e(t)(t))

input='e(\n`\\\n_\\\n=\\\n>\\\n\"\\\nH\\\ne\\\nl\\\nl\\\no\\\n,\\\n \\\nW\\\no\\\nr\\\nl\\\nd\\\n!\\\n\"\\\n+\\\n\\`\n\\`\n`)'
console.log(f(input))

Si no le importa el requisito de nueva línea final para la salida, puede reemplazar las últimas 6 líneas con esto en su lugar:

!"
`)

Como lo hice

Las restricciones en la entrada son que es una cadena, cada línea tiene dos bytes de longitud o menos, y que la longitud total es de 80 bytes o menos. Mi primer intento después de entender eso correctamente fue este:

_
=>
`\
H\
e\
l\
l\
o\
,\
 \
W\
o\
r\
l\
d\
!
`

Nota: los \s deben ignorar las nuevas líneas en la cadena en la entrada. Esto es increíblemente crucial para la respuesta, y no puedo creer que me topé con él por accidente. (Estaba familiarizado con eso antes pero lo olvidé)

Pero esto no funcionó, ya que =>tiene que estar en la misma línea que los argumentos. Afortunadamente, tuve la idea de envolver algo similar en una cadena y poner una evaluación en mi entrada para reducirlo a una línea, lo que resultó en mi respuesta final. Después de que ocurre la evaluación en la entrada, se genera lo siguiente como una cadena (que luego se evalúa en una función y luego se ejecuta):

_=>"Hello, World!"+`
`

Esto fue realmente difícil de descifrar, pero al final tuve éxito.

Además, ¡el primer crack!

DanTheMan
fuente
3

Cúbicamente por MD XF

Me imagino que esto siempre es peligroso, pero creo que tengo una grieta, a la espera de que tenga razón en que hay un error en el intérprete (que acabo de compilar).

Mi entrada

0 1 0 1 0 1 0 1 1 0 1 0 0

La salida es Hello, World!\n\n\n\n\n\n\n\n\n\n.....con nuevas líneas interminables.

Pero noté la última sección del código:

:1/1+1$(@6)7

configura el bloc de notas en 0x0A(nueva línea) de forma aterradora, lee la entrada en la cara 7 (la cara de entrada) y luego imprime la cara 6 (cara del bloc de notas) repetidamente hasta que la cara 7 sea cero. Si establece la cara 7 en cero, solo debería obtener una nueva línea. Sin embargo, obtuve nuevas líneas infinitas y mi 13a entrada fue un cero, y puedo verificar que la 7 cara siempre es cero insertando un "número de impresión de 7 caras" en el bucle:

:1/1+1$(@6%7)7

luego imprime \n0pares interminables .

Estoy mirando las especificaciones en la página cúbicamente github y este comportamiento se parece mucho a un error. Cambiar el último carácter del programa original de 7a a 0resulta en el comportamiento esperado. El intérprete de TIO exhibe el mismo comportamiento incorrecto.

rexroni
fuente
Debería arreglarse ahora, tan pronto como Dennis tire Cubically se solucionará en TIO.
MD XF
2

CJam , Erik el Outgolfer

q5/:i:c

00072001010010800108001110004400032000870011100114001080010000033

Pruébalo en línea!

¿Cómo?

q       - Take input (string)
 5/     - split into chunks of five
   :i   - cast to integers
     :c - cast to characters
Jonathan Allan
fuente
2

C # (.NET Core) , Grzegorz Puławski

La solución que encontré hace un uso muy sustancial de caracteres no imprimibles, por lo que intentar pegarlo aquí no funcionó bien. Los valores de bytes para la entrada son:

109, 89, 4, 121, 3, 11, 8, 29, 37, 38, 27, 25, 72, 4, 4, 4, 3, 3, 3, 4, 4, 37, 3, 27, 4, 3

O la versión de cadena está disponible en el campo de entrada del enlace TIO.

Pruébalo en línea!

El programa original tomaría los caracteres distintos en la entrada, luego invertiría la entrada y multiplicaría los elementos de las dos listas. Por lo tanto, creé una cadena de 26 caracteres de longitud donde los primeros 13 caracteres eran distintos, los últimos 13 caracteres también aparecieron en los primeros 13 y cada par de índices se [i, 26-i]multiplicó al valor de byte del i-ésimo carácter en Hello, World!.

Kamil Drakari
fuente
¡Gran trabajo! Has logrado omitir la trampa Take (a.First () - 33). También me hizo darme cuenta de que olvidé Disctinct en el reverso, pero bueno, creo que fue un buen desafío. También tenía% 255, por lo que podría usar números más altos, en ASCII imprimible.
Grzegorz Puławski
2

Ly , LyricLy

n[>n]<[8+o<]

2 25 92 100 106 103 79 24 36 103 100 100 93 64

Pruébelo aquí (aunque la página no muestra la nueva línea).

ntoma entrada, intenta dividirse en espacios y lanzar a ints, estos se ponen en la pila. oimprime puntos ordinales y 8+hace lo que uno pensaría. Por lo tanto, la entrada debe ser 8 menos que los puntos de código en orden inverso divididos por espacios.

Jonathan Allan
fuente
Esto no imprime una nueva línea final, ¿verdad?
LyricLy
Ah, ¡ay, fácilmente rectificable!
Jonathan Allan
... en realidad lo es? Pensé 2que funcionaría, ¿es solo la página de herokuapp que no lo muestra?
Jonathan Allan
1
Sí, agregando 2 obras. La página simplemente no muestra nuevas líneas finales.
LyricLy
2

C (gcc), por Felix Palmen

Código original:

#define O(c)(((char**)v)+c)
#define W(c)*(O(c)-**O(2)+x)
main(x,v){puts(W(42));}

Argumentos:

"Hello, World!" ","

Pruébalo en línea!

Explicación:

W(c)está calculando la dirección de una cadena de la lista de argumentos para imprimir. Comienza con la dirección del argumento cth ( O(c)), que es el argumento 42 en este caso, y luego resta el primer carácter del segundo argumento ( **O(2)) como un desplazamiento de enteros, y luego suma x, que es el número de argumentos.

W(c)utiliza el segundo argumento, por lo que sabe que debe haber al menos 3 de ellos (0, 1, 2). Entonces "¡Hola, mundo!" puede ir en el primer argumento, y luego para abordar ese argumento necesita un carácter cuyo valor ASCII se ajuste a la ecuación "42-x + 3 = 1". Eso pasa a ser ",".

ArchDelacy
fuente
Gran explicación, editaré mi publicación tan pronto como esté en una PC :)
Felix Palmen
2

JavaScript: ThePirateBay

Anulo los métodos valueOf()y toString()de los objetos analizados para que la coerción falle con a TypeError.

{"valueOf": 7, "toString": 7}
Maltysen
fuente
12
Umm, parece que no puedo entender. Por favor elabora o algo? Especialmente la parte dalksdjalkdjaS djalksdjalksdja , me confunde un poco.
Erik the Outgolfer
@EriktheOutgolfer Edité la parte de spam, pero no tengo idea de por qué estaba allí.
NoOneIsHere
@EriktheOutgolfer oh lol. Eso estaba pasando para evitar que mi respuesta se convirtiera automáticamente en un comentario.
Maltysen
1
@Maltysen Bueno, hay un botón de edición allí que puede ser útil la próxima vez;)
Erik the Outgolfer
2

Conjunto 6502 (C64) - Felix Palmen

La respuesta correcta es 52768,23

La explicación está un poco involucrada.

00 c0                          ;load address
20 fd ae      jsr $aefd        ; checks for comma
20 eb b7      jsr $b7eb        ; reads arguments

El código primero busca una coma (necesidad de sintaxis) y luego lee dos argumentos, el primero de los cuales es una PALABRA, almacenado little-endian en la ubicación de memoria 0014 y 0015, el último de los cuales se almacena en el registro X.

8a              TXA            ;Store second argument into A (default register)
0a              ASL            ; bitshifts the second argument left (doubles it)
45 14           EOR $14        ; XOR that with the low byte of first argument
8d 21 c0        STA $c021      ; Drop that later in the program

Eso es bastante inteligente, usando nuestra entrada para reescribir el programa. Eventualmente reescribe el contador para el bucle de salida al final del programa.

45 15           EOR $15        ; XOR that with the high byte of the first argument
85 15           STA $15        ; Put the result in $15
49 e5           EOR #$e5       ; XOR that with the number $e5
85 14           STA $14        ; Put that in $14

Aquí viene la parte tortuosa:

8e 18 d0        STX $d018      ; stores the original second argument in d018

en el C64, d018 es un byte muy importante. Almacena los puntos de referencia para cosas que involucran la salida de la pantalla. Ver aquí para más información. Si esto obtiene un valor incorrecto, bloqueará su C64. Para imprimir las letras mayúsculas y minúsculas mixtas requeridas, esto debe ser $ 17.

Ahora comenzamos nuestro ciclo de salida:

a0 00               ldy #$00       ; zeroes out the Y register
b1 14               lda ($14),y    ; puts the memory referenced by the byte
                                   ;   starting at $14 (remember that byte?)
                                   ;   into the default register
20 d2 ff            jsr $ffd2      ; calls the kernal routine to print the char stored in A
c8                  iny            ; increment Y
c0 0e               cpy #$0e       ; test for equality with the constant $0e

Esa constante es lo que se escribió antes. Determina claramente cuánto dura el ciclo. Resulta que ya es el valor correcto, pero necesitamos mantener 0e allí nuevamente.

d0 f6                   bne *-8        ; jump back 8 bytes if y and that constant weren't equal
60                      rts            ; ends the program

El resto es solo la información que necesitamos imprimir, comenzando en la dirección de memoria c025.

Entonces solo sigue las matemáticas desde allí.

Un hombre de oro
fuente
Absolutamente correcto, felicidades. Puede que me lleve un tiempo editar correctamente mi publicación, ahora estoy en el móvil.
Felix Palmen
El d018 fue muy inteligente, y me gusta cómo publicaste una pista en secreto.
Un hombre de oro el
d018 fue el abridor de puerta previsto ... la pista fue accidental, quise decir $FFallí, pero luego decidí dejarlo.
Felix Palmen
2

6502 Código máquina (C64) - Felix Palmen

La respuesta correcta es

8bitsareenough

El código es bastante complicado e implica una gran cantidad de auto modificación. Entonces, en lugar de aplicarle ingeniería inversa, puedes usarlo para descifrarlo.

Aquí hay un desmontaje un poco más útil del código, para ayudar a comprender lo que sucedió. La sintaxis es para KickAssembler.

*=$c000       // LOAD ADDRESS
jsr $aefd     //checks for a comma
jsr $ad9e     /*Reads in an argument. Stores length of it into
                $61, with the address of the stored arg in $62-3*/
jsr $b6a3     /*Evaluates the string, leaving the pointer on $22-3
                and the length on A*/ //I think

ldy #$00
loop: lda thedata,y   
cpy #$01
beq shuffle
cpy #$07
beq shuffle
cpy #$0b
beq shuffle
tricks: jsr output
iny
bne loop
output: eor ($22),y      //XOR's A with the y-eth letter of our input
jmp $ffd2               //good old CHROUT, returns to tricks above
thedata: .byte $f0,$48,$fa,$a2, $1c,$6d,$72,$30
.byte $06,$a9,$03,$48,$7c,$a3
shuffle: sta $c048      //drops A in mystery+4, over the constant
lda $c026,y
sta $c045               //overwrites the low byte of mystery
lda $c027,y
sta $c046               //overwrites the high byte of mystery
ldx #$00
mystery: lda $aefd,x              
eor #$23
jsr output
iny
inx
cpx #$03
bne mystery
cpy #$0e
bne loop
eor #$1a
sta $d018                
rts

Etiquetarlo de esta manera fue suficiente para mí para ver que el código XOR contiene un montón de constantes que se ocultan para imprimir lo que necesitamos. Como XOR es reversible, si ingresa la salida deseada, le dirá cuál es la clave.

Entonces cambié la última línea

/*from sta $d018 
to*/ jsr $ffd2

por lo que imprimiría la última entrada requerida en lugar de bloquearse en una entrada incorrecta.

¡Y eso es eso!

Si hay algún interés, descifraré el código más.

Un hombre de oro
fuente
Wow, este es, de hecho, un gran atajo, probablemente debí haber forzado un bloqueo en una entrada incorrecta antes en el procesamiento. Hubo otro atajo posible por cierto, utilizando el depurador de vice. Pero lo que sea, es la solución correcta.
Felix Palmen
No sabía que el vicio tiene un depurador. Esto es lo que obtengo por aprender un idioma solo para descifrar respuestas.
Un hombre de oro el
Edité mi publicación, con algunas explicaciones. Buen trabajo, simplemente modificar el programa para que no se bloquee, por supuesto, es una forma bastante obvia, no pensé en esto.
Felix Palmen
Nitpick: " drops A in mystery+1, over the constant" <- eso es realmente mystery+4con tu etiqueta. Las compensaciones están en bytes :) y FWIW, la auto-modificación es bastante común incluso en el código 6502 serio , siempre que el código se ejecute desde la RAM.
Felix Palmen
1

Explotar , paso gallina

@_?&4_-j>5&f^~c>&6\|4>7

Rh / qi?, Wcr + du

Pruébalo en línea!

  • Intentar averiguar qué están haciendo realmente todos los "exploradores" lastima demasiado la cabeza, así que simplemente hice ingeniería inversa (literalmente: p - comenzando desde el carácter más a la derecha, compensé cada uno a lo largo [y alrededor] del rango de caracteres imprimible) .
Jonathan Allan
fuente
Buen trabajo :) Agregaré una explicación en un par de horas cuando vuelva a mi PC
Stephen
1

C (tcc) por Joshua

int puts(const char *s)
{
    printf("Hello, World!%s", s);
}

Pruébalo en línea!

Dennis
fuente
Maldito. Tuve esta grieta exacta pero no pude hacer que funcionara en TIO. +1
MD XF
Lo siento por eso. Fwiw ya está arreglado.
Dennis
¿Sabes cuál era el problema?
MD XF
Sé cómo lo arreglé (tcc tuvo que construirse con el soporte de SELinux), pero no estoy seguro de qué hace o por qué fue necesario en primer lugar.
Dennis
1

Jelly de Jonathan Allan

Código original:

œ?“¥ĊɲṢŻ;^»œ?@€⁸ḊFmṪ⁷

Pruébalo en línea!

Entrada:

1.2586391,2949273,3312154,3312154,1134001,362881,2223505,766081,1134001,1497601,3312154,1860601,140

Explicación:

Principalmente, es necesario entender lo que hace el código. Lo primero que hace es tomar la cuerda"!,Word Hel"(con todos los caracteres necesarios excepto la nueva línea) y crea un montón de permutaciones de ellos. Las entradas especifican números de permutación, y cada par de permutaciones de la entrada se aplica a la cadena, excluyendo los pares donde se aplica primero la primera permutación. Básicamente, P2 (P1 (S)), P2 (P2 (S), P2 (P3 (S)), ..., P2 (PN (S)), P3 (P1 (S)), ..., P3 (PN (S)), ... ..., PN (P1 (S)), ..., PN (PN (S)). Todos se concatenan juntos. Luego, la última entrada se reutiliza para tomar cada PNth carácter de esta gran cadena. Entonces, tomo PN = len (S) * N = 10 * N. Esto significa que tomaremos el primer carácter de P2 (P1 (S)), el primer carácter de P3 (P1 (S )), todo el camino hasta el primer carácter de PN (P1 (S)). Para simplificar aún más, dejo que P1 = 1, que es la permutación de identidad. Entonces es suficiente elegir cualquier P2 que permuta "H" en el primer posición, un P3 que permuta "e" en la primera posición y así sucesivamente. Afortunadamente, los números de permutación pequeños como el que ya se eligió para PN no afectan a los caracteres anteriores de la cadena, por lo que PN deja "!" Al principio de la cuerda. (Si esto no fuera cierto, aún sería posible resolverlo eligiendo un P1 diferente).

tehtmi
fuente
Se necesitan 14 permutaciones de la lista de las 14 permutaciones, se aplana, se quita y luego se toma cada 140 caracteres.
Jonathan Allan
1

C (GCC en TIO) por MD XF

4195875

Pruébalo en línea!

¿Cómo?

Intenta imprimir el segundo argumento como una cadena, que es un puntero que podemos determinar en la entrada. Sucede que en la memoria de ubicación 4195875comienza la "Hello, World!\n"cadena.

El número se determinó sumando print("%p", "Hello, World!");antes del printf, convirtiendo el número hexadecimal a decimal y probándolo en el TIO original. Sin embargo, me mostró la printfcadena de formato. Al probar algunos números, descubrí que la cadena se encuentra antes de la cadena de formato.

Entonces, en la memoria, se vería así (como una cadena C):

Hello, World!\n\0%2$s\0

Esto también significa que cualquier actualización del compilador podría romper la solución.

Neui
fuente
1

JavaScript (ES6), Voile

Dado el límite de 81 caracteres, esta probablemente no sea la solución prevista

global.g = ()=>"Hello, World!";
var str = "g";

Pruébalo en línea!

Birjolaxew
fuente
Genioso pasando una cadena de caracteres con manipulación global. Parece que es la solución prevista
Евгений Новиков
Esa no es la solución prevista :(
Voile
Ahora que lo estoy pensando, no creo que esté permitido hacer toneladas de cosas como esta antes de pasar la entrada en una función, a menos que dichas cosas también se puedan componer como parte de la entrada (por ejemplo, dentro de la función que será evaluado en el interior), ya que el desafío requiere que hagas una entrada que dará como resultado '¡Hola, Mundo!', no un programa completo. De lo contrario, casi nada puede ser seguro. Entonces, ¿creo que esta grieta podría no ser válida?
Voile el
@Voile Muy bien puede ser. Creo que es justo leer la tarea como si la entrada debe ser independiente (es decir, sin cambios en el sistema externo), especialmente si esta no es la solución prevista :) No es necesario marcar a su policía como agrietado.
Birjolaxew
1
Hice una meta publicación discutiendo sobre esto. Siéntase libre de dejar algunas discusiones allí.
Voile el