Die Diedergruppe $D_4$ ist die Symmetriegruppe des Quadrats, dh die Bewegungen, die ein Quadrat durch Rotationen und Reflexionen in sich selbst transformieren. Es besteht aus 8 Elementen: Rotationen um 0, 90, 180 und 270 Grad sowie Reflexionen über die horizontale, vertikale und zwei diagonale Achsen.

Die Bilder stammen alle von dieser schönen Seite von Larry Riddle.

Bei dieser Herausforderung geht es darum, diese Züge zu komponieren: Geben Sie bei zwei Zügen den Zug aus, der gleichbedeutend damit ist, sie nacheinander auszuführen. Zum Beispiel ist das Ausführen von Zug 7, gefolgt von Zug 4, dasselbe wie das Ausführen von Zug 5.

Beachten Sie, dass das Umschalten der Reihenfolge auf Zug 4 und dann auf Zug 7 zu Zug 6 führt.

Die Ergebnisse sind unten tabellarisch aufgeführt. Dies ist der Cayley-Tisch der Gruppe $D_4$ . So sollten beispielsweise die Eingänge $7, 4$ Ausgang $5$ erzeugen .

$$\begin{array}{*{20}{c}} {} & {\begin{array}{*{20}{c}} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \\ \end{array} } \\ {\begin{array}{*{20}{c}} 1 \\ 2 \\ 3 \\ 4 \\ 5 \\ 6 \\ 7 \\ 8 \\ \end{array} } & {\boxed{\begin{array}{*{20}{c}} 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 \\ 2 & 3 & 4 & 1 & 8 & 7 & 5 & 6\\ 3 & 4 & 1 & 2 & 6 & 5 & 8 & 7\\ 4 & 1 & 2 & 3 & 7 & 8 & 6 & 5\\ 5 & 7 & 6 & 8 & 1 & 3 & 2 & 4\\ 6 & 8 & 5 & 7 & 3 & 1 & 4 & 2\\ 7 & 6 & 8 & 5 & 4 & 2 & 1 & 3\\ 8 & 5 & 7 & 6 & 2 & 4 & 3 & 1\\ \end{array} }} \\ \end{array}$$

Herausforderung

Ihr Ziel ist es, diese Operation in so wenigen Bytes wie möglich zu implementieren. Zusätzlich zum Code wählen Sie auch die Bezeichnungen , die die Schritte 1 bis 8 darstellen. Die Bezeichnungen müssen 8 verschiedene Zahlen von 0 bis 255 oder die 8 sein -byte Zeichen, die ihre Codepunkte darstellen.

Ihr Code erhält zwei der von Ihnen ausgewählten 8 Etiketten und muss das Etikett ausgeben, das ihrer Zusammensetzung in der Diedergruppe $D_4$ .

Beispiel

Angenommen, Sie haben die Zeichen C, O, M, P, U, T, E und R für die Züge 1 bis 8 ausgewählt. Dann sollte Ihr Code diese Tabelle implementieren.

$$\begin{array}{*{20}{c}} {} & {\begin{array}{*{20}{c}} \, C \, & \, O \, & M \, & P \, & U \, & \, T \, & \, E \, & R \, \\ \end{array} } \\ {\begin{array}{*{20}{c}} C \\ O \\ M \\ P \\ U \\ T \\ E \\ R \\ \end{array} } & {\boxed{\begin{array}{*{20}{c}} C & O & M & P & U & T & E & R \\ O & M & P & C & R & E & U & T\\ M & P & C & O & T & U & R & E\\ P & C & O & M & E & R & T & U\\ U & E & T & R & C & M & O & P\\ T & R & U & E & M & C & P & O\\ E & T & R & U & P & O & C & M\\ R & U & E & T & O & P & M & C\\ \end{array} }} \\ \end{array}$$

