🧩 Veintinueve bytes para decir hola: haciendo code golf con «Hello, World!» en SuperHack 🔗

Un análisis del reto «Super Small Hello World» de hacker.org: las soluciones que funcionaron, las que casi lo logran y el truco que finalmente alcanzó los 29 bytes.

📑 Tabla de Contenidos 🔗

🎯 El reto 🔗

hacker.org tiene un pequeño lenguaje esotérico llamado SuperHack. La tarea parece trivial: escribir un programa en SuperHack que imprima Hello, World!.

El truco está en la puntuación. Se te puntúa según el área del rectángulo delimitador de tu código, y cuanto más pequeño, mejor. Además, el programa tiene que terminar correctamente: ejecutando la instrucción ! (halt). Que falle con una excepción de la máquina virtual una vez impreso el texto no vale, y tampoco vale imprimir bytes sobrantes.

El número a batir era 29.

🧭 Un recorrido de dos minutos por SuperHack 🔗

SuperHack es una máquina de pila bidimensional, similar en espíritu a Befunge:

• El código es una cuadrícula de instrucciones de un solo carácter. El contador de programa (PC) comienza en la esquina superior izquierda (o en un %) y se mueve hacia la derecha.
• Hay una pila de datos de números enteros, más una pila de llamadas (call stack) independiente que almacena posiciones.
• Instrucciones utilizadas en este artículo:

Dos consecuencias condicionan todo lo que sigue:

1. Los caracteres son datos. g lee el propio código del programa, de modo que la cadena Hello, World! puede simplemente residir en la cuadrícula y leerse carácter a carácter. La mayoría de sus letras (H e l o W r) son no-ops cuando se ejecutan. Tres no lo son: , apila 0, d divide y ! detiene la ejecución.
2. @ / $ crean bucles, y el número de iteraciones depende de dónde estén los @. $ reanuda la ejecución dos celdas después del @ al que regresa. Eso aterriza sobre el siguiente @, que vuelve a apilarse a sí mismo, por lo que unos pocos @ pueden repetir el cuerpo del bucle muchas veces:
   • Los @@@@@ adyacentes producen recuentos de Fibonacci. Cinco de ellos ejecutan el cuerpo exactamente 13 veces.
   • Los @ separados de dos en dos producen potencias de dos. Cuatro de ellos permiten 16 pasadas.

Trece caracteres, trece pasadas. Quédate con ese dato.

El área es el ancho multiplicado por el alto, y 29 es primo. Por tanto, un programa de 29 celdas tiene que ser una sola fila o una sola columna.

1️⃣ Solución 1: el bucle directo (área 32) 🔗

Hello, World!%0@s!@@@@@ 01^gP1+$

La primera solución real coloca la carga útil (payload) al principio e inicia la ejecución después de ella:

El artilugio de parada. El primer @ coloca su propia posición en el fondo de la pila de llamadas, y s salta por encima del !. A continuación, la cadena de Fibonacci realiza sus 13 pasadas. Cuando la pila de llamadas finalmente se desenrolla hasta ese primer @, $ reanuda la ejecución dos celdas después, que es exactamente donde está el !. El programa se detiene limpiamente y no hay ninguna comprobación de final de cadena en ninguna parte.

El relleno. Con @ adyacentes, al regresar del último @ la ejecución se reanuda dos celdas más adelante, lo que salta la primera celda posterior a la cadena. Por tanto, esa celda debe ser algo inofensivo, así que es un espacio.

Resultado: Hello, World!, parada limpia, área 32. Es correcto pero holgado: el texto es peso muerto, y el %, el espacio de relleno y el 0 cuestan en conjunto tres celdas.

2️⃣ Solución 2: intercalado (área 28, pero no válida) 🔗

1H@e@l@l@o ,1 ^WgoPr2lsds!+$

La siguiente idea consiste en dejar de gastar celdas en un bloque de datos separado y entrelazar la cadena con el código. Los caracteres de Hello, World! ocupan las columnas impares (1, 3, …, 25), y el código rellena las columnas pares intermedias:

