克莱因（Klein）是我设计的2D语言，可以嵌入12种不同的拓扑表面。通过更改命令行参数，可以在不同的表面上运行Klein程序。

拓扑确定指令指针离开程序边缘时的位置。当移出边缘时，ip将跳至具有匹配颜色的边缘，并保持其相对于箭头的位置，即指针将保留其与箭头的距离。

例如topology 000，大多数2D语言使用的topology ，当离开边缘时，会使指令指针环绕到另一侧。

任务

任务非常简单，编写一个Klein程序，该程序在运行时将输出其运行所在的拓扑。各个数字可以用空格分隔。（例如000和0 0 0都是允许的输出）。您可以选择使用或忽略-A命令行标志，如果使用它不会花费您的字节数。

这是代码高尔夫球，所以最短的答案将是赢家。

这是一个在线测试驱动程序，可用于一次测试所有拓扑。要以整数模式运行，请删除-A。

52 48字节

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

在线尝试！

测试驱动

说明

在Klein中，IP从右上角开始。我希望程序执行的第一步是从程序顶部发送IP，以确定第一位和第三位。IP将根据拓扑重新输入程序，如下所示：

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

我决定我的程序将在第二位之前记录拓扑的第三位，但$在结束之前交换它们（使用）。为此，我添加了代码以将每个拓扑的第一和第三位压入上述IP的入口点。

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

接下来，我首先关注1或2来关注拓扑。我决定重新组合它们，并在未连接到北侧的一侧将它们送出，以便确定它们的第二个位置。

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

方便地，这将拓扑按第二位进行了重新组合，因此我可以将其推入堆栈。

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

之后，我只需要交换第二和第三位并终止程序即可。

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

既然使用1或2刚开始使用的拓扑已经起作用，那么我可以集中精力制作具有0正确输出的拓扑。第一步是重新组合它们，以便可以根据它们的第二位将它们分为两组。

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

首先，我将重点放在那些拓扑上1。这些提出了一个挑战，因为对于他们来说，IP位于拓扑已经使用2的第一行。由于在该行上容纳多条指令（使用一条指令可以跳过一条指令）非常棘手，!而且我总体上空间不足，因此我决定将IP重定向到该行之外并重用现有的1指令推第二位。

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

现在剩下的工作就是拓扑，1因为它们的第二位是固定第二位和第三位的顺序并终止。

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

最后，将拓扑0作为第二位。程序中没有剩余多少空间，最大的未使用空间位于第一行，因此我在那里将拓扑的IP重定向0为第二位。

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

我仍然需要推动0第二位并固定第二位和第三位的顺序以及终止程序。幸运的是，我能够重用现有的$指令，因此0and @指令可以适合剩余的空间。

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

最终，可以从行尾去除点，以获得最终程序。

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

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

在线尝试！

44 41 40 38 37字节

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

在线尝试！

测试驱动程序。

使用6 x 6平方。如果有人想尝试改进它，那么我得到的最短的乘以8 x 8的正方形可以得到38个字节。

说明：

第一个直通代码对前缀0和编码前两个数字1。对于2，它将先编码第三个数字。

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

然后，我们将IP传递到第三个边缘，以决定最终编号。我们将IP加上相同的前缀。

     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

对于0和1前缀，它们都位于顶部边缘以确定第三个数字。

     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

对于2前缀，IP从底部边缘出来。

     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

两条边都交换第一个和第三个数字，推第二个数字，然后与第三个交换它以获得正确的顺序。