Klein ist eine von mir entworfene 2D-Sprache, die auf 12 verschiedenen topologischen Oberflächen eingebettet werden kann. Ein Klein-Programm kann durch Ändern der Befehlszeilenargumente auf verschiedenen Oberflächen ausgeführt werden.

Die Topologie bestimmt, wohin der Befehlszeiger geht, wenn er den Rand des Programms verlässt. Beim Abheben von der Kante springt das ip zu einer Kante mit der entsprechenden Farbe und behält seine Position relativ zum Pfeil bei, dh der Zeiger behält seinen Abstand zur Pfeilspitze bei.

Beispielsweise 000bewirkt die Topologie , die von den meisten 2D-Sprachen verwendet wird, dass der Anweisungszeiger auf die andere Seite umgebrochen wird, wenn er von einer Kante abweicht.

Aufgabe

Die Aufgabe ist ziemlich einfach: Schreiben Sie ein Klein-Programm, das beim Ausführen die Topologie ausgibt, in der es ausgeführt wird. Die einzelnen Zahlen können durch Leerzeichen getrennt sein. (zB 000und 0 0 0sind beide zulässige Ausgaben). Sie können das -ABefehlszeilen-Flag entweder verwenden oder ignorieren, es kostet Sie keine Bytes, wenn Sie es verwenden.

Dies ist Code-Golf, also gewinnt die kürzeste Antwort.

Hier ist ein Online-Testtreiber, mit dem alle Topologien gleichzeitig getestet werden können. Um im Ganzzahlmodus zu laufen, entfernen Sie die -A.

52 48 Bytes

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

Probieren Sie es online!

Testfahrer

Erläuterung

In Klein beginnt die IP in der oberen linken Ecke und geht nach rechts. Der erste Schritt, den ich von meinem Programm wollte, bestand darin, die IP von der Programmspitze zu entfernen, um das erste und dritte Bit zu bestimmen. Die IP würde das Programm abhängig von der Topologie wie folgt erneut eingeben:

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

Ich habe beschlossen, dass mein Programm das dritte Bit der Topologie vor dem zweiten Bit aufzeichnet, sie aber $vor dem Ende austauscht (verwendet ). Zu diesem Zweck habe ich Code hinzugefügt, um das erste und dritte Bit jeder Topologie an den oben beschriebenen Eintrittspunkten des IP zu verschieben.

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

Als nächstes habe ich mich auf die Topologien mit 1oder 2als erstes Bit konzentriert. Ich entschied mich, sie neu zu kombinieren und sie auf der Seite loszuschicken, die nicht mit der Nordseite verbunden war, damit ich ihr zweites Bit bestimmen konnte.

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

Praktischerweise gruppierte dies die Topologien nach ihrem zweiten Bit neu, so dass ich das auf den Stapel schieben konnte.

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

Danach musste ich nur noch das zweite und dritte Bit tauschen und das Programm beenden.

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

Nachdem die Topologien mit 1oder 2als erstes funktionierten, konnte ich mich darauf konzentrieren, die Topologien mit 0der richtigen Ausgabe zu versehen. Der erste Schritt bestand darin, sie neu zu kombinieren, damit sie basierend auf ihrem zweiten Bit in zwei Gruppen aufgeteilt werden konnten.

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

Ich habe mich zuerst auf diese Topologien konzentriert und 1als zweites Bit. Diese stellten eine Herausforderung dar, da sich die IP auf einer Leitung befand, die bereits von den Topologien 2als erstes Bit verwendet wurde. Da es schwierig wäre, mehr als einen Befehl in diese Zeile einzufügen (ein einzelner Befehl kann mit dem !Befehl übersprungen werden ) und mir der Platz insgesamt ausgeht, habe ich beschlossen, die IP von dieser Zeile umzuleiten und einen vorhandenen 1Befehl wiederzuverwenden das zweite Bit drücken.

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

Nun war für die Topologien mit 1ihrem zweiten Bit nur noch die Reihenfolge des zweiten und dritten Bits festzulegen und zu beenden.

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

Zuletzt blieben die Topologien mit 0als zweitem Bit. Es war nicht mehr viel Speicherplatz im Programm vorhanden, und der größte nicht genutzte Speicherplatz befand sich in der obersten Zeile. Daher habe ich dort die IP für die Topologien 0als zweites Bit umgeleitet .

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

Ich musste immer noch auf 0das zweite Bit drängen und die Reihenfolge des zweiten und dritten Bits festlegen sowie das Programm beenden. Glücklicherweise konnte ich eine vorhandene $Anweisung wiederverwenden , sodass die Anweisungen 0und @in die verbleibenden Bereiche passen.

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

Schließlich können die Nops von den Zeilenenden entfernt werden, um das endgültige Programm zu erhalten.

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

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

Probieren Sie es online!

44 41 40 38 37 Bytes

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

Probieren Sie es online!

Testfahrer.

Verwendet ein 6 mal 6 Quadrat. Das kürzeste, was ich mit einem 8 x 8-Quadrat erreichen kann, sind 38 Byte, wenn jemand versuchen möchte, es zu verbessern.

Erläuterung:

Einer der ersten Pass-Through-Codes codiert die ersten beiden Zahlen für die Präfixe 0und 1. Denn 2es codiert die dritte Zahl und dann die erste.

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

Dann leiten wir die IPs durch die dritte Kante, um die endgültige Nummer zu bestimmen. Wir kombinieren die IPs mit dem gleichen Präfix.

     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

Für die 0und 1Präfixe, sie kommen beide die obere Kante , um die dritte Zahl zu entscheiden.

     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

Für das 2Präfix ragen die IPs an der Unterkante aus den Ecken heraus.

     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

Beide Kanten tauschen die erste und dritte Zahl aus, drücken die zweite Zahl und tauschen sie mit der dritten, um die richtige Reihenfolge zu erhalten.