Seekor semut berjalan di sepanjang tepi (bukan wajah) kubus gambar rangka. Setiap vertex yang dihadapinya menyajikannya dengan garpu yang darinya dua tepi baru bercabang. Semut memilih jalan mana yang akan diputar - leftatau right. Arah ini relatif terhadap semut, yang menghadap puncak dan berada di luar kubus. Tujuan Anda adalah untuk menentukan, dari urutan left/ rightpilihan yang diambil semut, apakah itu berakhir pada posisi yang sama dengan yang dimulainya.

Sebagai contoh, jika semut belok kiri empat kali ( left left left left), ia akan melewati persegi berlawanan arah jarum jam dan berakhir di tempat yang sama dengan semula. Tetapi, jika itu berjalan left left left left right, itu akan berakhir di tempat yang berbeda di kubus. Juga, jika berjalan left right right right left, ujungnya berakhir pada ujung awalnya tetapi menghadap titik yang berlawanan, yang tidak dihitung sebagai posisi yang sama.

Jalur semut mungkin mengulangi tepi, termasuk ujungnya dimulai, tetapi yang penting adalah di mana ia berakhir setelah seluruh urutan.

Tulis fungsi bernama yang mengambil urutan belokan dan keluaran semut apakah semut kembali pada posisi awal setelah urutan. Menetapkan fungsi yang tidak disebutkan namanya ke variabel sudah cukup untuk membuatnya menjadi fungsi bernama.

(Sunting: Jika bahasa Anda tidak dapat membuat fungsi bernama, itu bisa mengimplementasikan fungsi dengan input dan output melalui STDIN / pencetakan atau tumpukan. Jika itu tidak mungkin, buatlah cuplikan di mana input dan output disimpan dalam variabel.)

Memasukkan

Urutan left/ rightkeputusan panjang 0untuk 31inklusif, diwakili dalam format pilihan Anda. Ini mungkin berupa string huruf R/ L, daftar angka 1/ -1, atau array Boolean. Tidak ada yang cheesy jika mereka menjadi nama metode atau string yang berguna untuk kode Anda.

Silakan kirim test case dalam format Anda jika berbeda dari test case di bawah ini.

Keluaran

True/ False, 0/ 1, atau analog dalam bahasa Anda.

Kriteria menang

Bytes paling sedikit menang. Ingat, Anda harus memberikan fungsi yang bernama. Anda dapat memiliki kode di luar fungsi, tetapi byte tersebut juga dihitung. Fungsi Anda harus berperilaku dengan benar jika dipanggil beberapa kali.

Uji kasus

True kasing (satu per baris, yang kedua adalah daftar kosong):

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 kasing (satu per baris):

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

Berikut ini kasus uji yang sama dengan L's dan R' s.

True kasus:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False kasus:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

Tantangan kredit ekstra

Hal yang sama, tetapi dengan dodecahedron daripada kubus. Lihat Hunt the Wumpus untuk mendapatkan ide.

GolfScript, 24 karakter (19 untuk fungsi saja)

FTW Matematika!

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

Uji solusi ini secara online.

Fungsi ini sebagai input array biner (0 untuk kiri, 1 untuk kanan) dan mengembalikan 1 untuk true dan 0 untuk false.

Secara konseptual, ia bekerja dengan memutar kubus sehingga semut selalu mempertahankan posisi dan orientasi yang sama, dan memeriksa apakah kubus akhirnya berakhir dalam orientasi yang sama seperti yang dimulai.

Secara khusus, kita dapat mewakili belokan kiri dan kanan sebagai dua peta linier dalam tiga dimensi, di mana belokan kiri berhubungan dengan rotasi 90 ° di sekitar sumbu x , yaitu peta ( x , y , z ) → ( x , z , - y ), dan belok kanan sesuai dengan rotasi 90 ° di sekitar sumbu y , yaitu peta ( x , y , z ) → ( z , y , - x ).

