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 eval
también es alfanumérico. Entonces, en cambio, esto canaliza esa cadena como entrada a otra instancia de bash
. $0
contiene el nombre del comando utilizado para invocar Bash, que generalmente es solo bash
(o -bash
para 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 $0
directamente. 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.
05AB1E , Adnan
Pruébalo en línea!
¿Cómo?
fuente
totalmente humano , Python 2
Una solución es
fuente
Pyth : Sr. Xcoder
G
es el incorporado para el alfabeto en minúsculas. El código verifica la igualdad contra eso.fuente
Jalea: EriktheOutgolfer
Jalea , 11 bytes
Pruébalo en línea!
Explicación
El código original se puede explicar como tal:
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.
fuente
Octave por Stewie Griffin
No estoy seguro de si esta es la solución correcta (en TIO imprime el
\00
personaje), pero en mioctave-cli
shell se ve así: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,
\00
entonces debería estar bien.Pruébalo en línea!
fuente
0
con a10
).Hello, World!
y una nueva línea". Es una cita exacta del desafío. Y de hecho, eso hace que la respuesta sea trivial.Python 3 por rexroni
Prevenga cualquier error saliendo temprano.
Pruébalo en línea!
fuente
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á dentroString.fromCharCode
solo 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 ...).fuente
JavaScript (ES6), Voile
Proxy simple que solo devuelve el carácter deseado cada 3 veces que se llama.
Pruébalo en línea!
fuente
Ruby, por Histocrat
La entrada mágica es:
1767707618171221 30191World!
Pruébalo en línea.
Explicación:
1767707618171221
es primo y, escrito en base 36, lo es"hello"
. Cuando se escribe con mayúscula, esto produce"Hello"
, que se imprime usando$><<
$><<", #$'"if/30191/
busca el número30191
en la entrada y escribe en stdout una cadena compuesta por una coma, un espacio y cualquier cosa que esté en la entrada después de30191
(usando el$POSTMATCH
, que se refiere aquí por su variante corta$'
).fuente
Lua 5.1 por tehtmi
Pase esto como el primer argumento:
Suponiendo que el código original está en un archivo
tehtmi.lua
, ejecute (en bash o un shell similar):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
("").char
para obtener la funciónstring.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 tantoprint
lasHello, World!
cadenas como las que se pueden usar como se indica arriba.fuente
next
lugar dechar
lo que no funciona en Lua 5.3 debido a la aleatorización del orden de iteración.JavaScript (ES6) por Voile
La entrada debe ser una cadena que contenga esto:
Pruébalo usando esto:
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:
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):Esto fue realmente difícil de descifrar, pero al final tuve éxito.
Además, ¡el primer crack!
fuente
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
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:
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:luego imprime
\n0
pares 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
7
a a0
resulta en el comportamiento esperado. El intérprete de TIO exhibe el mismo comportamiento incorrecto.fuente
CJam , Erik el Outgolfer
Pruébalo en línea!
¿Cómo?
fuente
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:
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 enHello, World!
.fuente
Ly , LyricLy
Pruébelo aquí (aunque la página no muestra la nueva línea).
n
toma entrada, intenta dividirse en espacios y lanzar a ints, estos se ponen en la pila.o
imprime puntos ordinales y8+
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.fuente
2
que funcionaría, ¿es solo la página de herokuapp que no lo muestra?C (gcc), por Felix Palmen
Código original:
Argumentos:
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 sumax
, 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 ",".fuente
JavaScript: ThePirateBay
Anulo los métodos
valueOf()
ytoString()
de los objetos analizados para que la coerción falle con aTypeError
.fuente
Conjunto 6502 (C64) - Felix Palmen
La explicación está un poco involucrada.
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.
Eso es bastante inteligente, usando nuestra entrada para reescribir el programa. Eventualmente reescribe el contador para el bucle de salida al final del programa.
Aquí viene la parte tortuosa:
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:
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.
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í.
fuente
$FF
allí, pero luego decidí dejarlo.6502 Código máquina (C64) - Felix Palmen
La respuesta correcta es
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.
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
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.
fuente
vice
. Pero lo que sea, es la solución correcta.drops A in mystery+1, over the constant
" <- eso es realmentemystery+4
con 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.Explotar , paso gallina
Pruébalo en línea!
fuente
C (tcc) por Joshua
Pruébalo en línea!
fuente
MATL por Luis Mendo
Pruébalo en línea!
fuente
Jelly de Jonathan Allan
Código original:
Pruébalo en línea!
Entrada:
Explicación:
fuente
C (GCC en TIO) por MD XF
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
4195875
comienza la"Hello, World!\n"
cadena.El número se determinó sumando
print("%p", "Hello, World!");
antes delprintf
, convirtiendo el número hexadecimal a decimal y probándolo en el TIO original. Sin embargo, me mostró laprintf
cadena 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):
Esto también significa que cualquier actualización del compilador podría romper la solución.
fuente
JavaScript (Node.js) Por Voile
['Hello, World!','','','','','','','','','','','','']
Pruébalo en línea!
fuente
Röda por fergusq
Pruébalo en línea!
La explicación viene un poco ...
fuente
JavaScript (ES6), Voile
Pruébalo en línea!
fuente
PHP por LP154
Pruébalo en línea!
(TIO no tiene la clase PDO definida, por lo que la demostración anterior usa un teclado que sí)
Otra solución:
Pruébalo en línea!
fuente
JavaScript (ES6), Voile
Dado el límite de 81 caracteres, esta probablemente no sea la solución prevista
Pruébalo en línea!
fuente