Bei den Eingaben E und P sollten Sie U ausgeben. Ihre Eingaben bestehen immer aus zwei der Buchstaben C, O, M, P, U, T, E, R, und Ihre Ausgabe sollte immer aus einem dieser Buchstaben bestehen.

Texttabelle zum Kopieren

1 2 3 4 5 6 7 8
2 3 4 1 8 7 5 6
3 4 1 2 6 5 8 7
4 1 2 3 7 8 6 5
5 7 6 8 1 3 2 4
6 8 5 7 3 1 4 2
7 6 8 5 4 2 1 3
8 5 7 6 2 4 3 1

Ruby , 18 Bytes

->a,b{a+b*~0**a&7}

Ungolfed

->a,b{ (a+b*(-1)**a) % 8}  
# for operator precedence reasons, 
#-1 is represented as ~0 in the golfed version 

Probieren Sie es online!

Verwendet die folgenden Codierungsnummern 0 bis 7

In der Reihenfolge, in der der Code vorkommt:

Native     Effect                    Codes per
Code                                 Question
0          rotate 0 anticlockwise    1C
1 /        flip in y=x               7E
2 /|       rotate 90 anticlockwise   2O
3 /|/      flip in x axis            5U
4 /|/|     rotate 180 anticlockwise  3M
5 /|/|/    flip in y=-x              8R
6 /|/|/|   rotate 270 anticlockwise  4P
7 /|/|/|/  flip in y axis            6T

In der Reihenfolge nach der Frage

Native     Effect                    Codes per
Code                                 Question
0          rotate 0 anticlockwise    1C
2 /|       rotate 90 anticlockwise   2O
4 /|/|     rotate 180 anticlockwise  3M
6 /|/|/|   rotate 270 anticlockwise  4P
3 /|/      flip in x axis            5U
7 /|/|/|/  flip in y axis            6T
1 /        flip in y=x               7E
5 /|/|/    flip in y=-x              8R

Erläuterung

/repräsentiert einen Flip in der Linie y=xund |repräsentiert einen Flip in der y-Achse.

Es ist möglich , irgendeine der Symmetrien der Gruppe D4 durch abwechselndes Umklappen in diesen beiden Linien zu erzeugen , zum Beispiel /gefolgt von |verleiht /|die eine Drehung von 90 Grad gegen den Uhrzeigersinn ist.

Die Gesamtzahl der aufeinanderfolgenden Flips bietet eine sehr bequeme Darstellung für die arithmetische Manipulation.

Wenn der erste Zug eine Rotation ist, können wir einfach die Anzahl der Flips addieren:

Rotate 90 degrees   +  Rotate 180 degrees = Rotate 270 degrees
/|                     /|/|                 /|/|/|

Rotate 90 degress   +  Flip in y=x        = Flip in x axis   
/|                    /                     /|/

Wenn der erste Zug eine Reflexion ist, haben wir einige identische Reflexionen /und |Symbole nebeneinander. Da die Reflexion selbstinvers ist, können wir diese Umkehrungen nacheinander aufheben. Wir müssen also einen Zug vom anderen abziehen

Flip in x axis     +  Flip in y=x        = Rotate 90 degrees
/|/                   /                    /|/ / (cancels to) /|

Flip in x axis     +  Rotate 90 degrees  = Flip in y=x
/|/                   /|                   /|/ /| (cancels to ) / 

Wolfram Language (Mathematica) , 31 Byte

Verwenden von Ganzzahlen $0, 5, 2, 7, 1, 3, 6, 4$ als Beschriftungen.