Pada awal fungsi, kita cukup mengatur vektor tiga elemen yang berisi nilai positif berbeda (1, 2, 3), menerapkan urutan peta rotasi padanya, dan memeriksa apakah vektor yang dihasilkan sama dengan yang awal.

(Bahkan, untuk menyimpan beberapa karakter, saya benar-benar mengubah koordinat sehingga vektor awal adalah (0, 1, 2) dan peta-peta tersebut adalah ( x , y , z ) → ( x , z , −1− y ) dan ( x , y , z ) → ( z , y , −1− x ), tetapi hasil akhirnya sama.)

Ps. Terima kasih kepada haskeller yang bangga telah menemukan bug di versi asli dari solusi ini.

Perl, 58 karakter

Seperti yang diminta dalam komentar, inilah solusi yang sama yang diangkut ke Perl. (Versi ini benar-benar menggunakan koordinat yang tidak diubah, karena transformasi tidak menyimpan karakter di Perl.)

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

Uji solusi ini secara online.

Bonus: Semut pada Dodecahedron (GolfScript, 26 karakter)

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

Uji solusi ini secara online.

Seperti fungsi ant-on-a-cube di atas, fungsi ini sebagai input array biner (0 untuk kiri, 1 untuk kanan) dan mengembalikan 1 jika semut berakhir pada posisi dan orientasi yang sama dengan yang dimulai, atau 0 jika tidak.

Solusi ini menggunakan representasi yang sedikit lebih abstrak daripada solusi kubus di atas. Secara khusus, ia menggunakan fakta bahwa grup simetri rotasi dodecahedron adalah isomorfik untuk grup bergantian A ₅ , yaitu grup permutasi genap dari lima elemen. Dengan demikian, setiap kemungkinan rotasi dodecahedron (yang memetakan tepi ke tepi dan simpul ke simpul) dapat secara unik direpresentasikan sebagai permutasi dari array lima elemen, dengan rotasi berturut-turut yang sesuai untuk menerapkan permutasi yang sesuai secara berurutan.

Jadi, yang perlu kita lakukan adalah menemukan dua permutasi L dan R yang dapat mewakili rotasi kiri dan kanan. Secara khusus, permutasi ini harus 5-siklus (sehingga menerapkannya lima kali kembali ke keadaan semula), mereka tidak boleh menjadi kekuatan satu sama lain (yaitu R ≠ L ⁿ untuk setiap n ), dan mereka harus memenuhi hubungan ( LR ) ⁵ = (1), di mana (1) menunjukkan permutasi identitas. (Akibatnya, kriteria ini menyatakan bahwa jalan LRLRLRLRLRharus kembali ke posisi semula.)

Memperbaiki permutasi L menjadi barrel shift sederhana ke kiri, yaitu pemetaan ( a , b , c , d , e ) → ( b , c , d , e , a ), karena dapat diimplementasikan dalam GolfScript hanya dalam dua chars ( (+), kami menemukan bahwa ada lima pilihan yang mungkin untuk permutasi R. Dari semua itu, saya memilih pemetaan ( a , b , c , d , e ) → ( c , e , d ,b , a ), karena ia juga memiliki implementasi GolfScript yang relatif kompak. (Faktanya, saya mengimplementasikannya dengan pertama-tama menghubungkan elemen-elemen dengan 2*2%untuk mendapatkan ( a , c , e , b , d ), kemudian menukar dua elemen terakhir dengan [~\], dan akhirnya menerapkan permutasi L tanpa syarat untuk memindahkan a ke ujung.)

Tautan demo online di atas mencakup beberapa kasus uji jalur yang valid pada Dodecahedron yang kembali ke asal, seperti:

           # 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

Python, 68

Mengambil daftar 1 dan -1. Berdasarkan rotasi 3D: memeriksa apakah titik (3,2,1) berakhir pada posisi yang sama setelah menerapkan serangkaian rotasi. Ada dua kemungkinan rotasi, sesuai dengan 1 dan -1. Masing-masing dilakukan dengan mengubah dua koordinat dan mengubah tanda salah satunya. Koordinat yang tepat untuk diubah dan tanda mana yang diblokir tidak penting.

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

EDIT: ini sebenarnya sebagian besar solusi yang sama dengan "Perl, 58".

Mathematica

Terinspirasi oleh solusi Ilmari Karonen. Grup simetri rotasi kubus adalah isomorfik ke S ₄ .

Cube, 51 byte

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

Mengambil daftar 1s dan -1s sebagai input.

Cobalah online!

Dodecahedron, 55 byte

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

Mengambil daftar 1s dan -1s sebagai input.

Cobalah online!

C (gcc) , 118 116 107 105 byte

-2 bytes berkat ceilingcat

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;}

