Klein est un langage 2D que j'ai conçu et qui peut être intégré à 12 surfaces topologiques différentes. Un programme de Klein peut être exécuté sur différentes surfaces en modifiant les arguments de la ligne de commande.

La topologie détermine l'emplacement du pointeur d'instruction lorsqu'il quitte le programme. Lorsque vous vous éloignez du bord, l'ip saute sur un bord avec la couleur correspondante et conserve sa position par rapport à la flèche, c'est-à-dire que le pointeur conservera sa distance par rapport à la tête de la flèche.

Par exemple 000, la topologie , la topologie utilisée par la plupart des langages 2D, fait en sorte que le pointeur d'instruction se retourne de l'autre côté lorsqu'il se déplace hors d'un bord.

Tâche

La tâche est assez simple: écrivez un programme Klein qui, une fois exécuté, affichera la topologie dans laquelle il est exécuté. Les nombres individuels peuvent être séparés par des espaces. (par exemple, 000et 0 0 0sont les deux sortie autorisée). Vous pouvez choisir d'utiliser ou d'ignorer l' -Aindicateur de ligne de commande. Il ne vous coûtera pas d'octets si vous l'utilisez.

C'est du code-golf donc la réponse la plus courte sera gagnante.

Voici un pilote de test en ligne qui peut être utilisé pour tester toutes les topologies à la fois. Pour exécuter en mode entier, supprimez le fichier -A.

52 48 octets

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

Essayez-le en ligne!

Pilote d'essai

Explication

À Klein, l’IP commence dans le coin supérieur gauche et va à droite. La première étape que je souhaitais que mon programme fasse est d’envoyer l’adresse IP depuis le début du programme pour déterminer le premier et le troisième bits. L’IP rentrerait dans le programme comme suit en fonction de la topologie:

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

J'ai décidé que mon programme enregistrerait le troisième bit de la topologie avant le second bit mais les échangerait (avec $) avant la fin. À cette fin, j'ai ajouté du code pour pousser les premier et troisième bits de chaque topologie aux points d'entrée de l'IP décrits ci-dessus.

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

Ensuite, je me suis concentré sur les topologies avec 1ou 2comme premier élément. J'ai décidé de les recombiner et de les envoyer du côté non connecté au nord afin de pouvoir déterminer leur deuxième bit.

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

Cela a commodément regroupé les topologies par leur deuxième bit afin que je puisse le transférer vers la pile.

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

Après cela, je devais simplement échanger les deuxième et troisième bits et faire terminer le programme.

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

Maintenant que les topologies avec 1ou 2dans leur premier bit ont fonctionné, je pouvais me concentrer sur la création de topologies avec 0la sortie correcte. La première étape consistait à les recombiner afin de pouvoir les séparer en deux groupes en fonction de leur deuxième bit.

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

Je me suis d'abord concentré sur ces topologies avec 1comme second élément. Celles-ci constituaient un défi, car pour elles, l’IP était sur une ligne déjà utilisée par les topologies avec 2comme premier bit. Puisqu'il serait difficile d'adapter plus d'une instruction sur cette ligne (une instruction unique peut être sautée à l'aide de l' !instruction) et que je manquais beaucoup d' espace, j'ai décidé de rediriger l'IP de cette ligne et de réutiliser une 1instruction existante. pousser le second bit.

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

Maintenant, tout ce qui restait à faire pour les topologies avec 1leur deuxième bit consistait à fixer l'ordre des deuxième et troisième bits et à se terminer.

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

Restaient enfin les topologies avec 0comme second bit. Il ne restait pas beaucoup d'espace dans le programme, le plus grand espace inutilisé se trouvant sur la première ligne. C'est donc là que j'ai redirigé l'adresse IP pour les topologies 0comme deuxième bit.

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

Je devais encore pousser 0pour le deuxième bit et fixer l'ordre des deuxième et troisième bits ainsi que terminer le programme. Heureusement, j'ai pu réutiliser une $instruction existante afin que les instructions 0et @puissent être placées dans les espaces restants.

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

Enfin, les nops peuvent être supprimés des extrémités des lignes pour obtenir le programme final.

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

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

Essayez-le en ligne!

44 41 40 38 37 octets

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

Essayez-le en ligne!

Pilote d'essai.

Utilise un carré de 6 par 6. Le plus court que je puisse obtenir avec un carré de 8 sur 8 est de 38 octets si quelqu'un veut essayer de l'améliorer.

Explication:

Le premier passage du code code les deux premiers chiffres des préfixes 0et 1. Car 2, il code le troisième nombre puis le premier.

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

Ensuite, nous passons les adresses IP à travers le troisième bord pour décider du nombre final. Nous combinons les IP avec le même préfixe.

     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

Pour les préfixes 0et 1, ils sortent tous les deux du bord supérieur pour décider du troisième nombre.

     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

Pour le 2préfixe, les adresses IP sortent des coins du bord inférieur.

     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

Les deux bords échangent le premier et le troisième numéro, poussez le deuxième nombre et échangez-le avec le troisième pour obtenir le bon ordre.