Bir karınca bir tel kafes küpünün kenarları (yüzleri değil) boyunca yürür. Karşılaştığı her köşe, iki yeni kenarın daldığı bir çatalla ortaya çıkıyor. Karınca hangi yöne döneceğini seçer - leftveya right. Bu yön, tepe noktasına bakan ve küpün dışındaki karıncaya göredir. Amacınız , karıncanın aldığı left/ rightseçimler sırasından, başladığının aynı pozisyonda bitip bitmediğini belirlemektir.

Örneğin, karınca dört kez sola dönerse ( left left left left), saat yönünün tersine bir kare boyunca dolanır ve başladığı yerde biter. Ancak, giderse left left left left right, küpte farklı bir noktada sona erecek. Ayrıca, eğer giderse left right right right left, başlangıç ​​kenarında biter ancak aynı pozisyonda sayılmayan zıt tepe noktasına bakar.

Karınca yolu, başladığı kenar da dahil olmak üzere kenarları tekrarlayabilir, ancak önemli olan bütün dizilimden sonra nerede bittiğidir.

Karınca sıralarına giren ve karınca sıradan sonra başlangıç ​​pozisyonuna gelip gelmediğini gösteren adlandırılmış bir fonksiyon yazın . Bir değişkene adlandırılmamış bir işlev atamak, onu adlandırılmış bir işlev yapmak için yeterlidir.

(Düzenleme: Diliniz adlandırılmış bir işlev yapamıyorsa, işlevi yerine STDIN / printing veya yığın yoluyla giriş ve çıkışlar uygulayabilir. Bu mümkün değilse, giriş ve çıkışın kaydedildiği bir pasajı yapın. değişkenler.)

Giriş

Dizisi left/ rightuzunluk kararlarına 0karşı 31seçtiğiniz bir biçimde temsil dahil,. Bu bir harf dizisi R/ L, bir sayı listesi 1/ -1veya bir Boole dizisi olabilir. Sevimsiz hiçbir şey onları kodunuz için yararlı yöntem adları veya dizeleri olması gibi bir şey.

Lütfen aşağıdaki test senaryolarından farklı ise, test senaryolarını formatınıza gönderin.

Çıktı

True/ False, 0/ 1veya sizin dilinizdeki analogları.

Kazanan kriterler

En az bayt kazanır. Unutma, adlandırılmış bir işlev vermen gerekir. İşlevin dışında kodunuz olabilir, ancak bu baytlar da sayılır. Birden çok kez aranıyorsa, işleviniz doğru şekilde davranmalıdır.

Test durumları

True servis talepleri (satır başına bir tane, ikincisi boş bir listedir):

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 durumlar (satır başına bir):

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

İşte L's R' ve s ile aynı test vakaları .

True durumlar:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False durumlar:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

Ekstra kredi mücadelesi

Aynı şey, ama bir küp yerine bir on iki parmaklı ile . Fikirler için Wumpus Avını görün .

GolfScript, 24 karakter (yalnızca işlev gövdesi için 19)

Matematik FTW!

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

Bu çözümü çevrimiçi olarak test edin.

Bu işlev bir ikili dizi girişi olarak alır (sol için 0, sağ için 1) ve doğru için 1 ve yanlış için 0 döndürür.

Kavramsal olarak, küpü döndürerek çalışır, böylelikle karınca her zaman aynı pozisyon ve oryantasyonu korur ve küpün sonunda başladığı yönün sonunda bitip bitmediğini kontrol eder.

Özellikle, sol ve sağ dönüşleri üç boyutlu iki doğrusal harita olarak gösterebiliriz; burada sol dönüş, x ekseni etrafında 90 ° dönüşe karşılık gelir , yani harita ( x , y , z ) → ( x , z , - y ) ve sağa dönüş, y ekseni etrafında 90 ° dönüşe karşılık gelir , yani harita ( x , y , z ) → ( z , y , - x ).