Cobalah online!

Misalkan kita memberi kubus koordinat berikut:

            (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)

Jika kita mulai dari sudut D, maka pindah ke C atau H dapat dianggap sebagai memutar kubus di sekitar kita. Bergerak ke kanan berarti berputar berlawanan arah jarum jam di sekitar sumbu Z, dan bergerak ke kiri berarti berputar searah jarum jam di sekitar sumbu X. Hanya ini dua rotasi yang perlu kita perhatikan. Karena setiap putaran tepat 90 derajat, kita dapat membayangkan sudut-sudut "meluncur" di sepanjang tepinya. Untuk bergerak ke kanan, ini berarti A -> B, B -> C, C -> D, D -> A dengan sisi lain melakukan E -> F dll. Untuk bergerak ke kiri, kita malah mendapatkan A -> E, E - > H dll.

Karena setiap sudut hanya meluncur di sepanjang tepi, itu berarti hanya satu dimensi dari setiap titik yang berubah untuk setiap rotasi. Ketika B pindah ke C, hanya komponen y yang berubah, dan ketika H pindah ke D, hanya komponen z yang berubah, dan seterusnya. Lebih lanjut, karena koordinat dibatasi pada 0 dan 1, kita dapat menganggap setiap titik sebagai angka biner, dengan bit yang sesuai dibalikkan pada pergerakan.

Kita bisa melihat bahwa untuk gerakan ke kanan, A dan C membalik x mereka, sedangkan D dan B membalik y mereka. Jika kita mengubah perspektif untuk melihat sisi kepala kubus itu, dan mengabaikan komponen z (yang tidak berubah untuk rotasi ini pula) kita mendapatkan:

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

Muncul pola: Untuk titik yang membalik x, x == y, sedangkan yang sebaliknya berlaku untuk titik yang membalik y mereka. Ini berlaku untuk jenis rotasi lain, tetapi dengan z bukannya x.

Dengan kata lain:

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

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

Sekarang kita dapat dengan mudah melewati semua rotasi, dan pada akhirnya melihat apakah D akhir cocok dengan D. awal kita

Menyimpan setiap titik sebagai angka tunggal adalah sesuatu yang diberikan, tetapi dalam C, menugaskan array char jauh lebih kompak daripada array int. Kami berhati-hati untuk memilih karakter yang tiga bit terendahnya cocok dengan 000..111, sehingga memungkinkan untuk mengabaikan sisa bit. Membalik koordinat hanyalah masalah XOR'ing dengan bitmask yang sesuai.

Python - 110, 150

Mengambil daftar bilangan bulat dengan -1untuk belok kiri, 1untuk belok kanan.

Cube, 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

Uji:

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

Dodecahedron, 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

Marbelous 188

Pencurian tanpa malu-malu algoritma Ilmari Karonen yang tidak tahu untuk tujuan memamerkan bahasa baru.

Skrip ini mengharapkan string 0x00 untuk kiri dan 0x01 untuk kanan pada stdin, diikuti oleh 0x0A (baris baru). Ini menghasilkan "0" untuk kasus gagal dan "1" untuk sukses.

......@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!!..//

contoh dijalankan:

# 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

Cobalah online!

