Eine Ameise läuft an den Rändern (nicht an den Flächen) eines Drahtgitterwürfels entlang. Jeder Scheitelpunkt, auf den er trifft, präsentiert ihm eine Gabelung, von der zwei neue Kanten abzweigen. Die Ameise entscheidet, in welche Richtung sie sich dreht - leftoder right. Diese Richtungen beziehen sich auf die Ameise, die dem Scheitelpunkt zugewandt ist und sich außerhalb des Würfels befindet. Ihr Ziel ist es , aus der Folge von bestimmen left/ rightEntscheidungen die Ameise nahm, wäre es an der gleichen Stelle endet , dass es angefangen hat .

Wenn sich die Ameise beispielsweise viermal nach links dreht ( left left left left), hat sie ein Quadrat gegen den Uhrzeigersinn durchquert und endet an derselben Stelle, an der sie begonnen hat. Aber wenn es geht left left left left right, wird es an einer anderen Stelle auf dem Würfel enden. Wenn es geht left right right right left, endet es an seiner Startkante, zeigt aber zum gegenüberliegenden Scheitelpunkt, der nicht zur selben Position zählt.

Der Pfad der Ameise wiederholt möglicherweise Kanten, einschließlich der Kante, an der sie begonnen hat. Entscheidend ist jedoch, wo sie nach der gesamten Sequenz endet.

Schreiben Sie eine benannte Funktion , die die Abfolge der Umdrehungen der Ameise aufnimmt und ausgibt, ob die Ameise nach der Abfolge wieder an ihrer Startposition ist. Das Zuweisen einer unbenannten Funktion zu einer Variablen reicht aus, um sie zu einer benannten Funktion zu machen.

(Bearbeiten: Wenn Ihre Sprache keine benannte Funktion erstellen kann, kann sie stattdessen die Funktion mit Ein- und Ausgängen über STDIN / printing oder den Stapel implementieren. Wenn dies nicht möglich ist, erstellen Sie ein Snippet, in dem die Ein- und Ausgaben gespeichert sind Variablen.)

Eingang

Eine Folge von left/ rightEntscheidungen von Länge 0bis 31einschließlich, dargestellt in einem Format Ihrer Wahl. Dies kann eine Folge von Buchstaben R/ L, eine Liste von Zahlen 1/ -1oder ein Array von Booleschen Werten sein. Nichts ist kitschiger als Methodennamen oder Zeichenfolgen, die für Ihren Code nützlich sind.

Bitte posten Sie die Testfälle in Ihrem Format, wenn sie sich von den folgenden Testfällen unterscheiden.

Ausgabe

True/ False, 0/ 1oder die Analoga in Ihrer Sprache.

Gewinnkriterien

Wenigste Bytes gewinnt. Denken Sie daran, dass Sie eine benannte Funktion angeben müssen. Sie können Code außerhalb der Funktion haben, aber diese Bytes zählen auch. Ihre Funktion sollte sich korrekt verhalten, wenn sie mehrmals aufgerufen wird.

Testfälle

True Fälle (einer pro Zeile, der zweite ist eine leere Liste):

1 1 1 1

-1 -1 -1 -1
1 -1 1 -1 1 -1
1 1 -1 -1 1 1 -1 -1
-1 1 1 -1 -1 1 1 -1
1 1 1 -1 -1 -1 -1 1
1 -1 -1 1 -1 -1
1 1 1 1 -1 -1 -1 -1 1 -1 -1 1 -1 -1
-1 -1 -1 1 -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 Fälle (einer pro Zeile):

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

Hier sind die gleichen Testfälle mit L's und R' s.

True Fälle:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False Fälle:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

Zusätzliche Kreditherausforderung

Das Gleiche, aber mit einem Dodekaeder und nicht mit einem Würfel. Ideen finden Sie unter Jagd auf den Wumpus .

GolfScript, 24 Zeichen (19 nur für Funktionskörper)

Mathe FTW!

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

Testen Sie diese Lösung online.

Diese Funktion nimmt ein binäres Array als Eingabe (0 für links, 1 für rechts) und gibt 1 für wahr und 0 für falsch zurück.

