Le groupe dièdre est le groupe de symétrie du carré, c'est-à-dire les mouvements qui transforment un carré à lui-même via des rotations et des réflexions. Il se compose de 8 éléments: des rotations de 0, 90, 180 et 270 degrés et des réflexions sur les axes horizontal, vertical et deux diagonaux.$D_4$

Les images sont toutes issues de cette jolie page de Larry Riddle.

Ce défi consiste à composer ces mouvements: compte tenu de deux mouvements, sortez le mouvement qui équivaut à les faire l'un après l'autre. Par exemple, faire le coup 7 suivi du coup 4 revient au même que faire le coup 5.

Notez que changer l'ordre de déplacer 4 puis déplacer 7 produit le mouvement 6 à la place.

Les résultats sont présentés dans le tableau ci-dessous; c'est la table Cayley du groupe . Ainsi, par exemple, les entrées devraient produire la sortie .$D_4$$7, 4$$5$

$$\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}$$

Défi

Votre objectif est d'implémenter cette opération dans le moins d'octets possible, mais en plus du code, vous choisissez également les étiquettes qui représentent les déplacements de 1 à 8. Les étiquettes doivent être constituées de 8 nombres distincts de 0 à 255 , ou les 8 -octets représentent leurs points de code.

Votre code recevra deux des étiquettes parmi les 8 que vous avez choisies et doit sortir l'étiquette qui correspond à leur composition dans le groupe dièdre $D_4$ .

Exemple

Supposons que vous ayez choisi les caractères C, O, M, P, U, T, E, R pour les mouvements 1 à 8 respectivement. Ensuite, votre code doit implémenter cette table.

$$\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}$$

Étant donné les entrées E et P, vous devez sortir U. Vos entrées seront toujours deux des lettres C, O, M, P, U, T, E, R, et votre sortie devrait toujours être l'une de ces lettres.

Tableau de texte pour la copie

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

Rubis , 18 octets

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

Non golfé

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

Essayez-le en ligne!

Utilise les numéros de codage suivants de 0 à 7

Dans l'ordre natif du code:

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

Pour la question

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

Explication

/représente un retournement dans la ligne y=xet |représente un retournement dans l'axe y.

Il est possible de générer n'importe laquelle des symétries du groupe D4 en inversant alternativement ces deux lignes, par exemple /suivi de |donne /|qui est une rotation de 90 degrés dans le sens inverse des aiguilles d'une montre.

Le nombre total de flips consécutifs donne une représentation très pratique pour la manipulation arithmétique.

Si le premier coup est une rotation, on peut simplement ajouter le nombre de flips:

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

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

Si le premier mouvement est une réflexion, nous constatons que nous avons des réflexions /et des |symboles identiques les uns à côté des autres. La réflexion étant auto-inverse, nous pouvons annuler ces flips un par un. Nous devons donc soustraire un mouvement de l'autre

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 octets

$0, 5, 2, 7, 1, 3, 6, 4$

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

Essayez-le en ligne!

Explication:

$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\}.$$

Et nous avons

$$\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},$$

qui peut facilement être écrit en opérations au niveau du bit.

Wolfram Language (Mathematica) , 51 octets

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

Essayez-le en ligne!

À l'aide d'étiquettes {228, 57, 78, 147, 27, 177, 198, 108}.

Ce sont {3210, 0321, 1032, 2103, 0123, 2301, 3012, 1230}en base 4. Heureusement, 256 = 4 ^ 4.

---

Implémentation de niveau inférieur, également 51 octets

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

Essayez-le en ligne!

Python 2 , 22 octets

$0, 6, 1, 7, 2, 3, 5, 4$

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

Essayez-le en ligne!

Python 2 , 26 23 21 octets

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

$D_3$andxnor

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

TI-BASIC, 165 octets

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

L'entrée est une liste de deux pouces de longueur Ans.
La sortie est le nombre à l' (row, column)index dans le tableau.

Il pourrait y avoir une meilleure méthode de compression qui permettrait d'économiser des octets, mais je vais devoir y réfléchir.

Exemples:

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

Explication:
(Des sauts de ligne ont été ajoutés pour plus de lisibilité.)

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"