Ini menggunakan representasi permutasi

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

di mana kiri dan kanan (0 dan 1) sesuai dengan siklus-4 panjang pada 4 elemen. Kami beralih pada input yang menerapkan permutasi yang ditunjukkan, dan memeriksa apakah hasilnya sama dengan nilai awal.

Kami mulai a,b,c,dsebagai daftar empat elemen 0,1,2,3. Kami memadatkannya menjadi nomor basis-4 tunggal n=abcd, dengan nilai awal yang n=27sesuai dengan 0123dalam basis 4. Kami instantiate masing-masing permutasi secara hitung n.

Karena kedua hasil dimulai dengan d, kita bisa lakukan n%4untuk mengekstraksi d, kemudian n%4*64memindahkannya ke posisi yang tepat d___. Digit lainnya adalah abc, diekstraksi sebagain/4 . Kita perlu memasukkannya ke dalam tiga nilai tempat yang lebih rendah.

Untuk arah x=0, kita masukkan abcapa adanya, dan untuk x=1, kita putar sebagai cab. Rotasi dapat dicapai sebagai *16%63, yang mengambil abcuntuk abc00untuk cab. ( %63Akan salah a==b==c==3, tetapi nilai ini tidak mungkin.) Karena hanya melakukan %63adalah no-op, ekspresi tergantung arah *16**x%63memberi abcatau cabsesuai kebutuhan.

Python 2 , 55 byte

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

Cobalah online!

Haskell, 104 103 99 97 96/ 67 64 chars

Saya merasa setara dengan kanan / kiri akan menjadi datatype Direction seperti:

Direction = R | L

jadi saya berasumsi dalam jawaban saya bahwa mereka tersedia.
edit: sebenarnya menyadari bahwa booleans akan mengarah pada kode yang lebih pendek. Benar mewakili belok kiri, dan Salah mewakili belok kanan (meskipun, secara teknis, kode akan bekerja sama jika dibalik; simetris)

96 karakter:

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 adalah fungsi yang diberi daftar Direction akan mengembalikan cuaca semut tidak kembali ke tempatnya.

penjelasan representasi posisi: posisi semut dikodekan sebagai tiga tupel bilangan bulat. bilangan bulat pertama mewakili titik yang menuju semut. bit pertama mewakili jika vertex berada di bagian atas / bawah, yang kedua adalah bagian kiri / kanan, dan yang ketiga adalah bagian belakang / depan. ini dilakukan agar pemindahan dari titik ke titik tetangga dapat dilakukan dengan membalik sedikit.

bilangan bulat kedua adalah jumlah yang akan diubah verteks semut jika ia pergi ke kiri. misalnya, jika semut berada di vertex 3, dan bilangan bulat kedua adalah 4, daripada setelah belok kiri verteks akan menjadi 7. perhatikan ini akan selalu menjadi kekuatan 2, karena tepat satu bit dibalik dengan menggerakkan satu titik.

bilangan bulat ketiga adalah sama, tetapi untuk berjalan dengan benar; saya tahu ini bisa dihitung oleh dua yang pertama, tetapi saya tidak tahu caranya. jika Anda punya ide, tolong beritahu saya.

sesuatu yang perlu diperhatikan adalah ketika berbelok ke kiri, bilangan bulat ketiga akan tetap sama, dan yang kedua akan menjadi yang antara 1 2 dan 4 yang bukan bilangan bulat kedua atau ketiga, yang kebetulan sama dengan 7 - bilangan bulat kedua - bilangan bulat ketiga.

saya memilih cara ini untuk mewakili posisi karena (seperti yang baru saja disebutkan dalam paragraf sebelumnya) itu sepele untuk menghitung posisi berikutnya.

penjelasan fungsi:

fungsi (%) adalah fungsi yang mengambil titik saat ini dan jumlah untuk mengubahnya, dan mengubahnya. sampai ke bit yang akan berubah dan membaliknya (dengan cara yang sangat numerik).