BitXor[##,2Mod[#,2]⌊#2/4⌋]&

Probieren Sie es online!

Erläuterung:

$D_4$$\mathbb{F}_2$

$$D_4 \cong U(3,2) := \left\{\begin{pmatrix} 1 & a & b \\ 0 & 1 & c \\ 0 & 0 & 1 \end{pmatrix} \mid a,b,c \in \mathbb{F}_2\right\}.$$

And we have

$$\begin{pmatrix} 1 & a_1 & b_1 \\ 0 & 1 & c_1 \\ 0 & 0 & 1 \end{pmatrix} \cdot \begin{pmatrix} 1 & a_2 & b_2 \\ 0 & 1 & c_2 \\ 0 & 0 & 1 \end{pmatrix} = \begin{pmatrix} 1 & a_1+a_2 & b_1+b_2+a_1c_2 \\ 0 & 1 & c_1+c_2 \\ 0 & 0 & 1 \end{pmatrix},$$

which can easily be written in bitwise operations.

Wolfram Language (Mathematica), 51 bytes

⌊#/4^IntegerDigits[#2,4,4]⌋~Mod~4~FromDigits~4&

Try it online!

Using labels {228, 57, 78, 147, 27, 177, 198, 108}.

These are {3210, 0321, 1032, 2103, 0123, 2301, 3012, 1230} in base 4. Fortunately, 256=4^4.

---

Lower-level implementation, also 51 bytes

Sum[4^i⌊#/4^⌊#2/4^i⌋~Mod~4⌋~Mod~4,{i,0,3}]&

Try it online!

Python 2, 22 bytes

A port of my Mathematica answer. Using integers $0, 6, 1, 7, 2, 3, 5, 4$ as labels.

lambda a,b:a^b^a/2&b/4

Try it online!

Python 2 , 26 23 21 Bytes

lambda x,y:y+x*7**y&7

Probieren Sie es online! Port meiner Antwort an Cayley Table von der Dihedral Group$D_3$. Bearbeiten: 3 Bytes dank @NieDzejkob gespeichert. 2 Bytes gespart dank @xnor für den Vorschlag des Operators and(anstatt xnor). Verwendet die folgende Zuordnung:

 id | r1 | r2 | r3 | s0 | s1 | s2 | s3 
----+----+----+----+----+----+----+----
 0  | 2  | 4  | 6  | 1  | 3  | 5  | 7  

TI-BASIC, 165 Bytes

Ans→L₁:{.12345678,.23417865,.34126587,.41238756,.58671342,.67583124,.75862413,.86754231→L₂:For(I,1,8:10fPart(.1int(L₂(I)₁₀^(seq(X,X,1,8:List▶matr(Ans,[B]:If I=1:[B]→[A]:If I-1:augment([A],[B]→[A]:End:[A](L₁(1),L₁(2

Die Eingabe ist eine Liste mit einer Länge von zwei Zoll Ans.
Ausgabe ist die Nummer am (row, column)Index in der Tabelle.

Es könnte eine bessere Komprimierungsmethode geben, die Bytes einspart, aber ich muss mich darum kümmern.

Beispiele:

{1,2
           {1 2}
prgmCDGF1B
               2
{7,4
           {7 4}
prgmCDGF1B
               5

Erläuterung:
(Zeilenumbrüche wurden zur besseren Lesbarkeit hinzugefügt.)

Ans→L₁                              ;store the input list into L₁
{.123456 ... →L₂                    ;store the compressed matrix into L₂
                                    ; (line shortened for brevity)
For(I,1,8                           ;loop 8 times
10fPart(.1int(L₂(I)₁₀^(seq(X,X,1,8  ;decompress the "I"-th column of the matrix
List▶matr(Ans,[B]                   ;convert the resulting list into a matrix column and
                                    ; then store it into the "[B]" matrix variable
If I=1                              ;if the loop has just started...
[B]→[A]                             ;then store this column into "[A]", another matrix
                                    ; variable
If I-1                              ;otherwise...
augment([A],[B]→[A]                 ;append this column onto "[A]"
End
[A](L₁(1),L₁(2                      ;get the index and keep it in "Ans"
                                    ;implicit print of "Ans"

Hier ist eine 155-Byte- Lösung, die jedoch nur die Matrix fest codiert und den Index abruft.
Ich fand es langweiliger, also habe ich es nicht zu meiner offiziellen Einreichung gemacht:

Ans→L₁:[[1,2,3,4,5,6,7,8][2,3,4,1,8,7,5,6][3,4,1,2,6,5,8,7][4,1,2,3,7,8,6,5][5,7,6,8,1,3,2,4][6,8,5,7,3,1,4,2][7,6,8,5,4,2,1,3][8,5,7,6,2,4,3,1:Ans(L₁(1),L₁(2

---

Hinweis: TI-BASIC ist eine Token-Sprache. Die Anzahl der Zeichen entspricht nicht der Anzahl der Bytes.

Gelee , 6 Bytes

N⁹¡+%8

Ein dyadischer Link, der die erste Transformation rechts und die zweite Transformation links akzeptiert und die zusammengesetzte Transformation ergibt.

Wo die Transformationen sind:

as in question:  1    2    3    4    5    6    7    8
transformation: id  90a  180  90c  hor  ver  +ve  -ve
  code's label:  0    2    4    6    1    5    7    3

Probieren Sie es online! ... oder sehen Sie sich die Tabelle wieder auf den Etiketten in der Frage abgebildet .

(Die Argumente können in der anderen Reihenfolge mit dem 6-Byte- _+Ḃ?%8 )

Wie?

Jedes Label ist die Länge einer Sequenz von Wechsel- horund +veTransformationen, die der Transformation entspricht (z. B. 180entspricht hor, +ve, hor, +ve).

Die Komposition A,Bist gleichbedeutend mit der Verkettung der beiden äquivalenten Sequenzen und ermöglicht eine Vereinfachung der Subtraktion oder Addition ...

Anhand des 7, 4Beispiels der Frage haben wir folgendes +ve, 90c:
hor, +ve, hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve, hor, +ve

... aber da hor, horist idhaben wir:
hor, +ve, hor, +ve, hor, +ve , +ve, hor, +ve, hor, +ve

... und da +ve, +veist idhaben wir:
hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve

... und wir können diese Absagen wiederholen, um:
hor
..äquivalent zum Subtrahieren der Längen ( 7-6=1).

Wenn keine Stornierungen möglich sind, addieren wir nur die Längen (wie 90a, 180 $\rightarrow$ 2+4=6 $\rightarrow$ 90c).

Schließlich ist zu beachten, dass eine Sequenz der Länge acht ist, iddamit wir die resultierende Sequenzlänge modulo acht nehmen können.

N⁹¡+%8 - Link: B, A
  ¡    - repeat (applied to chain's left argument, B)...
 ⁹     - ...times: chain's right argument, A
N      - ...action: negate  ...i.e. B if A is even, otherwise -B
   +   - add (A)
    %8 - modulo eight

---

Es ist auch 1 Byte kürzer als diese Implementierung mit lexikografischen Permutationsindizes:

œ?@ƒ4Œ¿

... ein monadischer Link, der akzeptiert [first, second], mit Labels:

as in question:  1    2    3    4    5    6    7    8
transformation: id  90a  180  90c  hor  ver  +ve  -ve
  code's label:  1   10   17   19   24    8   15    6

JavaScript (Node.js) , 22 bis 17 Byte

(x,y)=>y+x*7**y&7

Probieren Sie es online! Port meiner Antwort an Cayley Table von der Dihedral Group$D_3$aber mit den Vorschlägen auf meiner Python-Antwort nach unten Golf gespielt. Verwendet die folgende Zuordnung:

 id | r1 | r2 | r3 | s0 | s1 | s2 | s3 
----+----+----+----+----+----+----+----
 0  | 2  | 4  | 6  | 1  | 3  | 5  | 7  

Ältere Versionen von JavaScript können für 22 Byte auf verschiedene Arten unterstützt werden:

(x,y)=>(y&1?y-x:y+x)&7
(x,y)=>y-x*(y&1||-1)&7
(x,y)=>y+x*(y<<31|1)&7

Rust , 16 Bytes

|a,b|a^b^a/2&b/4

Probieren Sie es online!

Port of Alephalphas Python Antwort. Aber kürzer.

Ulme , 42 Bytes 19 Bytes

\a b->and 7<|b+a*7^b

Port der Neil's Node.js Version

Probieren Sie es online aus

Vorherige Version:

\a b->and 7<|if and 1 a>0 then a-b else a+b

Python, 82 71 Bytes

0-7

-11 Bytes nur dank ASCII

lambda a,b:int("27pwpxvfcobhkyqu1wrun3nu1fih0x8svriq0",36)>>3*(a*8+b)&7

TIO

Scala , 161 Bytes

Auswahl von COMPUTER als Beschriftung.

val m="0123456712307645230154763012675446570213574620316574310274651320"
val s="COMPUTER"
val l=s.zipWithIndex.toMap
def f(a: Char, b: Char)=s(m(l(a)*8+l(b))-48)

Probieren Sie es online!

Scala , 70 Bytes

Auswahl von 0-7 nativen Ganzzahlen als Bezeichnungen.

Komprimierte die Matrix in eine 32-Byte-ASCII-Zeichenfolge, wobei jedes Zahlenpaar n0, n1 in 1 Zeichen c = n0 + 8 * n1 + 49 ist. Ab 49 ist in der codierten Zeichenfolge kein \ enthalten.

(a:Int,b:Int)=>"9K]oB4h]K9Vh4BoVenAJne3<_X<AX_J3"(a*4+b/2)-49>>b%2*3&7

Probieren Sie es online!

C # (Visual C # Interactive Compiler) , 17 Byte

a=>b=>a^b^a/2&b/4

Port of Alpehalpha's Python Antwort.

Probieren Sie es online!

Perl 6 , 19 Bytes

{($^x*7**$^y+$y)%8}

Port von Neils Python-Lösung .

Probieren Sie es online!

Wolfram Language (Mathematica), 7 Byte (UTF-8-Codierung)

#⊙#2&

Eine reine Funktion mit zwei Argumenten. Das hier als gerenderte Symbol ⊙ist tatsächlich das private Unicode-Symbol F3DE (3 Byte) von Mathematica, das die Funktion darstellt PermutationProduct.

Mathematica kennt sich mit Flächengruppen aus und repräsentiert die Elemente verschiedener Gruppen als Permutationen, die mit dem CyclesBefehl geschrieben wurden. Führen Sie beispielsweise den Befehl aus

GroupElements[DihedralGroup[4]]

ergibt die Ausgabe:

{Cycles[{}], Cycles[{{2, 4}}], Cycles[{{1, 2}, {3, 4}}], 
 Cycles[{{1, 2, 3, 4}}], Cycles[{{1, 3}}], Cycles[{{1, 3}, {2, 4}}], 
 Cycles[{{1, 4, 3, 2}}], Cycles[{{1, 4}, {2, 3}}]}

PermutationProduct ist die Funktion, die Gruppenelemente multipliziert, wenn sie in dieser Form geschrieben werden.

Da wir unsere eigenen Bezeichnungen auswählen dürfen, übernimmt diese Funktion diese Bezeichnungen für die Gruppenelemente. Die Zuordnung zwischen diesen Labels und denen im Problembeitrag ist gegeben durch:

Cycles[{}] -> 1
Cycles[{{1, 2, 3, 4}}] -> 2
Cycles[{{1, 3}, {2, 4}}] -> 3
Cycles[{{1, 4, 3, 2}}] -> 4
Cycles[{{2, 4}}] -> 5
Cycles[{{1, 3}}] -> 6
Cycles[{{1, 2}, {3, 4}}] -> 7
Cycles[{{1, 4}, {2, 3}}] -> 8

Es gibt einen eingebauten.