Fonksiyonun başında, sadece farklı pozitif değerleri içeren üç elementli bir vektör oluşturduk (1, 2, 3), buna dönme haritalarının sırasını uyguladık ve elde edilen vektörün öncekine eşit olup olmadığını kontrol ettik.

(Aslında, birkaç karakteri kurtarmak için, koordinatları, ilk vektör (0, 1, 2) ve haritalar ( x , y , z ) → ( x , z , −1− y ) olacak şekilde dönüştürürüm. ve ( x , y , z ) → ( z , y , −1− x ), ancak sonuç aynıdır.)

Ps. Bu çözümün orijinal versiyonunda hatayı tespit ettiğim için gururlu haskeller'e teşekkürler .

Perl, 58 karakter

Yorumlarda istendiği gibi, işte Perl ile gösterilen aynı çözüm. (Bu sürüm aslında dönüştürülmemiş koordinatları kullanır, çünkü dönüşüm Perl'de hiç karakter kaydetmez.)

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

Bu çözümü çevrimiçi olarak test edin.

Bonus: Dodecahedron'daki Karınca (GolfScript, 26 karakter)

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

Bu çözümü çevrimiçi olarak test edin.

Yukarıdaki küp üzerinde karınca işlevi gibi, bu işlev de bir ikili dizi girişi olarak alır (sol için 0, sağ için 1) ve karınca başlangıçta olduğu gibi aynı konumda ve oryantasyonda bitiyorsa 1 değerini döndürür veya 0 aksi takdirde.

Bu çözüm, yukarıdaki küp çözümünden biraz daha fazla soyut gösterimi kullanır. Spesifik olarak, bu gerçeğinden yararlanmaktadır dodecahedronun döner simetri grubu izomorf alternatif grubu bir ₅ yani beş elemanlarının da permütasyon grubu. Bu nedenle, dodecahedronun her bir olası dönüşü (kenarları kenarlara ve köşeleri köşelere eşleyen) , karşılık gelen permütasyonların sırayla uygulanmasına karşılık gelen ardışık dönüşlerle, beş elemanlı bir dizinin geçirgenliği olarak benzersiz şekilde temsil edilebilir .

Böylece, tüm yapmanız gereken iki permütasyon bulmak L ve R sol ve sağ rotasyonlar temsil edebilir. Spesifik olarak, bu permütasyon 5-döngüleri olması gerekir (yani orijinal durumuna olanağına beş kez döner tatbik eder), bunların (yani her bir diğer yetkileri olmamalıdır R ≠ L ⁿ herhangi n ), ve ilişkiyi tatmin etmesi gerekir ( LR ) ⁵ = (1), burada (1) kimlik müsaadesini belirtir. (Aslında, bu kriter yolun LRLRLRLRLRorijinal konumuna geri dönmesi gerektiğini belirtir .)

L permütasyonunun sola doğru basit bir varil kayması olarak sabitlenmesi , yani haritalama ( a , b , c , d , e ) → ( b , c , d , e , a ), çünkü sadece iki kere GolfScript'te uygulanabilir. chars ( (+), R geçirgenliği için beş olası seçenek olduğunu görüyoruz . Bunların dışında haritalamayı seçtim ( a , b , c , d , e ) → ( c , e , d ,b , a ) Nispeten kompakt bir GolfScript uygulamasına sahip olduğu için. (Aslında olan elemanları serpiştirilmesi, ilk olarak uygulamak 2*2%(elde edilmesi için bir , c , e , b , d daha sonra, son iki elemanları trampa) [~\]ve son olarak da tatbik L taşımak koşulsuz permütasyon bir uç için).

Yukarıdaki çevrimiçi demo bağlantısı, aşağıdakiler gibi kökene geri dönen bir Dodecahedron'daki geçerli yolların bazı test durumlarını içerir:

           # 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

1 ve -1 listesini alır. 3B dönüşlere göre: Bir dizi döndürme uygulandıktan sonra, noktanın (3,2,1) aynı konumda olup olmadığını kontrol eder. 1 ve -1'e karşılık gelen iki olası dönüş vardır. Her biri iki koordinata izin vererek ve bunlardan birinin işaretini değiştirerek yapılır. Değişecek koordinatların ve izin verilecek işaretlerin kesin olması önemli değildir.

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

EDIT: Bu aslında "Perl, 58" ile aynı çözümdür.

Mathematica

Ilmari Karonen'in çözümünden ilham aldı. Bir küpün dönme simetri grubu S'ye izomorfiktir ₄ .

Küp, 51 bayt

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

Bir listesini alır 1-1Giriş olarak s ve s .

Çevrimiçi deneyin!

Dodecahedron, 55 bayt

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

1S listesini alır ve-1Giriş olarak s .

Çevrimiçi deneyin!

C (gcc) , 118 116 107 105 bayt

Ceilingcat sayesinde -2 bayt

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

Çevrimiçi deneyin!

Diyelim ki küpü aşağıdaki koordinatlara verdik:

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

D köşesinden başlarsak, o zaman C veya H'ye hareket etmek, küpü etrafımıza döndürmek olarak düşünülebilir. Sağa hareket etmek, Z ekseni etrafında saatin tersi yönde döndürmek anlamına gelir ve sola hareket etmek, X ekseni etrafında saat yönünde döndürmek anlamına gelir. Dikkat etmemiz gereken sadece iki dönüş bunlar. Her dönüş tam olarak 90 derece olduğundan, köşelerin kenarlar boyunca "kaydığını" hayal edebiliriz. Sağa ilerlemek için, bu A -> B, B -> C, C -> D, D -> A, diğer tarafın E -> F vb. Yaptıkları anlamına gelir. > H vb.

Her köşe yalnızca bir kenar boyunca kaydığından, bu, her bir noktanın boyutlarından yalnızca birinin her bir dönüş için değiştiği anlamına gelir. B, C'ye geçtiğinde, sadece y bileşeni değişir ve H, D'ye geçtiğinde, sadece z bileşeni değişir, vb. Ayrıca, koordinatlar 0 ve 1 ile sınırlandırıldığından, her noktayı hareket üzerine uygun bit çevrilmiş bir ikili sayı olarak düşünebiliriz.

Sağa doğru bir hareket için A ve C'nin x'lerini, D ve B ise y'lerini çevirdiğini görebiliriz. Küp kafasının bu tarafına bakmak için perspektifi değiştirirsek ve z bileşenini (bu rotasyon için herhangi bir şekilde değişmeyen) görmezden gelirsek:

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

Bir desen ortaya çıkıyor: x, x == y değerlerini çeviren noktalar için, tersi y'lerini çeviren noktalar için geçerlidir. Bu, diğer döndürme türlerinde geçerlidir, ancak x yerine z kullanılır.

Diğer bir deyişle:

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

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

Şimdi tüm rotasyonları kolayca geçebiliriz ve sonunda son D'nin ilk D ile uyuşup uyuşmadığını görürüz.

Her noktanın tek bir sayı olarak saklanması bir sayıdır, fakat C'de bir char dizisi atamak bir int dizisinden çok daha küçüktür. Alt bitleri 000..111 ile eşleşen karakterleri seçmeye özen göstererek bitlerin geri kalanını görmezden gelebilmeyi mümkün kıldık. Koordinatları çevirmek uygun Xmas'la uygun bit maskesiyle ilgili.

Python - 110, 150

-1Sola 1dönüş, sağa dönüş için bir tamsayılar listesine girer .

Küp, 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

Ölçek:

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

Mermer 188

Ilmari Karonen'in algoritmasını yeni bir dil göstermek amacıyla utanmaz hırsızlık .

Bu betiğin solunda 0x00, stdin'de sağ 0x01 dizisi ve ardından 0x0A (newline) beklenir. Başarısız bir durum için "0" ve başarılı olması için "1" yazar.

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

örnek çalışma:

# 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 bayt

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

Çevrimiçi deneyin!

Bu permütasyon gösterimini kullanır

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

sol ve sağ (0 ve 1) 4 element üzerinde uzunluk-4 çevrime karşılık gelir. Belirtilen permütasyonu uygulayan girdi üzerinde tekrar eder ve sonucun başlangıç ​​değerine eşit olup olmadığını kontrol ederiz.

a,b,c,dDört element listesi olarak başlıyoruz 0,1,2,3. Bunları tek bir taban-4 numarasına sıkıştırdık n=abcd, başlangıç ​​değeri temel 4'e n=27karşılık geliyor 0123. Her bir aritmetik aritmetik olarakn .

Her iki sonuç ile başlamak yana d, yapabileceğimiz n%4ekstresine dsonra, n%4*64sağ pozisyona taşımak için d___. Diğer basamak vardır abcolarak ekstren/4 . Onları üç değerin altına yerleştirmeliyiz.

Yönü için x=0, biz eklemek abcolduğu gibi ve için x=1, biz bunları döndürmek cab. Açıklanan dönüş elde edilebilir *16%63alır, abciçin abc00için cab. (Bu %63yanlış gider a==b==c==3, ancak bu değer mümkün değildir.) Sadece %63işlem yapılmaması nedeniyle, yöne bağlı ifade *16**x%63verir abcya cabda gerektiği gibi.

Python 2,55 bayt

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

Çevrimiçi deneyin!

Haskell, 104 103 99 97 96/ 67 64 karakter

Sağ / sol eşdeğeri gibi bir veri türü Yön olacağını düşünüyorum:

Direction = R | L

Ben de cevabımda onların uygun olduğunu varsaydım.
düzenleme: aslında booleanların daha kısa koda yol açacağını fark etti. Doğru, sola dönüşü temsil eder ve False, sağa dönüşü temsil eder (teknik olarak kod ters çevrilmişse aynı şekilde çalışır; simetriktir)

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, Yön listesi verilen karınca yerine geri dönmediyse havayı geri getirecek bir fonksiyondur.

Pozisyon gösteriminin açıklanması: Karınca pozisyonu, üç tamsayı dizisi olarak kodlanır. ilk tamsayı, karıncaların gittiği tepe noktasını temsil eder. ilk bit, tepe noktanın yukarı / aşağı yarıda olup olmadığını, ikincisi sol / sağ yarıyı ve üçüncüsü arka / ön yarıyı temsil eder. Bu, bir tepe noktasından komşu bir tepe noktasına hareket etmek için bir bit döndürülerek yapılabilir.

ikinci tamsayı, eğer karınca sola giderse değişecek olan miktardır. Örneğin, eğer karınca tepe 3'te ise ve ikinci tamsayı 4 ise, sola döndükten sonra tepe noktası 7 olacaktır. Bunun her zaman 2'nin bir gücü olacağına dikkat edin, çünkü tam olarak bir bit bir köşeyi hareket ettirerek çevrilir.

üçüncü tamsayı aynıdır, fakat doğru gitmek için; Bunun ilk ikisi tarafından hesaplanabileceğini biliyorum, ama nasıl yapacağımı bilmiyorum. Bir fikrin varsa, lütfen bana söyle.

Unutulmaması gereken bir şey, sola dönülürken, üçüncü tamsayı aynı kalacak ve ikincisi, 1 ile 4 arasında olan ikinci tamsayı ya da üçüncü olmayan, 1 2 ile 4 arasında bir olacaktı. ikinci tamsayı - üçüncü tamsayı.

Bu pozisyonu temsil etmeyi seçtim çünkü (önceki paragrafta belirtildiği gibi) bir sonraki pozisyonu hesaplamak çok önemliydi.

fonksiyonların açıklaması:

(%) işlevi geçerli tepe noktasını alan ve onu değiştirecek tutarı değiştiren ve değiştiren işlevdir. değişecek olan bite gider ve onu çevirir (çok sayısal bir şekilde).

m işlevi, karınca konumunu ve yönünü alan ve daha önce not ettiğimiz notu kullanarak yeni konumu döndüren bir işlevdir.

Daha sonra m işlevi reduceg işlevini, bu sorunun cevabını oluşturmak için foldl ( javascript'teki gibi fakat biraz daha etkileyici olan) kullanılarak birleştirilir.

Haskell, 64 karakter

@ alphaalpha'nın cevabından ilham alan, işte haskell'e aktarılan versiyon:

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]

Düzenleme: Ben şimdi Karonen'in cevabı nedeniyle inanılmaz derecede aptal hissediyorum. belki cevabını Haskell'e iletirim. Başka düzenleme: onun cevabı kadar aptalca bir duygu değil edilmektedir yanlış olduğunu
düzenleme: kendi olarak listelerini kullanarak aslında dizilerini kullanarak anahtarlamalı Ordörneği ve [ ... ]sözdizimsel şeker daha kısa hale getirir

Haskell , 53 bayt

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

Çevrimiçi deneyin!

Python cevabımla aynı mantık , hatta düşünce modvediv yazmak için daha uzun.

Haskell , 58 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

H.PWiz , adımları tersine çevirmenin bir fark ve bunun -2 baytla sonuçlandığını öne sürdü.

Golf ufaktan daha kısa olması amaçlandığından, bu utanç verici. En azından denedim.

İşlev adlandırılır fve test durumlarında 1sola dönüş (boolean true) ve 0sağa dönüş (boolean false) gösterir. ⍬boş listeyi temsil eder.

APL (Dyalog) , 21 bayt

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

Çevrimiçi deneyin! (Erik Outgolfer en dan test ortamı kullanarak cevap )

Sola ve sağa 1ve sola alıyorum 2. Bu, aşağıdaki izinleri kullanır abcd:

1 : bcda
2 : cdba

Ben permütasyon tekabül uygulamak 1ve 2karşı ⍳4 : 1 2 3 4değişmeden ise, ve kontrol

Bash , 71 65 bayt

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

Çevrimiçi deneyin!

Daha önceki birçok cevap gibi, 1234-> 4123 ve 1234-> 4312 tarafından üretilen küpün dönme grubunun bir gösterimini kullanır. Harfler yerine sayıları kullanır, böylece aritmetik genişlemeli üçlü bir operatör kullanabilirim. Girdiyi 0 ve 1 olarak boşlukla ayrılmış olarak bekler ve çıkış kodu ile çıkar.

@ Manatwork adlı kullanıcının yorumu sayesinde 6 bayt kurtarıldı!

brainfuck , 119 bayt, 137 bayt

Küpün rotasyon grubunun izomorfik olduğu gerçeğini kullanır $S_4$. Brainfuck'un hiçbir işlevi yoktur, adlandırılmış veya başka bir işlevi yoktur, bu nedenle bu, STDIN üzerinden girdi alan ve STDOUT'a çıkan tam bir programdır. (Bir değişkende ısrar ediyorsanız, programın sona erdiği hücrenin değerini bir değişken gibi yapın.)

Küp, 119 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

İki program arasındaki tek fark kurulum ve permütasyonlardır. Burada kullanılan sol permütasyon DCAEB, mevcut olan en güçlü konjugat gibi görünüyordu.

Jöle , 14 bayt

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

Çevrimiçi deneyin!

1 = sola dönüş, 0 = sağa dönüş. Dyalog çözümüme göre.

Ne yazık ki, Jelly adlandırılmış işlevlere sahip değil. Örtülü bir girdi kullanamıyorsam ve bunun değişkende olduğunu varsaymam gerekiyorsa, bu aynı uzunluktaki sürüm aşağıdakileri yapar:

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

Girişin kayıt defterinde olduğunu varsayar (© / ®).

Perl - 120, 214

Bir boole dizisini (listesini) alır.

Küp (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)}