Konzeptionell funktioniert dies, indem der Würfel so gedreht wird, dass die Ameise immer die gleiche Position und Ausrichtung beibehält und überprüft, ob der Würfel letztendlich die gleiche Ausrichtung hat, in der er begonnen hat.

Insbesondere können wir die Links- und Rechtskurven als zwei lineare Karten in drei Dimensionen darstellen, wobei eine Linkskurve einer 90 ° -Drehung um die x- Achse entspricht, dh die Karte ( x , y , z ) → ( x , z , - y ) und eine Rechtsdrehung entspricht einer 90 ° -Drehung um die y- Achse, dh der Karte ( x , y , z ) → ( z , y , - x ).

Zu Beginn der Funktion richten wir einfach einen Vektor mit drei Elementen ein, der die eindeutigen positiven Werte (1, 2, 3) enthält, wenden die Folge von Rotationskarten darauf an und prüfen, ob der resultierende Vektor dem anfänglichen entspricht.

(Um ein paar Zeichen zu sparen, transformiere ich die Koordinaten tatsächlich so, dass der Anfangsvektor (0, 1, 2) ist und die Karten ( x , y , z ) → ( x , z , −1− y ) sind. und ( x , y , z ) → ( z , y , −1− x ), aber das Endergebnis ist dasselbe.)

Ps. Vielen Dank an den stolzen Haskeller, der den Fehler in der Originalversion dieser Lösung entdeckt hat.

Perl, 58 Zeichen

Wie in den Kommentaren gefordert, ist hier dieselbe Lösung für Perl portiert. (Diese Version verwendet tatsächlich die nicht transformierten Koordinaten, da die Transformation in Perl keine Zeichen speichert.)

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

Testen Sie diese Lösung online.

Bonus: Ameise auf einem Dodekaeder (GolfScript, 26 Zeichen)

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

Testen Sie diese Lösung online.

Wie die Ant-on-a-Cube-Funktion oben nimmt diese Funktion ein binäres Array als Eingabe (0 für links, 1 für rechts) und gibt 1 zurück, wenn die Ameise an derselben Position und Ausrichtung endet, in der sie begonnen hat, oder 0 Andernfalls.

Diese Lösung verwendet eine etwas abstraktere Darstellung als die obige Cube-Lösung. Insbesondere wird die Tatsache ausgenutzt , dass die Rotationssymmetriegruppe des Dodekaeders zu der alternierenden Gruppe A ₅ , dh der Gruppe von geraden Permutationen von fünf Elementen, isomorph ist . Somit kann jede mögliche Drehung des Dodekaeders (die Kanten auf Kanten und Scheitelpunkte auf Scheitelpunkte abbildet) eindeutig als Permutation eines Fünf-Elemente-Arrays dargestellt werden, wobei aufeinanderfolgende Rotationen dem Anwenden der entsprechenden Permutationen in Folge entsprechen.

Wir müssen also nur zwei Permutationen L und R finden, die die linke und rechte Rotation darstellen können. Insbesondere müssen diese Permutationen 5-Zyklen sein (so dass ihre fünfmalige Anwendung zum ursprünglichen Zustand zurückkehrt), sie dürfen keine Potenzen voneinander sein (dh R ≠ L ⁿ für ein beliebiges n ) und sie müssen die Beziehung erfüllen ( LR ) ⁵ = (1), wobei (1) die Identitätspermutation bezeichnet. (In der Tat gibt dieses Kriterium an, dass der Pfad LRLRLRLRLRan die ursprüngliche Position zurückkehren muss.)