• 1 inicia el índice en la columna 1 (la H).
• Cuatro @ separados de dos en dos (columnas 2, 4, 6, 8) permiten hasta 16 pasadas.
• La propia , del texto (columna 11) apila el 0 que g necesita como fila.
• 2+ avanza el índice hasta la siguiente columna impar.
• Las celdas s saltan por encima de la d y el ! del texto, para que no se ejecuten como código.

El problema es que 16 pasadas son más que 13. Después de imprimir la cadena, el bucle sigue leyendo más allá del final e imprime $ y dos bytes NUL. Entonces $ encuentra vacía la pila de llamadas y la máquina virtual muere:

output:  "Hello, World!$\0\0"
message: call stack underflow

Es pequeño, pero no es una solución válida. Sin embargo, introduce la idea clave: los caracteres de datos que resultan ser instrucciones útiles (,) cumplen una doble función como datos y como código.

3️⃣ Solución 3: en vertical (área 27, pero no válida) 🔗

\
2
H
@
e
@
l
@
l
@
o
x
,
g

P
W
2
o
+
r
$
l

d

!

(Un carácter por línea. Las líneas en blanco son espacios individuales, que forman parte de los datos).

Poner el programa en vertical tiene una ventaja inesperada. En una sola columna, g necesita que la coordenada x sea 0 y que la fila sea i. La , de los datos proporciona ese 0 gratis, por lo que la lectura se reduce a x , g: duplicar i, apilar 0 y obtener el carácter. El coste es un único \ en la parte superior para dirigir el PC hacia abajo.

No obstante, tiene el mismo defecto que la solución 2. El bucle se pasa de largo, imprime bytes NUL y termina con call stack underflow. Con un área de 27, es el programa más pequeño de este artículo, pero no cuenta.

La lección de las soluciones 2 y 3 es que detenerse limpiamente cuesta celdas. El intercalado abarata el bucle, pero te da 16 pasadas cuando necesitas exactamente 13.

4️⃣ Solución 4: pagar por la salida (área 30) 🔗

\
2
H
@
e
@
l
@
l
@
o
x
,
g
 
P
W
x
o
5
r
d
l
5
d
?
!
2
+
$

La solución 4 conserva el intercalado vertical de la solución 3 y añade una comprobación de fin de cadena en toda regla:

El índice recorre 2, 4, …, 26. floor(i/25) se mantiene en 0 hasta el último carácter (i = 26), por lo que ? salta la parada en todas las pasadas salvo en la última. En la última pasada, la ejecución cae sobre el ! de los datos, que es simultáneamente el último carácter impreso y la instrucción que detiene el programa.

Es una reutilización magnífica: la ,, la d y el ! del texto sirven todos como código. Pero la comprobación cuesta cinco celdas y el total asciende a 30.

🧱 Por qué bajar a 29 parecía imposible 🔗

Llegados a este punto, mi compañero de IA intentó demostrar que 30 era el óptimo. Todos los enfoques parecían chocar contra el mismo muro:

• El intercalado bloquea el bucle barato. Trece pasadas requieren cinco @ adyacentes, y en un intercalado no hay celdas de código adyacentes. Así que estás atado a 16 pasadas y a una comprobación que consume celdas.
• La paridad bloquea salidas más baratas. En un intercalado, ? nunca puede situarse justo delante de $. La celda entre ambos es siempre una celda de datos.
• Un bloque de datos contiguo bloquea el otro diseño. Si pones el texto en un solo bloque, el bucle de Fibonacci vuelve a caber. Pero entonces los datos tienen que vivir en algún lugar que nunca se ejecute (lo que cuesta un % o un índice inicial grande), porque ejecutar ...d! como código provoca un fallo o detiene el programa antes de tiempo.

Las búsquedas exhaustivas por ordenador en áreas más pequeñas no encontraron nada, y las búsquedas alrededor de la disposición de la solución 4 con área 29 tampoco arrojaron resultados. «30 es el límite inferior» empezaba a parecer un teorema.

No lo era.

🏆 Solución 5: veintinueve (área 29) 🔗

9@s!@@@@@Hello, Worlä¡1^gP1+$

El avance llegó al releer el código fuente del juez. Hay dos líneas clave:

case 'P':
  $output .= chr($this->Pop() & 0x7F); break;
...
default:
  break;   // every unknown character is a no-op

• P imprime únicamente los 7 bits inferiores. Un byte con su bit más significativo activado, c + 128, se imprime exactamente igual que c.
• Un byte entre 128 y 255 no es una instrucción, por lo que se ejecuta como un no-op.
• Las cadenas en PHP son secuencias de bytes, así que dicho byte ocupa una celda como cualquier otro.

Por consiguiente, cada carácter de los datos tiene dos codificaciones. La normal puede hacer algo al ejecutarse. La codificación c | 0x80 es garantizadamente inerte. Esa es la «fórmula para los datos»: almacenar los caracteres peligrosos como c + 128, y dejar que P elimine el bit alto gratis.

Solo dos caracteres del texto son peligrosos: d se convierte en ä (0xE4) y ! se convierte en ¡ (0xA1). Con esos dos cambios, toda la cadena de datos puede ejecutarse. Eso elimina el obstáculo del tercer punto anterior.

Ahora tomamos la solución 1 y movemos los datos dentro del bucle:

Recorramos una pasada:

1. El PC aterriza en algún punto de la cadena de @ y atraviesa los datos. H e l l o, el espacio y W o r l no hacen nada. La , de los datos apila el 0 que g necesita como fila. ä y ¡ no hacen nada.
2. 1^ copia i encima de ese 0, y g lee la columna i.
3. P la imprime. Para los dos últimos caracteres imprime 0xE4 & 0x7F = 'd' y 0xA1 & 0x7F = '!'.
4. 1+ incrementa i, y $ regresa a la cadena de @.

En comparación con la solución 1, desaparecen tres celdas:

• %: ya no hace falta proteger los datos de la ejecución.
• El espacio de relleno: la celda que se salta tras la cadena de @ es ahora la H de los datos, un no-op.
• El 0 antes de 1^g: la , de los datos lo proporciona en cada pasada.

32 − 3 = 29. Tras la 13.ª pasada, la pila de llamadas se desenrolla hasta el artilugio inicial y el programa se detiene en el ! de la columna 3.

Salida Hello, World!, sin mensaje de error de la VM, 271 ciclos, área 29.

🌐 El último obstáculo: hacer llegar los bytes al juez 🔗

El primer envío devolvió got: 'Hello, WorlC$' y una puntuación de 31. El formulario web había enviado los datos en UTF-8, convirtiendo cada carácter especial en dos bytes (ä → C3 A4, ¡ → C2 A1). Al aplicar la máscara de 7 bits, 0xC3 se imprime como C y 0xA4 como $.

La solución consiste en hacer que el navegador envíe Latin-1, donde cada uno de esos caracteres ocupa un solo byte. En la página del reto, tuve que abrir la consola de DevTools y ejecutar:

document.querySelectorAll('form').forEach(
  f => f.acceptCharset = 'ISO-8859-1');
document.querySelector('textarea').value =
  "9@s!@@@@@Hello, Worl\u00e4\u00a11^gP1+$";

Y luego pulsar el botón de envío normal. El juez imprime Hello, World!, y la puntuación máxima es 29.

📊 Tabla de resultados 🔗

💡 Conclusiones 🔗

• Los datos también son código. Cada avance ganador provino de permitir que las mismas celdas sirvieran para ambas cosas: la , del texto como un push 0 gratuito, su ! como parada, y finalmente toda la cadena de datos como cuerpo del bucle.
• Una demostración de imposibilidad es tan válida como sus premisas. «30 es el mínimo» era cierto para diseños intercalados con caracteres ASCII imprimibles. Ninguna de las dos restricciones figuraba en las reglas.
• Lee el código fuente real. La búsqueda por fuerza bruta dentro de un espacio de diseño fijo no puede encontrar una respuesta que se encuentre fuera de él. Dos líneas del PHP del juez (& 0x7F y default: break) lograron lo que horas de búsqueda no pudieron hacer.
• Cuida el transporte. Un programa correcto puede fallar igualmente si el formulario web altera sus bytes de camino al juez.