fungsi m adalah fungsi yang mengambil posisi semut, dan arah, dan mengembalikan posisi baru dengan menggunakan catatan yang kita catat sebelumnya.

maka fungsi m digabungkan menggunakan foldl (yang semacam seperti reducedi javascript, tetapi sedikit lebih ekspresif) untuk membuat fungsi g, jawaban untuk pertanyaan ini.

Haskell, 64 karakter

terinspirasi oleh jawaban @ alphaalpha, ini dia versi porting ke 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]

sunting: Saya sekarang merasa sangat bodoh karena jawaban lmari Karonen. mungkin saya akan port jawaban untuk haskell. suntingan lain: tidak merasa sebodoh jawabannya adalah salah
edit: beralih dari menggunakan tuple menjadi menggunakan daftar sebagai Ordcontohnya dan [ ... ]gula sintaksis membuatnya lebih pendek

Haskell , 53 byte

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

Cobalah online!

Logika yang sama dengan jawaban Python saya , bahkan berpikir moddan divlebih panjang untuk menulis.

Haskell , 58 byte

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

Cobalah online!

APL (Dyalog Unicode) , 22 byte ( Adám's SBCS )

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

Cobalah online!

H.Piz menyarankan bahwa membalikkan langkah-langkah tidak membuat perbedaan, dan yang menghasilkan -2 byte.

Yah, ini memalukan, karena itu dimaksudkan untuk menjadi jauh lebih pendek daripada GolfScript. Setidaknya saya mencoba.

Fungsi ini dinamai f, dan, dalam kasus uji, 1mewakili belok kiri (boolean true) dan 0mewakili belok kanan (boolean false). ⍬mewakili daftar kosong.

APL (Dyalog) , 21 byte

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

Cobalah online! (Menggunakan lingkungan pengujian dari jawaban Erik the Outgolfer )

Saya ambil kiri dan kanan sebagai 1dan 2. Ini menggunakan permutasi berikut abcd:

1 : bcda
2 : cdba

Saya menerapkan permutasi yang sesuai dengan 1dan 2untuk ⍳4 : 1 2 3 4, dan memeriksa apakah itu tidak berubah

Bash , 71 65 byte

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

Cobalah online!

Seperti banyak jawaban sebelumnya, gunakan representasi dari kelompok rotasi kubus yang dihasilkan oleh 1234-> 4123 dan 1234-> 4312. Menggunakan angka alih-alih huruf sehingga saya bisa menggunakan operator ternary dengan ekspansi aritmatika. Diharapkan inputnya sebagai 0 dan 1 dipisahkan oleh spasi, dan output melalui kode keluar.

6 byte disimpan berkat komentar @ manatwork!

brainfuck , 119 byte, 137 byte

Menggunakan fakta bahwa grup rotasi kubus adalah isomorfik $S_4$. Brainfuck tidak memiliki fungsi sama sekali, dinamai atau tidak, jadi ini adalah program lengkap yang mengambil input melalui STDIN dan output ke STDOUT. (Jika Anda bersikeras pada variabel, berpura-pura nilai sel program berakhir adalah variabel.)

Cube, 119 byte

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

Cobalah online!

++++>+++>++>+    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

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

Cobalah online!

Satu-satunya perbedaan antara kedua program adalah pengaturan dan permutasi. Permutasi kiri yang digunakan di sini adalah DCAEB, yang tampaknya merupakan konjugasi golf yang tersedia.

Jelly , 14 byte

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

Cobalah online!

1= belok kiri, 0= belok kanan. Berdasarkan solusi Dyalog saya.

Sayangnya, Jelly tidak memiliki fungsi bernama. Jika saya tidak dapat menggunakan input implisit dan perlu menganggapnya dalam variabel, versi yang sama panjang ini akan melakukan:

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

Diasumsikan input ada dalam register (© / ®).

Perl - 120, 214

Mengambil array (daftar) boolean.

Cube (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}

Dodecahedron (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)}