Voici une solution à 155 octets , mais elle code simplement la matrice et obtient l'index.
Je l'ai trouvé plus ennuyeux, donc je n'en ai pas fait ma soumission officielle:

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

---

Remarque: TI-BASIC est un langage à jetons. Le nombre de caractères n'est pas égal au nombre d'octets.

Gelée , 6 octets

N⁹¡+%8

Un lien dyadique acceptant la première transformation à droite et la deuxième transformation à gauche qui donne la transformation composite.

Où se trouvent les transformations:

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

Essayez-le en ligne! ... Ou voyez le tableau retranscrit sur les étiquettes de la question .

(Les arguments peuvent être repris dans l'autre ordre en utilisant le 6 octet, _+Ḃ?%8)

Comment?

Chaque étiquette est la longueur d'une séquence d'alternances horet de +vetransformations qui est équivalente à la transformation (par exemple 180est équivalente à hor, +ve, hor, +ve).

La composition A,Best équivalente à la concaténation des deux séquences équivalentes, et permet une simplification en soustraction ou addition modulo huit ...

En utilisant l' 7, 4exemple de la question que nous avons +ve, 90cqui est:
hor, +ve, hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve, hor, +ve

... mais depuis hor, horest que idnous avons:
hor, +ve, hor, +ve, hor, +ve , +ve, hor, +ve, hor, +ve

... et depuis +ve, +veest que idnous avons:
hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve

... et nous pouvons répéter ces annulations pour:
hor
..équivalent à la soustraction des longueurs ( 7-6=1).

Lorsqu'aucune annulation n'est possible, nous ajoutons simplement les longueurs (comme 90a, 180 $\rightarrow$ 2+4=6 $\rightarrow$ 90c).

Enfin, notez qu'une séquence de longueur huit est idainsi nous pouvons prendre la longueur de séquence résultante modulo huit.

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

---

Il est également 1 octet plus court que cette implémentation utilisant des index de permutation lexicographiques:

œ?@ƒ4Œ¿

... un lien monadique acceptant [first, second], avec des étiquettes:

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 17 octets

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

Essayez-le en ligne! Port de ma réponse à Cayley Table du groupe dièdre$D_3$mais j'ai joué au golf en utilisant les suggestions de ma réponse Python. Utilise le mappage suivant:

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

Les anciennes versions de JavaScript peuvent être prises en charge de différentes manières pour 22 octets:

(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

Rouille , 16 octets

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

Essayez-le en ligne!

Réponse de Port of alephalpha en Python. Mais plus court.

Orme , 42 octets 19 octets

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

Port de la version Neil's Node.js

Essayez-le en ligne

La version précédente:

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

Python, 82 71 octets

0-7

-11 octets grâce à ASCII uniquement

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

TIO

Scala , 161 octets

Choisir ORDINATEUR comme étiquettes.

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)

Essayez-le en ligne!

Scala , 70 octets

Choix de 0 à 7 entiers natifs comme étiquettes.

Compression de la matrice en chaîne ASCII de 32 octets, chaque paire de nombres n0, n1 en 1 caractère c = n0 + 8 * n1 + 49. À partir de 49, nous n'avons pas \ dans la chaîne codée.

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

Essayez-le en ligne!

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

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

Réponse de Port of alpehalpha en Python.

Essayez-le en ligne!

Perl 6 , 19 octets

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

Port de la solution Python de Neil .

Essayez-le en ligne!

Wolfram Language (Mathematica), 7 octets (encodage UTF-8)

#⊙#2&

Une fonction pure prenant deux arguments. Le symbole rendu ici ⊙est en fait le symbole Unicode privé F3DE de Mathematica (3 octets), qui représente la fonction PermutationProduct.

Mathematica connaît les groupes dièdres et représente les éléments de divers groupes sous forme de permutations, écrits à l'aide de la Cyclescommande. Par exemple, exécuter la commande

GroupElements[DihedralGroup[4]]

donne la sortie:

{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 est la fonction qui multiplie les éléments de groupe lorsqu'elle est écrite sous cette forme.

Puisque nous sommes autorisés à choisir nos propres étiquettes, cette fonction suppose ces étiquettes pour les éléments du groupe; L'association entre ces étiquettes et celles du poste problématique est donnée par:

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

tl; dr Il y a un intégré.