Một con kiến ​​đi dọc theo các cạnh (không phải mặt) của một khối khung dây. Mỗi đỉnh mà nó gặp phải trình bày nó với một ngã ba mà từ đó hai cạnh mới tách ra. Con kiến ​​chọn cách rẽ - lefthoặc right. Những hướng này có liên quan đến con kiến, người đang đối mặt với đỉnh và nằm ngoài khối lập phương. Mục tiêu của bạn là xác định, từ chuỗi left/ rightlựa chọn mà con kiến ​​đưa ra, liệu nó có kết thúc ở cùng vị trí mà nó bắt đầu hay không.

Ví dụ, nếu con kiến ​​rẽ trái bốn lần ( left left left left), nó sẽ đi qua một hình vuông ngược chiều kim đồng hồ và kết thúc tại cùng một nơi nó bắt đầu. Nhưng, nếu nó đi left left left left right, nó sẽ kết thúc ở một điểm khác trên khối lập phương. Ngoài ra, nếu nó đi left right right right left, nó kết thúc ở cạnh bắt đầu của nó nhưng phải đối mặt với đỉnh đối diện, không được tính là cùng một vị trí.

Đường đi của kiến ​​có thể lặp lại các cạnh, bao gồm cả cạnh bắt đầu, nhưng điều quan trọng là nó kết thúc ở đâu sau toàn bộ chuỗi.

Viết một hàm được đặt tên theo chuỗi lần lượt của kiến ​​và đưa ra liệu con kiến ​​có trở lại vị trí bắt đầu sau chuỗi không. Việc gán một hàm không tên cho một biến là đủ để biến nó thành một hàm được đặt tên.

(Chỉnh sửa: Nếu ngôn ngữ của bạn không thể tạo chức năng được đặt tên, thay vào đó, ngôn ngữ đó có thể thực hiện chức năng với đầu vào và đầu ra thông qua STDIN / in hoặc ngăn xếp. biến.)

Đầu vào

Một chuỗi left/ rightquyết định của chiều dài 0để 31bao gồm, đại diện trong một định dạng của sự lựa chọn của bạn. Đây có thể là một chuỗi các chữ cái R/ L, một danh sách các số 1/ -1hoặc một mảng Booleans. Không có gì hay ho như việc chúng là tên phương thức hoặc chuỗi hữu ích cho mã của bạn.

Vui lòng gửi các trường hợp thử nghiệm ở định dạng của bạn nếu nó khác với các trường hợp thử nghiệm bên dưới.

Đầu ra

True/ False, 0/ 1hoặc tương tự trong ngôn ngữ của bạn.

Tiêu chí chiến thắng

Ít byte nhất sẽ thắng. Hãy nhớ rằng, bạn cần đưa ra một chức năng được đặt tên. Bạn có thể có mã bên ngoài hàm, nhưng các byte đó cũng được tính. Chức năng của bạn sẽ hoạt động chính xác nếu được gọi nhiều lần.

Các trường hợp thử nghiệm

True trường hợp (một trên mỗi dòng, thứ hai là danh sách trống):

1 1 1 1

-1 -1 -1 -1
1 -1 1 -1 1 -1
1 1 -1 -1 1 1 -1 -1
-1 1 1 -1 -1 1 1 -1
1 1 1 -1 -1 -1 -1 1
1 -1 -1 1 -1 -1
1 1 1 1 -1 -1 -1 -1 1 -1 -1 1 -1 -1
-1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

False trường hợp (một trên mỗi dòng):

1
1 1
1 1 1
-1 1
1 -1 -1 -1 1
1 -1 -1 1 1
-1 1 -1 1
1 1 1 1 -1
-1 -1 1 -1 1 -1 -1 1
1 -1 1 1 1 1 -1 -1 -1 1 1 -1 -1 -1

Đây là trường hợp thử nghiệm tương tự với L's và R'.

True các trường hợp:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False các trường hợp:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

Thử thách tín dụng thêm