Fixierung der L- Permutation als einfache Verschiebung des Laufs nach links, dh Zuordnung ( a , b , c , d , e ) → ( b , c , d , e , a ), da sie in GolfScript in nur zwei Schritten implementiert werden kann chars ( (+) gibt es fünf Möglichkeiten für die R- Permutation. Von diesen wählte ich das Mapping ( a , b , c , d , e ) → ( c , e , d ,b , a ), da es auch eine relativ kompakte GolfScript-Implementierung hat. (Tatsächlich implementiere ich es, indem ich zuerst die Elemente verschachtele 2*2%, um ( a , c , e , b , d ) zu erhalten, dann die letzten beiden Elemente mit vertausche [~\]und schließlich die L- Permutation bedingungslos anwende, um a an das Ende zu verschieben.)

Der obige Online-Demo-Link enthält einige Testfälle gültiger Pfade auf einem Dodekaeder, die zum Ursprung zurückkehren, wie z.

           # 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

Nimmt eine Liste von 1 und -1. Basierend auf 3D-Rotationen: Überprüft, ob der Punkt (3,2,1) nach einer Reihe von Rotationen an derselben Position endet. Es gibt zwei mögliche Rotationen, die 1 und -1 entsprechen. Jedes wird durchgeführt, indem zwei Koordinaten permutiert und das Vorzeichen einer von ihnen geändert werden. Die genauen zu ändernden Koordinaten und das zu permutierende Vorzeichen sind nicht wichtig.

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

EDIT: das ist eigentlich meist die selbe Lösung wie "Perl, 58".

Mathematica

Inspiriert von der Lösung von Ilmari Karonen. Die Rotationssymmetriegruppe eines Würfels ist zu S ₄ isomorph .

Würfel, 51 Bytes

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

Nimmt eine Liste von 1s und -1s als Eingabe.

Probieren Sie es online!

Dodekaeder, 55 Bytes

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

Nimmt eine Liste von 1s und -1s als Eingabe.

Probieren Sie es online!

C (GCC) , 118 116 107 105 Bytes

-2 Bytes dank 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;}

Probieren Sie es online!

Angenommen, wir haben dem Würfel die folgenden Koordinaten gegeben:

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

Wenn wir in Ecke D beginnen, können wir uns vorstellen, den Würfel stattdessen um uns herum zu drehen, wenn wir zu C oder H gehen. Nach rechts zu bewegen würde bedeuten, sich gegen den Uhrzeigersinn um die Z-Achse zu drehen, und nach links zu bewegen würde bedeuten, sich im Uhrzeigersinn um die X-Achse zu drehen. Dies sind die einzigen zwei Umdrehungen, um die wir uns kümmern müssen. Da jede Umdrehung genau 90 Grad beträgt, können wir uns vorstellen, dass die Ecken entlang der Kanten "gleiten". Für die Bewegung nach rechts bedeutet dies A -> B, B -> C, C -> D, D -> A, wobei die andere Seite E -> F usw. tut. Für die Bewegung nach links erhalten wir stattdessen A -> E, E - > H usw.

Da jede Ecke nur entlang einer Kante gleitet, ändert sich bei jeder Drehung nur eine der Abmessungen jedes Punkts. Wenn sich B nach C bewegt, ändert sich nur die y-Komponente, und wenn sich H nach D bewegt, ändert sich nur die z-Komponente und so weiter. Da die Koordinaten auf 0 und 1 beschränkt sind, können wir uns jeden Punkt als Binärzahl vorstellen, wobei das entsprechende Bit bei der Bewegung umgedreht wird.

Wir können sehen, dass für eine Bewegung nach rechts A und C ihre x-Zeichen drehen, während D und B ihre y-Zeichen drehen. Wenn wir die Perspektive ändern, um auf diese Seite des Würfelkopfs zu schauen, und die z-Komponente ignorieren (die sich für diese Drehung sowieso nicht ändert), erhalten wir:

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

Es entsteht ein Muster: Für die Punkte, die ihr x spiegeln, gilt x == y, während das Gegenteil für die Punkte gilt, die ihr y spiegeln. Dies gilt für die andere Art der Drehung, jedoch mit z anstelle von x.

Mit anderen Worten:

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

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

Jetzt können wir alle Umdrehungen leicht durchgehen und am Ende sehen, ob das endgültige D mit unserem anfänglichen D übereinstimmt.

Das Speichern jedes Punktes als einzelne Zahl ist eine Selbstverständlichkeit, aber in C ist das Zuweisen eines char-Arrays viel kompakter als ein int-Array. Wir achten darauf, Zeichen auszuwählen, deren untere drei Bits mit 000..111 übereinstimmen, damit der Rest der Bits einfach ignoriert werden kann. Das Umkehren der Koordinaten ist einfach eine Frage der XOR-Verknüpfung mit der entsprechenden Bitmaske.

Python - 110, 150

Nimmt eine Liste von ganzen Zahlen mit -1für links abbiegen, 1für rechts abbiegen.

Würfel, 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

Prüfung:

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

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

