Klein é uma linguagem 2D que eu projetei que pode ser incorporada em 12 superfícies topológicas diferentes. Um programa Klein pode ser executado em superfícies diferentes alterando os argumentos da linha de comandos.

A topologia determina para onde o ponteiro de instrução vai quando sai da borda do programa. Ao sair da borda, o ip pulará para uma borda com a cor correspondente e manterá sua posição em relação à seta, ou seja, o ponteiro conservará sua distância da ponta da seta.

Por exemplo 000, topologia , a topologia usada pela maioria das linguagens 2D, faz com que o ponteiro de instruções seja contornado para o outro lado quando se move para fora de uma aresta.

Tarefa

A tarefa é bem simples, escreva um programa Klein que, quando executado, produzirá a topologia em que é executado. Os números individuais podem ser separados por espaços. (por exemplo, 000e 0 0 0são ambos saída permitida). Você pode optar por usar ou ignorar o -Asinalizador da linha de comando, que não custará bytes se você o usar.

Isso é código-golfe, então a resposta mais curta será a vencedora.

Aqui está um driver de teste online que pode ser usado para testar todas as topologias de uma só vez. Para executar no modo inteiro, remova o -A.

52 48 bytes

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

Experimente online!

Test Driver

Explicação

Em Klein, o IP começa no canto superior esquerdo, indo para a direita. O primeiro passo que eu queria que meu programa fizesse foi enviar o IP da parte superior do programa para determinar o primeiro e o terceiro bits. O IP entraria novamente no programa da seguinte forma, dependendo da topologia:

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

Decidi que o meu programa gravaria o terceiro bit da topologia antes do segundo, mas os trocaria (usando $) antes do final. Para esse fim, adicionei código para enviar o primeiro e o terceiro bits de cada topologia nos pontos de entrada do IP descritos acima.

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

Em seguida, concentrei-me nas topologias com 1ou 2como seu primeiro bit. Decidi recombiná-los e enviá-los para o lado não conectado ao lado norte, para que eu pudesse determinar o 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, isso reagrupou as topologias pelo segundo bit para que eu pudesse colocar isso na pilha.

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

Depois disso, eu só precisava trocar o segundo e o terceiro bits e terminar o programa.

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

Agora que as topologias com 1ou 2como o primeiro bit funcionaram, eu poderia me concentrar em fazer as topologias com 0a saída correta. O primeiro passo foi recombiná-los para que pudessem ser separados em dois grupos com base no segundo bit.

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

Primeiro, foquei nessas topologias com 1o segundo bit. Isso representou um desafio, porque para eles o IP estava em uma linha já usada pelas topologias com 2o seu primeiro bit. Como seria complicado ajustar mais de uma instrução nessa linha (uma única instrução pode ser pulada usando a !instrução) e eu estava com pouco espaço como um todo, decidi redirecionar o IP dessa linha e reutilizar uma 1instrução existente para empurrar o segundo bit.

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

Agora, tudo o que restava a ser feito para as topologias com 1o segundo bit era fixar a ordem do segundo e terceiro bits e terminar.

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

Por fim, permaneceram as topologias com 0o segundo bit. Não havia muito espaço no programa, com o maior espaço não utilizado na linha superior; portanto, foi lá que eu redirecionei o IP para as topologias com 0o segundo bit.

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

Eu ainda precisava pressionar 0o segundo bit e corrigir a ordem do segundo e terceiro bits, além de encerrar o programa. Felizmente, pude reutilizar uma $instrução existente para que as instruções 0e @pudessem se encaixar nos espaços restantes.

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

Finalmente, os nops podem ser retirados do final das linhas para obter o 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@

Experimente online!

44 41 40 38 37 bytes

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

Experimente online!

Driver de teste.

Usa um quadrado de 6 por 6. O menor que eu consegui com um quadrado de 8 por 8 é de 38 bytes, se alguém quiser tentar melhorá-lo.

Explicação:

Uma na primeira passagem do código codifica os dois primeiros números para os prefixos 0e 1. Pois 2, ele codifica o terceiro número e depois o primeiro.

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

Em seguida, passamos os IPs pela terceira extremidade para decidir o número final. Combinamos os IPs com o mesmo prefixo.

     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 os prefixos 0e 1, ambos saem pela borda superior para decidir o terceiro 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 o 2prefixo, os IPs saem pelos cantos da borda 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

Ambas as arestas trocam o primeiro e o terceiro número, empurram o segundo número e o trocam com o terceiro para obter a ordem correta.