2.}<@>%?<{>$"/\M!8;
Legible:
2 . }
< @ > %
? < { > $
" / \ M
! 8 ;
Pruébalo en línea!
Esto probablemente se puede jugar por un byte o dos, pero eso puede requerir un diseño realmente ingenioso, que se puede encontrar más fácilmente a través de la fuerza bruta (incluso si puede tomar bastante tiempo encontrarlo).
Explicación de alto nivel
El programa sigue principalmente este pseudocódigo:
while (read number is not zero)
{
if (number is even)
print number;
}
Lo cual abusa de cómo Hexagony intenta leer un número una vez que STDIN está vacío (devuelve un cero). Muchas gracias a Martin por su ayuda con este enfoque.
Explicación completa
Todavía no he jugado con Mono para obtener el fantástico IDE esotérico de Timwi , ¡así que me he apoyado en Martin para que me proporcione algunas bonitas imágenes útiles!
Primero, un pequeño manual sobre el flujo de control básico en Hexagony. El primer puntero de instrucciones (IP), que es el único utilizado en este programa, comienza en la parte superior izquierda del código fuente hexagonal y comienza a moverse hacia la derecha. Cada vez que la IP abandona el borde del hexágono, mueve side_length - 1filas hacia el centro del hexágono. Como este programa utiliza un hexágono de longitud lateral de tres, la IP siempre se moverá dos filas cuando esto suceda. La única excepción es si se mueve fuera de la fila central, donde se mueve condicionalmente hacia la parte superior o inferior del hexágono, dependiendo del valor del borde de memoria actual.
Ahora un poco sobre condicionales. Los únicos condicionales en Hexagony para el flujo de control son >, <y el borde medio del hexágono. Todos estos siguen una regla constante: si el valor en el borde de la memoria actual es cero o el flujo de control negativo se mueve hacia la izquierda y si es positivo, el control fluye hacia la derecha. Los corchetes mayores y menores que redirigen la IP en ángulos de sesenta grados, mientras que el borde del hexágono controla a qué fila salta la IP.
Hexagony también tiene un modelo de memoria especial, donde todos los datos se almacenan en los bordes de una cuadrícula hexagonal infinita. Este programa solo usa tres aristas: una para almacenar un dos, una para el número actualmente leído y otra para el módulo número dos. Se ve algo así como:
Mod \ / Input
|
2
No voy a explicar cuidadosamente dónde estamos en la memoria en cada punto durante la explicación del programa, así que vuelve aquí si te confundes por dónde estamos en la memoria.
Con todo eso fuera del camino, la explicación real puede comenzar. Primero, llenamos el borde "2" en la memoria con un 2, luego ejecutamos un no-op y movemos el puntero de memoria hacia la derecha ( 2.}).
A continuación, comenzamos el ciclo principal del programa. Leemos el primer número de STDIN y luego tocamos un condicional ( ?<). Si no quedan números en STDIN, esto lee un cero en el borde de la memoria actual, así que giramos a la izquierda en el @, que finaliza el programa. De lo contrario, rebotamos en un espejo, movemos el puntero de memoria hacia atrás y hacia la izquierda, envolvemos el hexágono para calcular el resto de dividir la entrada por 2 y luego presionamos otro condicional ( /"%>).
Si el resto era uno (es decir, el número era impar), giramos a la derecha siguiendo el camino azul de arriba, comenzando ejecutando el no-op nuevamente, luego envolvemos la parte inferior del hexágono, multiplicamos el borde actual por 10 y luego suma ocho, rebota en un par de espejos, haz la misma multiplicación y suma nuevamente, obteniendo 188 en el borde actual, volviendo a la parte superior del hexágono, ejecutando el no-op nuevamente y finalmente terminando el programa ( .8/\8.@). Este resultado complicado fue un feliz accidente, originalmente había escrito una lógica mucho más simple, pero noté que podía eliminarlo a favor del no-op, que pensé que estaba más en el espíritu de Hexagony.
Si el resto era cero, giramos a la izquierda siguiendo el camino rojo, arriba. Esto hace que muevamos el puntero de memoria hacia la izquierda y luego imprimamos el valor allí (el valor de entrada) como un número. El espejo con el que nos encontramos actúa como no operativo debido a la dirección en la que nos estamos moviendo ( ). Como 77 es positivo, nos movemos hacia la parte inferior del hexágono y, debido al trampolín, omitimos la primera instrucción ( ). Luego multiplicamos el borde de la memoria actual por 10 y sumamos 8, obteniendo 778. Luego sacamos este valor mod 256 (10) como un carácter ASCII, que resulta ser una nueva línea. Finalmente, salimos del hexágono y volvemos al primero que anula el 778 con el siguiente valor de entrada.{/! ). Luego tocamos el borde del hexágono, que actúa de manera condicional con un solo resultado, ya que el valor de entrada de antes ya se probó como positivo, por lo que siempre nos movemos hacia la derecha (si te imaginas mirando en la dirección de la IP) . Luego multiplicamos la entrada por 10 y agregamos dos, solo para cambiar la dirección, envolver y sobrescribir el nuevo valor con el valor ascii de la letra mayúscula M, 77. Luego golpeamos algunos espejos y salimos por el borde del medio de el hexágono con un trampolín (2<M\>$!?
el intérprete sigue las flechas y omite una instrucción al cruzar '#'