Klein là một ngôn ngữ 2D tôi đã thiết kế có thể được nhúng trên 12 bề mặt tôpô khác nhau. Một chương trình Klein có thể được chạy trên các bề mặt khác nhau bằng cách thay đổi các đối số dòng lệnh.

Cấu trúc liên kết xác định nơi con trỏ lệnh đi khi nó đi ra khỏi cạnh của chương trình. Khi di chuyển ra khỏi cạnh, ip sẽ nhảy đến một cạnh có màu phù hợp và sẽ duy trì vị trí của nó so với mũi tên, tức là con trỏ sẽ giữ khoảng cách của nó với đầu mũi tên.

Ví dụ cấu trúc liên kết 000, cấu trúc liên kết được sử dụng bởi hầu hết các ngôn ngữ 2D, khiến con trỏ lệnh bao bọc sang phía bên kia khi di chuyển khỏi một cạnh.

Bài tập, nhiệm vụ

Nhiệm vụ này khá đơn giản, hãy viết một chương trình Klein mà khi chạy sẽ xuất ra cấu trúc liên kết mà nó được chạy. Các số riêng lẻ có thể được phân tách bằng dấu cách. (ví dụ 000và 0 0 0cả hai đầu ra cho phép). Bạn có thể chọn sử dụng hoặc bỏ qua -Acờ dòng lệnh, nó sẽ không tốn byte nếu bạn sử dụng nó.

Đây là môn đánh gôn nên câu trả lời ngắn nhất sẽ là người chiến thắng.

Dưới đây là trình điều khiển kiểm tra trực tuyến có thể được sử dụng để kiểm tra tất cả các cấu trúc liên kết cùng một lúc. Để chạy trong chế độ số nguyên, loại bỏ -A.

52 48 byte

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

Hãy thử trực tuyến!

Lái thử

Giải trình

Ở Klein, IP bắt đầu ở góc trên bên trái, bên phải. Bước đầu tiên tôi muốn chương trình của mình thực hiện là gửi IP ra khỏi đầu chương trình để xác định bit thứ nhất và thứ ba. IP sẽ nhập lại chương trình như sau tùy thuộc vào cấu trúc liên kết:

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

Tôi quyết định rằng chương trình của tôi sẽ ghi lại bit thứ ba của cấu trúc liên kết trước bit thứ hai nhưng trao đổi chúng (sử dụng $) trước khi kết thúc. Cuối cùng, tôi đã thêm mã để đẩy các bit đầu tiên và thứ ba của mỗi cấu trúc liên kết tại các điểm nhập của IP được mô tả ở trên.

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

Tiếp theo tôi tập trung vào các cấu trúc liên kết với 1hoặc 2là bit đầu tiên của chúng. Tôi quyết định kết hợp lại chúng và gửi chúng ở phía không kết nối với phía bắc để tôi có thể xác định bit thứ hai của chúng.

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

Thuận tiện điều này tập hợp lại các cấu trúc liên kết bằng bit thứ hai của chúng để tôi có thể đẩy nó lên ngăn xếp.

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

Sau đó tôi chỉ cần trao đổi bit thứ hai và thứ ba và chấm dứt chương trình.

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

Bây giờ các cấu trúc liên kết có 1hoặc 2như bit đầu tiên của chúng hoạt động, tôi có thể tập trung vào việc tạo các cấu trúc liên kết với 0đầu ra chính xác. Bước đầu tiên là kết hợp lại chúng để có thể tách chúng thành hai nhóm dựa trên bit thứ hai của chúng.

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

Đầu tiên tôi tập trung vào các cấu trúc liên kết với 1bit thứ hai của chúng. Chúng đưa ra một thách thức bởi vì đối với chúng, IP nằm trên một dòng đã được sử dụng bởi các cấu trúc liên kết với 2tư cách là bit đầu tiên của chúng. Vì sẽ rất khó để phù hợp với nhiều hơn một lệnh trên dòng đó (một lệnh có thể được nhảy bằng cách sử dụng !hướng dẫn) và tôi đã hết dung lượng toàn bộ, tôi quyết định chuyển hướng IP ra khỏi dòng đó và sử dụng lại một 1lệnh hiện có để đẩy bit thứ hai.

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

Bây giờ tất cả những gì còn lại để làm cho các cấu trúc liên kết với 1bit thứ hai của chúng là sửa thứ tự của bit thứ hai và thứ ba và chấm dứt.

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

Cuối cùng vẫn là cấu trúc liên kết với 0bit thứ hai của chúng. Không còn nhiều không gian trong chương trình với không gian chưa sử dụng lớn nhất nằm ở dòng trên cùng nên tôi đã chuyển hướng IP cho các cấu trúc liên kết với 0bit thứ hai.

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

Tôi vẫn cần phải đẩy 0bit thứ hai và sửa thứ tự của bit thứ hai và thứ ba cũng như chấm dứt chương trình. May mắn thay, tôi đã có thể sử dụng lại một $hướng dẫn hiện có để các hướng dẫn 0và @có thể phù hợp với các không gian còn lại.

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

Cuối cùng, các nops có thể được tước từ cuối dòng để có được chương trình cuối cùng.

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

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

Hãy thử trực tuyến!

44 41 40 38 37 byte

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

Hãy thử trực tuyến!

Lái thử.

Sử dụng một hình vuông 6 x 6. Thời gian ngắn nhất tôi có thể nhận được với một hình vuông 8 x 8 là 38 byte nếu có ai muốn thử cải thiện nó.

Giải trình:

Một mã thông qua đầu tiên mã hóa hai số đầu tiên cho tiền tố 0và 1. Đối với 2, nó mã hóa số thứ ba sau đó đầu tiên.

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

Sau đó, chúng tôi chuyển IP qua cạnh thứ ba để quyết định số cuối cùng. Chúng tôi kết hợp các IP với cùng một tiền tố.

     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

Đối với các tiền tố 0và 1tiền tố, cả hai đều đi ra cạnh trên cùng để quyết định số thứ ba.

     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

Đối với 2tiền tố, các IP đi ra các góc từ cạnh dưới cùng.

     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

Cả hai cạnh hoán đổi số thứ nhất và thứ ba, đẩy số thứ hai và hoán đổi nó với số thứ ba để có được thứ tự chính xác.