Điều tương tự, nhưng với một khối mười hai chứ không phải là một khối. Xem Hunt the Wumpus để biết ý tưởng.

GolfScript, 24 ký tự (chỉ 19 cho cơ thể chức năng)

Toán FTW!

{3,.@{[+~@\{@}*~]}/=}:f;

Kiểm tra giải pháp này trực tuyến.

Hàm này nhận đầu vào là một mảng nhị phân (0 cho trái, 1 cho phải) và trả về 1 cho true và 0 cho false.

Về mặt khái niệm, nó hoạt động bằng cách xoay khối lập phương để con kiến ​​luôn duy trì cùng vị trí và hướng, và kiểm tra xem khối cuối cùng có kết thúc theo cùng hướng khi nó bắt đầu không.

Cụ thể, chúng ta có thể biểu diễn các ngã rẽ trái và phải là hai bản đồ tuyến tính theo ba chiều, trong đó rẽ trái tương ứng với góc xoay 90 ° quanh trục x , tức là bản đồ ( x , y , z ) → ( x , z , - y ) và rẽ phải tương ứng với góc xoay 90 ° quanh trục y , tức là bản đồ ( x , y , z ) → ( z , y , - x ).

Khi bắt đầu hàm, chúng ta chỉ cần thiết lập một vectơ ba phần tử chứa các giá trị dương riêng biệt (1, 2, 3), áp dụng chuỗi các ánh xạ xoay cho nó và kiểm tra xem vectơ kết quả có bằng giá trị ban đầu không.

(Trong thực tế, để lưu một vài ký tự, tôi thực sự biến đổi tọa độ sao cho vectơ ban đầu là (0, 1, 2) và các bản đồ là ( x , y , z ) → ( x , z , 1− y ) và ( x , y , z ) → ( z , y , 1− x ), nhưng kết quả cuối cùng là như nhau.)

Thi thiên Cảm ơn haskeller tự hào vì đã phát hiện ra lỗi trong phiên bản gốc của giải pháp này.

Perl, 58 ký tự

Theo yêu cầu trong các bình luận, đây là giải pháp tương tự được chuyển đến Perl. (Phiên bản này thực sự sử dụng tọa độ chưa được dịch, vì phép chuyển đổi không lưu ký tự trong Perl.)

sub f{@a=@b=1..3;@a[$_,2]=($a[2],-$a[$_])for@_;"@a"eq"@b"}

Kiểm tra giải pháp này trực tuyến.

Phần thưởng: Ant on a Dodecahedron (GolfScript, 26 chars)

