Klein es un lenguaje 2D que he diseñado que puede integrarse en 12 superficies topológicas diferentes. Un programa de Klein se puede ejecutar en diferentes superficies cambiando los argumentos de la línea de comandos.

La topología determina a dónde va el puntero de instrucción cuando se sale del borde del programa. Al alejarse del borde, la ip saltará a un borde con el color correspondiente y mantendrá su posición con respecto a la flecha, es decir, el puntero conservará su distancia de la punta de la flecha.

Por ejemplo 000, la topología , la topología utilizada por la mayoría de los lenguajes 2D, hace que el puntero de instrucción se ajuste al otro lado cuando se mueve fuera de un borde.

Tarea

La tarea es bastante simple, escriba un programa Klein que, cuando se ejecute, genere la topología en la que se ejecuta. Los números individuales pueden estar separados por espacios. (p. ej., 000y 0 0 0ambos son salida permitida). Puede optar por usar o ignorar el -Aindicador de línea de comando, ya que no le costará bytes si lo usa.

Este es el código de golf, por lo que la respuesta más corta será el ganador.

Aquí hay un controlador de prueba en línea que se puede usar para probar todas las topologías a la vez. Para ejecutar en modo entero, elimine el -A.

52 48 bytes

./@$0<$
21\./01
..>..!\
@
.<..<\
20//\11
@01$00@

Pruébalo en línea!

Conductor de prueba

Explicación

En Klein, la IP comienza en la esquina superior izquierda hacia la derecha. El primer paso que quería que hiciera mi programa era enviar la IP desde la parte superior del programa para determinar el primer y el tercer bit. La IP volvería a ingresar al programa de la siguiente manera, según la topología:

             ^
            I|P
            ./.....
201, 211 -->.......<-- 100, 110
            .......
            .......
            .......
200, 210 -->.......<-- 101, 111
            .......
             ^   ^
             |   |
            000 001
            010 011

Decidí que mi programa registraría el tercer bit de la topología antes del segundo bit, pero los cambiaría (usando $) antes del final. Con ese fin, agregué código para empujar el primer y el tercer bit de cada topología en los puntos de entrada de IP descritos anteriormente.

./.....
21...01
.......
.......
.......
20...11
.0...0.

Luego me concentré en las topologías con 1o 2como su primer bit. Decidí recombinarlos y enviarlos al lado no conectado al lado norte para poder determinar su segundo bit.

                      ./.....
                      21\./01
                      ..>....--> 200, 201, 210, 211
                      .......
100, 101, 110, 111 <--....<..
                      20/.\11
                      .0...0.
                        ^ ^
                        | |
                        / \
                      110 100
                      111 101
                      210 200
                      211 201

Convenientemente, esto reagrupó las topologías en su segundo bit para poder empujar eso a la pila.

./.....
21\./01
..>....
.......
....<..
20/.\11
.01.00.

Después de eso, solo necesitaba intercambiar el segundo y tercer bit y hacer que el programa terminara.

./.$...
21\./01
..>....
@......
....<..
20//\11
.01$00.

Ahora que las topologías con 1o 2como su primer bit funcionaron, podría concentrarme en hacer que las topologías 0den el resultado correcto. El primer paso fue recombinarlos para que pudieran separarse en dos grupos en función de su segundo bit.

                      ./.$...
                      21\./01
                      ..>....<-- 010, 011
                      @......
000, 001, 010, 011 <--.<..<<.<-- 000, 001
                      20//\11
                      .01$00.

Primero me enfoqué en esas topologías con 1su segundo bit. Estos presentaron un desafío porque para ellos la IP estaba en una línea ya utilizada por las topologías 2como primer bit. Como sería difícil ajustar más de una instrucción en esa línea (se puede saltar una sola instrucción usando la !instrucción) y me estaba quedando sin espacio en general, decidí redirigir la IP fuera de esa línea y reutilizar una 1instrucción existente para empujar el segundo bit.

./.$...
21\./01
..>..!\
@......
.<..<<.
20//\11
.01$00.

Ahora todo lo que quedaba por hacer para las topologías con 1su segundo bit era arreglar el orden del segundo y tercer bit y terminar.

       ^
       |
 ./.$..$
 21\./01
 ..>..!\
 @......
 .<..<<.
 20//\11
 @01$00@
 ^     ^
 |     |
011   010

Finalmente quedaron las topologías con 0su segundo bit. No quedaba mucho espacio en el programa con el mayor espacio no utilizado en la línea superior, por lo que fue allí donde redirigí la IP para las topologías con 0su segundo bit.

./.$.<$
21\./01
..>..!\
@......
.<..<\.
20//\11
@01$00@

Todavía necesitaba presionar 0por el segundo bit y arreglar el orden del segundo y tercer bit, así como terminar el programa. Afortunadamente, pude reutilizar una $instrucción existente para que las instrucciones 0y @pudieran caber en los espacios restantes.

./@$0<$
21\./01
..>..!\
@......
.<..<\.
20//\11
@01$00@

Finalmente, los nops se pueden quitar de los extremos de las líneas para obtener el programa final.

116 88 86 77 69 61 60 59 58 54 53 50 bytes

\2..@2
/1\<$00
/>!..>!
0//
@0$10@1
011\.<0
\.<@>1@

Pruébalo en línea!

44 41 40 38 37 bytes

\\1.>2
/0./
@./$(\
$>0!>
11$/10
$.@.1

Pruébalo en línea!

Conductor de prueba.

Utiliza un cuadrado de 6 por 6. Lo más corto que podría obtener con un cuadrado de 8 por 8 son 38 bytes si alguien quiere intentar mejorarlo.

Explicación:

Uno el primer paso del código codifica los dos primeros números para los prefijos 0y 1. Para 2, codifica el tercer número y luego el primero.

     201  200
     211  210
       |  |
       v  v
   -> \\1.>2
 IP<- /../..  <- 000, 001
      ...$..
      .>0...
      .1..10  <- 010, 011
      ....1.
       ^  ^
       |  |
     100  110
     101  111

Luego pasamos las IP a través del tercer borde para decidir el número final. Combinamos las IP con el mismo prefijo.

     201  200
     211  210
       |  |
       v  v
   -> \\1.>2  -> 0,2 or 1,2
 IP<- /../..  <- 000, 001
      ...$..
      .>0!>.  -> 1
      .1./10  <- 010, 011
      ....1.
       ^ |^
       | v|
       | 0|
     100  110
     101  111

Para los prefijos 0y 1, ambos salen del borde superior para decidir el tercer número.

     201  200
     211  210
       |  |
       |10|
       vvvv
   -> \\1.>2  -> 2
 IP<- /0./..  <- 000, 001
      @./$..
      .>0!>.  -> 1
      .1./10  <- 010, 011
      ....1.
       ^ |^
       | v|
       | 0|
     100  110
     101  111

Para el 2prefijo, las IP salen de las esquinas desde el borde inferior.

     201  200
     211  210
       |  |
       |10|
       vvvv
   -> \\1.>2  -> 2
 IP<- /0./..  <- 000, 001
      @./$(\
      $>0!>.  -> 1
      11$/10  <- 010, 011
      $.@.1.
      ^^ |^^
      || v||
      1| 0|0
     100  110
     101  111

Ambos bordes intercambian el primer y tercer número, empujan el segundo número y lo intercambian con el tercero para obtener el orden correcto.