Schamloser Diebstahl von Ilmari Karonens Algorithmus, um eine neue Sprache vorzuführen .

Dieses Skript erwartet eine Zeichenfolge von 0x00 für left und 0x01 für right in stdin, gefolgt von 0x0A (newline). Es gibt "0" für einen fehlgeschlagenen Fall und "1" für einen Erfolg aus.

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

Beispiellauf:

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

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

Probieren Sie es online!

Dies verwendet die Permutationsdarstellung

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

wobei links und rechts (0 und 1) der Länge von 4 Zyklen auf 4 Elementen entsprechen. Wir durchlaufen die Eingabe mit der angegebenen Permutation und prüfen, ob das Ergebnis dem Anfangswert entspricht.

Wir beginnen a,b,c,dals Vier-Elemente-Liste 0,1,2,3. Wir verdichten sie zu einer einzigen Zahl zur Basis 4 n=abcd, wobei der Anfangswert der Zahl n=27zur 0123Basis 4 entspricht. Wir instanziieren jede Permutation arithmetisch auf n.

Da beide Ergebnisse mit beginnen d, können wir n%4zunächst extrahieren dund dann n%4*64in die richtige Position bringen d___. Die anderen Ziffern werden abcextrahiert als n/4. Wir müssen sie in die unteren drei Stellenwerte einfügen.

Für die Richtung x=0fügen wir so ein, abcwie sie ist, und für x=1drehen wir sie so cab. Die Drehung kann erreicht werden , wie *16%63, die dauert , abcum abc00zu cab. (Das %63würde schief gehen auf a==b==c==3, aber diese Werte sind nicht möglich) . Da nur das tut , %63ist ein no-op, der richtungsabhängigen Ausdruck *16**x%63gibt abcoder je cabnach Bedarf.

Python 2 , 55 Bytes

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

Probieren Sie es online!

Haskell, 104 103 99 97 96/ 67 64 Zeichen

Ich denke, das Äquivalent von rechts / links wäre ein Datentyp Richtung wie folgt:

Direction = R | L

Also nahm ich in meiner Antwort an, dass sie verfügbar waren.
edit: realisierte tatsächlich, dass Boolean zu kürzerem Code führen würde. True steht für eine Linkskurve und False für eine Rechtskurve (obwohl der Code technisch gesehen genauso funktioniert, wenn er umgedreht wird; er ist symmetrisch)

96 Zeichen:

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 ist eine Funktion, die bei einer Richtungsliste das Wetter zurückgibt, wenn die Ameise nicht an ihren Platz zurückgekehrt ist.

Erklärung der Positionsdarstellung: Die Position der Ameise wird als drei Tupel von ganzen Zahlen codiert. Die erste Ganzzahl stellt den Scheitelpunkt dar, auf den die Ameise zusteuert. Das erste Bit gibt an, ob sich der Scheitelpunkt in der oberen / unteren Hälfte befindet, das zweite in der linken / rechten Hälfte und das dritte in der hinteren / vorderen Hälfte. Dies geschieht so, dass das Verschieben von einem Scheitelpunkt zu einem Nachbarscheitelpunkt durch Umdrehen eines Bits erfolgen kann.

Die zweite Ganzzahl ist der Betrag, um den sich der Scheitelpunkt der Ameise ändern würde, wenn er nach links verschoben würde. Wenn sich die Ameise beispielsweise auf Scheitelpunkt 3 und die zweite Ganzzahl auf 4 befunden hätte, wäre der Scheitelpunkt nach links gleich 7. Beachten Sie, dass dies immer eine Potenz von 2 ist, da genau ein Bit durch Verschieben eines Scheitelpunkts gespiegelt wird.

die dritte ganze Zahl ist die gleiche, nur um richtig zu gehen; Ich weiß, dass dies durch die ersten beiden berechnet werden kann, aber ich weiß nicht, wie. Wenn du eine Idee hast, sag es mir bitte.

Etwas zu beachten ist, dass beim Abbiegen nach links die dritte Ganzzahl gleich bleibt und die zweite zwischen 1 2 und 4 wird, die weder die zweite noch die dritte Ganzzahl ist, was zufällig der 7 entspricht. zweite ganze Zahl - dritte ganze Zahl.

