Klein è un linguaggio 2D che ho progettato che può essere incorporato in 12 diverse superfici topologiche. Un programma Klein può essere eseguito su diverse superfici modificando gli argomenti della riga di comando.

La topologia determina dove va il puntatore dell'istruzione quando si spegne dal bordo del programma. Quando si sposta fuori dal bordo, l'ip salterà su un bordo con il colore corrispondente e manterrà la sua posizione rispetto alla freccia, ovvero il puntatore manterrà la sua distanza dalla testa della freccia.

Ad esempio la topologia 000, la topologia utilizzata dalla maggior parte dei linguaggi 2D, fa sì che il puntatore dell'istruzione si sposti sull'altro lato quando si sposta da un bordo.

Compito

Il compito è piuttosto semplice, scrivere un programma Klein che quando eseguito genererà la topologia in cui viene eseguito. I singoli numeri possono essere separati da spazi. (ad es. 000e 0 0 0sono entrambi output consentiti). Puoi scegliere di utilizzare o ignorare il -Aflag della riga di comando che non ti costerà byte se lo usi.

Questo è code-golf, quindi la risposta più breve sarà il vincitore.

Ecco un driver di test online che può essere utilizzato per testare tutte le topologie contemporaneamente. Per eseguire in modalità intera, rimuovere il -A.

52 48 byte

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

Provalo online!

Test Driver

Spiegazione

In Klein l'IP inizia nell'angolo in alto a sinistra andando a destra. Il primo passo che volevo fare al mio programma era di inviare l'IP dalla parte superiore del programma per determinare il primo e il terzo bit. L'IP reinserirà il programma come segue a seconda della topologia:

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

Ho deciso che il mio programma avrebbe registrato il terzo bit della topologia prima del secondo bit ma li avrebbe scambiati (usando $) prima della fine. A tal fine ho aggiunto il codice per inviare il primo e il terzo bit di ciascuna topologia nei punti di ingresso dell'IP sopra descritti.

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

Successivamente mi sono concentrato sulle topologie con 1o 2come primo bit. Ho deciso di ricombinarli e di inviarli sul lato non collegato al lato nord in modo da poter determinare il loro secondo bit.

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

Convenientemente, questo ha raggruppato le topologie con il loro secondo bit in modo da poterlo spingere nello stack.

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

Dopodiché avevo solo bisogno di scambiare il secondo e il terzo bit e terminare il programma.

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

Ora che le topologie con 1o 2come primo bit funzionavano, potevo concentrarmi sul fare in modo che le topologie 0fornissero il risultato corretto. Il primo passo è stato ricombinarli in modo da poterli separare in due gruppi in base al secondo bit.

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

In primo luogo mi sono concentrato su quelle topologie con 1come secondo bit. Questi rappresentavano una sfida perché per loro l'IP era su una linea già utilizzata dalle topologie 2come primo bit. Dal momento che sarebbe difficile per adattarsi a più di un'istruzione su quella linea (una singola istruzione può essere saltato utilizzando l' !istruzione) e mi è stato a corto di spazio nel suo insieme, ho deciso di reindirizzare l'IP fuori quella linea e riutilizzare uno esistente 1di istruzioni per spingere il secondo bit.

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

Ora tutto ciò che rimaneva da fare per le topologie con 1il loro secondo bit era correggere l'ordine del secondo e terzo bit e terminare.

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

Infine sono rimaste le topologie con 0il loro secondo bit. Non era rimasto molto spazio nel programma con lo spazio inutilizzato più grande nella riga superiore, quindi è stato lì che ho reindirizzato l'IP per le topologie con 0il loro secondo bit.

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

Avevo ancora bisogno di premere 0per il secondo bit e correggere l'ordine del secondo e terzo bit, nonché terminare il programma. Fortunatamente, sono stato in grado di riutilizzare un'istruzione esistente in $modo che le istruzioni 0e si @adattassero agli spazi rimanenti.

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

Alla fine, il nops può essere rimosso dalle estremità delle linee per ottenere il programma finale.

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

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

Provalo online!

44 41 40 38 37 byte

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

Provalo online!

Autista di prova.

Utilizza un quadrato 6 per 6. Il più breve che potrei ottenere con un 8 per 8 quadrati è di 38 byte se qualcuno vuole provare a migliorarlo.

Spiegazione:

Uno il primo pass-through del codice codifica i primi due numeri per i prefissi 0e 1. Per 2, codifica il terzo numero quindi il primo.

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

Quindi passiamo gli IP attraverso il terzo limite per decidere il numero finale. Combiniamo gli IP con lo stesso prefisso.

     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

Per i prefissi 0e 1, entrambi escono dal bordo superiore per decidere il terzo numero.

     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

Per il 2prefisso, gli IP escono dagli angoli dal bordo inferiore.

     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

Entrambi i bordi scambiano il primo e il terzo numero, spingono il secondo numero e lo scambiano con il terzo per ottenere l'ordine corretto.