{5,.@{{2*2%[~\]}*(+}/=}:f;

Kiểm tra giải pháp này trực tuyến.

Giống như hàm ant-on-a-cube ở trên, hàm này lấy đầu vào là một mảng nhị phân (0 cho trái, 1 cho phải) và trả về 1 nếu con kiến ​​kết thúc ở cùng vị trí và hướng khi nó bắt đầu, hoặc 0 nếu không thì.

Giải pháp này sử dụng một biểu diễn trừu tượng hơn một chút so với giải pháp khối ở trên. Cụ thể, nó sử dụng thực tế là nhóm đối xứng quay của khối mười hai mặt là đẳng cấu với nhóm A ₅ xen kẽ , tức là nhóm hoán vị chẵn của năm nguyên tố. Do đó, mỗi vòng quay có thể của khối mười hai mặt (ánh xạ các cạnh thành các cạnh và đỉnh thành các đỉnh) có thể được biểu diễn duy nhất dưới dạng hoán vị của một mảng năm phần tử, với các phép quay liên tiếp tương ứng với việc áp dụng các hoán vị tương ứng theo trình tự.

Vì vậy, tất cả những gì chúng ta cần làm là tìm hai hoán vị L và R có thể đại diện cho các phép quay trái và phải. Cụ thể, các hoán vị này cần phải là 5 chu kỳ (để áp dụng chúng năm lần trở về trạng thái ban đầu), chúng không được là quyền hạn của nhau (ví dụ R ≠ L ⁿ cho bất kỳ n ) và chúng cần thỏa mãn mối quan hệ ( LR ) ⁵ = (1), trong đó (1) biểu thị hoán vị danh tính. (Trong thực tế, tiêu chí này nói rằng đường dẫn LRLRLRLRLRphải trở về vị trí ban đầu.)

Sửa lỗi hoán vị L thành một nòng đơn giản sang trái, tức là ánh xạ ( a , b , c , d , e ) → ( b , c , d , e , a ), vì nó có thể được thực hiện trong GolfScript chỉ trong hai chars ( (+), chúng tôi thấy rằng có năm lựa chọn có thể cho hoán vị R. Trong số đó, tôi chọn ánh xạ ( a , b , c , d , e ) → ( c , e , d ,b , a ), vì nó cũng có một triển khai GolfScript tương đối nhỏ gọn. (Trong thực tế, tôi thực hiện nó bằng cách đầu tiên đan xen các yếu tố có 2*2%để có được ( một , c , e , b , d ), sau đó trao đổi hai yếu tố cuối cùng với [~\], và cuối cùng áp dụng L hoán vị vô điều kiện để di chuyển một đến cùng.)

Liên kết demo trực tuyến ở trên bao gồm một số trường hợp kiểm tra các đường dẫn hợp lệ trên một Dodecahedron trở về nguồn gốc, chẳng hạn như:

           # empty path
1 1 1 1 1  # clockwise loop
0 0 0 0 0  # counterclockwise loop
1 0 0 0 0 1 1 0 0 0 0 1  # figure of 8
1 0 1 0 1 0 1 0 1 0      # grand circle
1 0 0 0 1 0 0 0          # loop around two faces 
1 0 0 0 1 1 1 0 1 0 1 0 0 0 1 1 1 0 1 0  # Hamilton cycle

Con trăn, 68

Đưa ra một danh sách 1 và -1. Dựa trên các phép quay 3D: kiểm tra xem điểm (3,2,1) có kết thúc tại cùng một vị trí không sau khi áp dụng một loạt các phép quay. Có hai phép quay có thể, tương ứng với 1 và -1. Mỗi cái được thực hiện bằng cách hoán vị hai tọa độ và thay đổi dấu của một trong số chúng. Các tọa độ chính xác để thay đổi và dấu hiệu nào để hoán vị là không quan trọng.

def f(l):
 p=[3,2,1]
 for d in l:p[d],p[0]=-p[0],p[d]
 return[3,2]<p

EDIT: đây thực sự là giải pháp tương tự như "Perl, 58".

Toán học

Lấy cảm hứng từ giải pháp của Ilmari Karonen. Nhóm đối xứng quay của một khối lập phương là đẳng cấu với S ₄ .

Khối lập phương, 51 byte

Fold[Part,r=Range@4,{{2,3,4,1},{3,4,2,1}}[[#]]]==r&

Lấy danh sách 1s và -1s làm đầu vào.

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

Dodecahedron, 55 byte

Fold[Part,r=Range@5,{{2,3,4,5,1},{3,5,4,2,1}}[[#]]]==r&

Lấy danh sách 1s và -1s làm đầu vào.

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

C (gcc) , 118 116 107 105 byte

-2 byte nhờ trần

f(char*s){char*p,n[]="@ABCDEFG",y;for(;*s;s++)for(p=n;*p;*p++^=*s^82?y%2+1:4-(y&2))y=*p/2^*p;y=n[2]==66;}

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

Giả sử chúng ta đã cho khối lập phương các tọa độ sau:

            (1,1,1)       (1,1,0)
          G +--------------+ C
           /|             /|
          / |            / |
         /  |    (0,1,0)/  |
(0,1,1) +--------------+ D |
      H |   |          |   |
        |   |          |   |
        | F +----------|---+ (1,0,0)
        |  /(1,0,1)    |  / B           x
        | /            | /           y / 
        |/             |/            |/  
      E +--------------+ A      z ---*   
        (0,0,1)       (0,0,0)

Nếu chúng ta bắt đầu ở góc D, thì việc chuyển sang C hoặc H có thể được coi là xoay khối lập phương xung quanh chúng ta. Di chuyển sang phải có nghĩa là quay ngược chiều kim đồng hồ quanh trục Z và di chuyển sang trái có nghĩa là quay theo chiều kim đồng hồ quanh trục X. Đây là hai vòng quay duy nhất chúng ta cần quan tâm. Vì mỗi góc quay chính xác 90 độ, chúng ta có thể tưởng tượng các góc "trượt" dọc theo các cạnh. Để di chuyển sang phải, điều này có nghĩa là A -> B, B -> C, C -> D, D -> A với phía bên kia đang thực hiện E -> F, v.v ... Để di chuyển sang trái, chúng ta thay vào đó là A -> E, E - > H v.v.

Vì mỗi góc chỉ trượt dọc theo một cạnh, điều đó có nghĩa là chỉ một trong các kích thước của mỗi điểm thay đổi cho mỗi vòng quay. Khi B di chuyển đến C, chỉ thành phần y của nó thay đổi và khi H di chuyển đến D, chỉ thành phần z của nó thay đổi, v.v. Hơn nữa, vì tọa độ được giới hạn ở 0 và 1, chúng ta có thể nghĩ mỗi điểm là một số nhị phân, với bit thích hợp được lật khi di chuyển.

Chúng ta có thể thấy rằng đối với một chuyển động sang phải, A và C lật x của họ, trong khi D và B lật y của họ. Nếu chúng ta thay đổi phối cảnh để nhìn vào phía bên kia của khối lập phương và bỏ qua thành phần z (dù sao nó không thay đổi cho phép quay này), chúng ta sẽ nhận được:

D (0,1)         C (1,1)
 +-------------+
 |             |
 |             |
 |             |
 |             |
 |             |
 |             |
 +-------------+
A (0,0)         B (1,0)

Một mô hình xuất hiện: Đối với các điểm lật x, x == y, trong khi điều ngược lại là đúng đối với các điểm lật y của chúng. Cái này giữ cho kiểu quay khác, nhưng với z thay vì x.

Nói cách khác:

Right
    if (x == y) x = !x
    if (x != y) y = !y

Left
    if (z == y) z = !z
    if (z != y) y = !y

Bây giờ chúng ta có thể dễ dàng đi qua tất cả các phép quay và cuối cùng xem liệu D cuối cùng có khớp với chữ D ban đầu của chúng ta không

Lưu trữ mỗi điểm dưới dạng một số duy nhất là một số đã cho, nhưng trong C, việc gán một mảng char nhỏ gọn hơn nhiều so với một mảng int. Chúng tôi cẩn thận chọn các ký tự có ba bit thấp hơn khớp với 000..111, làm cho có thể bỏ qua các bit còn lại. Lật tọa độ chỉ đơn giản là vấn đề XOR'ing với bitmask thích hợp.

Con trăn - 110, 150

Đưa vào một danh sách các số nguyên với -1rẽ trái, 1rẽ phải.

Khối, 110:

def f(l):
    c,p='07'
    for d in l:a="100134462634671073525275"[int(c)::8];c,p=a[(a.index(p)+d)%3],c
    return'1'>c

Kiểm tra:

l=map(int,'1 1 1 1'.split())
print f(l)

Cây ngải cứu, 150:

def f(l):
    c,p='0J'
    for d in l:a="I5H76E8BBA8F76543100JI0J21D3A5C7E9CJI2132H4GF94C6D98AHGBEDGF"[int(c,36)::20];c,p=a[(a.index(p)+d)%3],c
    return'1'>c

Tuyệt vời 188

Trộm cắp không biết xấu hổ về thuật toán của Ilmari Karonen với mục đích thể hiện một ngôn ngữ mới.

Kịch bản lệnh này mong đợi một chuỗi 0x00 cho bên trái và 0x01 cho bên phải trên stdin, theo sau là 0x0A (dòng mới). Nó xuất ra "0" cho trường hợp thất bại và "1" cho thành công.

......@5@3FF
@0@1@2\\]]@5
010203@4=A@4
&0&0&0&0/\
MVMVMVMV..
@0@1@2@3..!!
:MV
}2}2}1}0}1}0}3
&0&1&0&1~~~~<A@P
{0{1{1{0&1&0=0&1
}0}1}2@P{2{2&030
=1=2=3&2FF}3..//
&2&2&231&2{3
\/\/\/&2!!..//

chạy ví dụ:

# echo -e "\x0\x0\x0\x1\x0\x0\x1\x1\x0\x1\x0\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1" | marbelous.py ant-on-a-cube.mbl
1

Python 2 , 57 byte

f=lambda l:reduce(lambda n,x:n%4*64+n/4*16**x%63,l,27)<28

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

Điều này sử dụng biểu diễn hoán vị

0: abcd -> dabc
1: abcd -> dcab

trong đó trái và phải (0 và 1) tương ứng với 4 chu kỳ dài trên 4 phần tử. Chúng tôi lặp lại đầu vào áp dụng hoán vị được chỉ định và kiểm tra xem kết quả có bằng giá trị ban đầu không.

Chúng tôi bắt đầu a,b,c,dnhư danh sách bốn yếu tố 0,1,2,3. Chúng tôi nén chúng thành một số 4 cơ sở duy nhất n=abcd, với giá trị ban đầu n=27tương ứng với 0123cơ sở 4. Chúng tôi khởi tạo mỗi hoán vị một cách hợp lý trên n.

Vì cả hai kết quả bắt đầu bằng d, chúng tôi có thể làm n%4để trích xuất d, sau đó n%4*64di chuyển nó vào đúng vị trí d___. Các chữ số khác abc, được trích xuất là n/4. Chúng ta cần chèn chúng vào ba giá trị thấp hơn.

Đối với hướng x=0, chúng tôi chèn abcnhư là, và cho x=1, chúng tôi xoay chúng như cab. Việc luân chuyển có thể đạt được như *16%63, trong đó có abctới abc00đến cab. (Điều %63này sẽ sai a==b==c==3, nhưng những giá trị này là không thể.) Vì chỉ cần làm %63là không có, nên biểu thức phụ thuộc vào hướng *16**x%63đưa ra abchoặc cabtheo yêu cầu.

Python 2 , 55 byte

f=lambda l:reduce(lambda n,x:n^(n*8%63|7*8**x),l,10)<11

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

Haskell, 104 103 99 97 96/ 67 64 chars

Tôi cảm thấy tương đương với phải / trái sẽ là một kiểu dữ liệu Hướng như vậy:

Direction = R | L

Vì vậy, tôi giả sử trong câu trả lời của tôi rằng họ đã có sẵn.
chỉnh sửa: thực sự nhận ra rằng booleans sẽ dẫn đến mã ngắn hơn. True đại diện cho rẽ trái và Sai đại diện cho rẽ phải (mặc dù về mặt kỹ thuật, mã sẽ hoạt động như nhau nếu được lật; nó đối xứng)

96 ký tự:

m[p,l,r]b|b=[p%l,7-r-l,r]|0<1=[p%r,l,7-r-l]
p%x|odd$div p x=p-x|0<1=p+x
g l=foldl m[0..2]l<[0,2]

g là một hàm đưa ra một danh sách Hướng sẽ trả lại thời tiết mà không phải con kiến ​​đã trở lại vị trí của nó.

giải thích về đại diện của vị trí: vị trí của con kiến ​​được mã hóa thành một bộ ba số nguyên. số nguyên đầu tiên đại diện cho đỉnh mà con kiến ​​đang hướng đến. bit đầu tiên biểu thị nếu đỉnh nằm ở nửa lên / xuống, nửa thứ hai là nửa trái / phải và nửa thứ ba là nửa sau / nửa trước. điều này được thực hiện sao cho việc di chuyển từ đỉnh này sang đỉnh lân cận có thể được thực hiện bằng cách lật một bit.

số nguyên thứ hai là số lượng mà đỉnh kiến ​​sẽ thay đổi nếu nó đi bên trái. ví dụ: nếu con kiến ​​ở đỉnh 3 và số nguyên thứ hai là 4, thì sau khi rẽ trái, đỉnh sẽ là 7. lưu ý đây sẽ luôn là lũy thừa 2, vì chính xác một bit được lật bằng cách di chuyển một đỉnh.

số nguyên thứ ba là như nhau, nhưng để đi đúng; Tôi biết điều này có thể được tính bởi hai người đầu tiên, nhưng tôi không biết làm thế nào. nếu bạn có một ý tưởng, xin vui lòng cho tôi biết.

Một điều cần lưu ý là khi rẽ trái, số nguyên thứ ba sẽ giữ nguyên và số thứ hai sẽ trở thành số nguyên giữa 1 2 và 4 không phải là số nguyên thứ hai hoặc số thứ ba, xảy ra giống như 7 - số nguyên thứ hai - số nguyên thứ ba.

tôi đã chọn cách thể hiện vị trí này bởi vì (như đã nói ở đoạn trước), việc tính toán vị trí tiếp theo là không quan trọng.

giải thích các chức năng:

hàm (%) là hàm lấy đỉnh hiện tại và số lượng để thay đổi nó và thay đổi nó. nó nhận được bit sẽ thay đổi và lật nó (theo một cách rất số).

hàm m là hàm lấy vị trí của con kiến ​​và hướng và trả về vị trí mới bằng cách sử dụng ghi chú mà chúng ta đã lưu ý trước đó.

sau đó, hàm m được kết hợp bằng cách sử dụng Foldl (giống như reducetrong javascript, nhưng biểu cảm hơn một chút) để tạo hàm g, câu trả lời cho câu hỏi này.

Haskell, 64 ký tự

lấy cảm hứng từ câu trả lời của @ alphaalpha, đây là phiên bản được chuyển sang haskell:

m[a,b,c,d]p|p=[b,c,d,a]|0<1=[b,d,a,c]
g l=foldl m[0..3]l<[0,1,3]

sửa: Bây giờ tôi cảm thấy vô cùng ngu ngốc vì câu trả lời của lmari Karonen. có lẽ tôi sẽ chuyển câu trả lời của mình cho haskell. chỉnh sửa khác: không cảm thấy ngu ngốc như câu trả lời của anh ta là
chỉnh sửa sai : chuyển từ thực sự sử dụng bộ dữ liệu sang sử dụng danh sách làm Ordví dụ của họ và [ ... ]đường cú pháp làm cho nó ngắn hơn

Haskell , 53 byte

f=(<28).foldl(\n x->mod n 4*64+mod(div n 4*16^x)63)27

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

Logic giống như câu trả lời Python của tôi , thậm chí đã nghĩ modvà divdài hơn để viết.

Haskell , 58 byte

r=[1..3]
f=(==r).foldl(\[x,y,z]->(!!)[[x,-z,y],[-z,y,x]])r

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

APL (Dyalog Unicode) , 22 byte ( SBCS của Adám )

f←{x∊(-@3∘⌽⌽)/⍵,x←⊂⍳3}

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

H.PWiz đề xuất rằng đảo ngược các bước không tạo ra sự khác biệt và dẫn đến -2 byte.

Chà, điều này thật đáng xấu hổ, vì nó được dự định là ngắn hơn GolfScript. Ít nhất tôi đã cố gắng.

Hàm được đặt tên f, và, trong các trường hợp thử nghiệm, 1đại diện cho rẽ trái (boolean true) và 0đại diện cho rẽ phải (boolean false). ⍬đại diện cho danh sách trống.

APL (Dyalog) , 21 byte

f←{x≡(↓∪⊢∘⌽)/⍵,x←⊂⍳4}

Hãy thử trực tuyến! (Sử dụng môi trường thử nghiệm từ câu trả lời của Erik the Outgolfer )

Tôi đi bên trái và bên phải như 1và 2. Điều này sử dụng các hoán vị sau đây của abcd:

1 : bcda
2 : cdba

Tôi áp dụng các hoán vị tương ứng với 1và 2để ⍳4 : 1 2 3 4, và kiểm tra xem nó là không thay đổi

Bash , 71 65 byte

f()(a=1234;for i;{ a=`tr 1-4 4$[$i?123:312]<<<$a`;};((a==1234));)

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

Giống như nhiều câu trả lời trước đó, sử dụng một đại diện của nhóm xoay của khối được tạo bởi 1234-> 4123 và 1234-> 4312. Sử dụng số thay vì chữ cái để tôi có thể sử dụng toán tử ternary với mở rộng số học. Yêu cầu đầu vào của nó là 0 và 1 được phân tách bằng dấu cách và đầu ra thông qua mã thoát.

6 byte được lưu nhờ bình luận của @ manatwork!

brainfuck , 119 byte, 137 byte

$S_4$

Khối lập phương, 119 byte

++++>+++>++>+>,[+++[->+++<]<<<<[->>>>+<<<<]>[>]<+[[-]<[->+<]<<<[->>>+<<<]>[>]],]<[[<]>[->]<[>>]<]<[>>-<]-[----->+<]>--.

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

++++>+++>++>+    Initialize tape as 4 3 2 1

>,[              For each input byte:

  +++[->+++<]       Add 3 and multiply by 3; if input is R, this will be 255

  <<<<[->>>>+<<<<]  Move first number to end (BCDA)

  >[>]<+[           If input wasn't R:

    [-]                Zero input cell (which is now negative 18)

    <[->+<]            Move previously moved number one slot further (BCD_A)

    <<<[->>>+<<<]      Move first number into vacated slot (CDBA)

  >[>]]

,]

<[[<]>[->]<[>>]<]     Determine whether tape is still 4 3 2 1

<[>>-<]               If not: subtract 1 from output cell

-[----->+<]>--.       Create "1" in output cell and output

Dodecahedron, 137 byte

+++++>++++>+++>++>+>,[+++[->+++<]<<<<<[>>>>>+[<]>-]>[>]<+[[-]<<[[->>+<<]<<]>[>>>>>>+[<]<-]>>[>]],]<[[<]>[->]<[>>]<]<[>>-<]-[----->+<]>--.

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

Sự khác biệt duy nhất giữa hai chương trình là thiết lập và hoán vị. Hoán vị trái được sử dụng ở đây là DCAEB, dường như là liên hợp golf có sẵn nhất.

Thạch , 14 byte

3RðW;ṙN1¦ṚƊ/⁼⁸

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

1= rẽ trái, 0= rẽ phải. Dựa trên giải pháp Dyalog của tôi.

Thật không may, Jelly không có chức năng được đặt tên. Nếu tôi không thể sử dụng đầu vào ngầm định và cần giả sử nó là một biến, phiên bản có cùng độ dài này sẽ thực hiện:

3RµW;®ṙN1¦ṚƊ/⁼

Nó giả sử đầu vào là trong thanh ghi (© / ®).

Perl - 120, 214

Có một mảng (danh sách) booleans.

Khối lập phương (120):

sub e{$a=$b=0;for$c(@_){$_=(13,62,53,40,57,26,17,'04')[$b];$d=s/$a/($b-1)%8/e;($a,$b)=($b,substr($_,$c^$d,1))}return!$b}

Cây ngải cứu (214):

sub e{$a=$b='00';for$c(@_){$_=('01041102090307040500061807160308091502101114121019131714151016081706131819051200'=~/\d{4}/g)[$b];$d=s/$a/sprintf'%02d',($b-1)%20/e;($a,$b)=($b,substr($_,($c^$d)*2,2));}return!($b+0)}