Ich habe mich für diese Art der Darstellung von Positionen entschieden, da es (wie bereits im vorigen Absatz erwähnt) trivial war, die nächste Position zu berechnen.

Erklärung der Funktionen:

Die (%) -Funktion ist die Funktion, die den aktuellen Scheitelpunkt und den Änderungsbetrag verwendet und ändert. es gelangt zu dem Bit, das sich ändern wird, und dreht es um (auf eine sehr numerische Weise).

Die m-Funktion ist eine Funktion, die die Position der Ameise und die Richtung einnimmt und die neue Position unter Verwendung der zuvor notierten Note zurückgibt.

dann wird die m-Funktion mit foldl (ähnlich wie reducebei Javascript, aber etwas aussagekräftiger) kombiniert , um die Funktion g zu erstellen, die Antwort auf diese Frage.

Haskell, 64 Zeichen

Inspiriert von der Antwort von @ alphaalpha ist hier die Version, die auf haskell portiert ist:

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]

edit: Ich fühle mich jetzt unglaublich dumm wegen der Antwort von Lmari Karonen. vielleicht portiere ich seine antwort auf haskell. ein andere edit: das Gefühl nicht so dumm , wie seine Antwort ist falsch war
edit: Einschalten von tatsächlich Tupel unter Verwendung von Listen wie ihre Verwendung OrdInstanz und der [ ... ]syntaktische Zucker macht es kürzer

Haskell , 53 Bytes

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

Probieren Sie es online!

Gleiche Logik wie meine Python-Antwort , auch gedacht modunddiv länger zu schreiben.

Haskell , 58 Bytes

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

Probieren Sie es online!

APL (Dyalog Unicode) , 22 Byte ( Adáms SBCS )

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

Probieren Sie es online!

H.PWiz schlug vor, dass das Umkehren der Schritte keinen Unterschied macht und das zu -2 Bytes führt.

Nun, das ist peinlich, denn es sollte viel kürzer sein als GolfScript. Zumindest habe ich es versucht.

Die Funktion heißt fund 1repräsentiert in den Testfällen eine Linkskurve (Boolean true) und 0eine Rechtskurve (Boolean false). ⍬steht für die leere Liste.

APL (Dyalog) , 21 Bytes

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

Probieren Sie es online! (Unter Verwendung der Testumgebung von Erik the Outgolfer's answer )

Ich nehme links und rechts als 1und 2. Dabei werden die folgenden Permutationen verwendet abcd:

1 : bcda
2 : cdba

Ich beantrage die Permutationen entsprechen 1und 2zu ⍳4 : 1 2 3 4, und prüfen , ob es unverändert ist

Bash , 71 65 Bytes

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

Probieren Sie es online!

Verwendet wie viele frühere Antworten eine Darstellung der Rotationsgruppe des Würfels, die von 1234-> 4123 und 1234-> 4312 generiert wurde. Verwendet Zahlen anstelle von Buchstaben, damit ich einen ternären Operator mit einer arithmetischen Erweiterung verwenden kann. Erwartet die Eingabe als durch Leerzeichen getrennte Nullen und Einsen und gibt sie über den Exit-Code aus.

6 Bytes gespart dank @ manatworks Kommentar!

Gehirnfick , 119 Bytes, 137 Bytes

$S_4$

Würfel, 119 Bytes

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

Probieren Sie es 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

Dodekaeder, 137 Bytes

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

Probieren Sie es online!

Die einzigen Unterschiede zwischen den beiden Programmen sind das Setup und die Permutationen. Die hier verwendete linke Permutation ist die DCAEB, die als das am besten geeignete Konjugat auf dem Markt zu gelten schien.

Jelly , 14 Bytes

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

Probieren Sie es online!

1 = links abbiegen, 0 = rechts abbiegen. Basierend auf meiner Dyalog-Lösung.

Leider hat Jelly keine benannten Funktionen. Wenn ich eine implizite Eingabe nicht verwenden kann und davon ausgehen muss, dass sie sich in einer Variablen befindet, ist diese Version mit der gleichen Länge ausreichend:

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

Es wird davon ausgegangen, dass sich die Eingabe im Register befindet (© / ®).

Perl - 120, 214

Nimmt ein Array (Liste) von Booleschen Werten.

Würfel (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}

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