El grupo diédrico $D_4$ es el grupo de simetría del cuadrado, es decir, los movimientos que transforman un cuadrado a sí mismo a través de rotaciones y reflexiones. Consta de 8 elementos: rotaciones de 0, 90, 180 y 270 grados, y reflexiones a través de los ejes horizontal, vertical y dos diagonales.

Las imágenes son todas de esta hermosa página de Larry Riddle.

Este desafío se trata de componer estos movimientos: dados dos movimientos, genera el movimiento que es equivalente a hacerlos uno tras otro. Por ejemplo, hacer el movimiento 7 seguido del movimiento 4 es lo mismo que hacer el movimiento 5.

Tenga en cuenta que cambiar el orden para mover 4 y luego mover 7 produce el movimiento 6 en su lugar.

Los resultados se tabulan a continuación; Esta es la tabla de Cayley del grupo $D_4$ . Entonces, por ejemplo, las entradas $7, 4$ deberían producir la salida $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}$$

Desafío

Su objetivo es implementar esta operación en la menor cantidad de bytes posible, pero además del código, también elige las etiquetas que representan los movimientos del 1 al 8. Las etiquetas deben ser 8 números distintos del 0 al 255 , o el 8 -byte caracteres que representan sus puntos de código.

Su código recibirá dos de las etiquetas de las 8 que ha elegido, y debe mostrar la etiqueta que corresponde a su composición en el grupo diédrico $D_4$ .

Ejemplo

Supongamos que ha elegido los caracteres C, O, M, P, U, T, E, R para los movimientos 1 a 8 respectivamente. Entonces, su código debe implementar esta tabla.

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

Dadas las entradas E y P, debe generar U. Sus entradas siempre serán dos de las letras C, O, M, P, U, T, E, R, y su salida siempre será una de estas letras.

Tabla de texto para copiar

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}

Sin golf

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

Pruébalo en línea!

Utiliza los siguientes números de codificación del 0 al 7

En orden nativo al código:

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

En orden por la pregunta

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

Explicación

/representa un giro en la línea y=xy| un giro en el eje y.

Es posible generar cualquiera de las simetrías del grupo D4 volteando alternativamente estas dos líneas. Por ejemplo, /seguido de |dado/| que es una rotación de 90 grados en sentido antihorario.

El número total de vueltas consecutivas proporciona una representación muy conveniente para la manipulación aritmética.

Si el primer movimiento es una rotación, simplemente podemos agregar el número de vueltas:

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

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

Si el primer movimiento es un reflejo, descubrimos que tenemos algunos reflejos /y |símbolos idénticos uno al lado del otro. Como la reflexión es inversa, podemos cancelar estos cambios uno por uno. Entonces necesitamos restar un movimiento del otro

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 bytes

Usando enteros $0, 5, 2, 7, 1, 3, 6, 4$ como etiquetas.

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

Pruébalo en línea!

Explicación:

El grupo Diedro $D_4$ es isomorfo al grupo matriz triangular unitario de grado tres sobre el campo $\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\}.$$

Y tenemos

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

que se puede escribir fácilmente en operaciones bit a bit.

Wolfram Language (Mathematica) , 51 bytes

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

Pruébalo en línea!

Usando etiquetas {228, 57, 78, 147, 27, 177, 198, 108} .

Estos están {3210, 0321, 1032, 2103, 0123, 2301, 3012, 1230}en la base 4. Afortunadamente, 256 = 4 ^ 4.

---

Implementación de nivel inferior, también 51 bytes

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

Pruébalo en línea!

Python 2 , 22 bytes

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

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

Pruébalo en línea!

Python 2 , 26 23 21 bytes

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

La entrada es una lista de longitud dos en Ans.
La salida es el número en el (row, column)índice de la tabla.

Podría haber un mejor método de compresión que ahorraría bytes, pero tendré que investigarlo.

Ejemplos:

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

Explicación:
(Se han agregado nuevas líneas para facilitar la lectura).

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"

Aquí hay una solución de 155 bytes , pero solo codifica la matriz y obtiene el índice.
Lo encontré más aburrido, así que no lo hice mi presentación oficial:

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

---

Nota: TI-BASIC es un lenguaje tokenizado. El recuento de caracteres hace es igual al recuento de bytes.

Jalea , 6 bytes

N⁹¡+%8

Un enlace diádico que acepta la primera transformación a la derecha y la segunda transformación a la izquierda que produce la transformación compuesta.

Donde están las transformaciones:

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

Pruébalo en línea! ... O vea la tabla asignada de nuevo a las etiquetas en la pregunta .

(Los argumentos podrían tomarse en el otro orden usando el byte 6 _+Ḃ?%8)

¿Cómo?

Cada etiqueta es la longitud de una secuencia de alternancia hory +vetransformaciones que es equivalente a la transformación (por ejemplo, 180es equivalente a hor, +ve, hor, +ve).

La composición A,Bes equivalente a la concatenación de las dos secuencias equivalentes, y permite la simplificación de la resta o la suma del módulo ocho ...

Usando el 7, 4ejemplo de la pregunta tenemos +ve, 90ccuál es:
hor, +ve, hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve, hor, +ve

... pero ya hor, hores idque tenemos:
hor, +ve, hor, +ve, hor, +ve , +ve, hor, +ve, hor, +ve

... y como +ve, +vees idque tenemos:
hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve

... y podemos repetir estas cancelaciones para:
hor
..equivalente a la resta de las longitudes (7-6=1 ).

Cuando no hay cancelaciones posibles, solo estamos agregando las longitudes (como 90a, 180 $\rightarrow$ 2+4=6 $\rightarrow$ 90c)

Por último, tenga en cuenta que una secuencia de longitud ocho es idpara que podamos tomar la secuencia de longitud resultante módulo ocho.

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

---

También es 1 byte más corto que esta implementación usando índices de permutación lexicográficos:

œ?@ƒ4Œ¿

... un enlace monádico que acepta [first, second], con etiquetas:

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 bytes

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

Pruébalo en línea! Puerto de mi respuesta a Cayley Table of the Dihedral Group$D_3$pero jugué con las sugerencias de mi respuesta de Python. Utiliza el siguiente mapeo:

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

Las versiones anteriores de JavaScript se pueden admitir de varias maneras para 22 bytes:

(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

Óxido , 16 bytes

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

Pruébalo en línea!

Port of alephalpha's Python answer. Pero mas corto.

Olmo , 42 bytes 19 bytes

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

Puerto de los Neil's Versión Node.js

Pruébalo en línea

Versión previa:

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

Python, 82 71 bytes

0-7

-11 bytes gracias a ASCII de sólo

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

TIO

Scala , 161 bytes

Elegir ORDENADOR como etiquetas.

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)

Pruébalo en línea!

Scala , 70 bytes

Elegir 0-7 enteros nativos como etiquetas.

Comprimió la matriz en una cadena ASCII de 32 bytes, cada par de números n0, n1 en 1 carácter c = n0 + 8 * n1 + 49. Comenzando desde 49 hasta que no tenemos \ en la cadena codificada.

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

Pruébalo en línea!

C # (compilador interactivo de Visual C #) , 17 bytes

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

Puerto de la respuesta Python de alpehalpha.

Pruébalo en línea!

Perl 6 , 19 bytes

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

Solución Python del puerto de Neil .

Pruébalo en línea!

Wolfram Language (Mathematica), 7 bytes (codificación UTF-8)

#⊙#2&

Una función pura que toma dos argumentos. El símbolo representado aquí como en ⊙realidad es el símbolo privado Unicode de Mathematica F3DE (3 bytes), que representa la funciónPermutationProduct .

Mathematica sabe sobre grupos diédricos, y representa los elementos de varios grupos como permutaciones, escritos usando el Cyclescomando. Por ejemplo, ejecutando el comando

GroupElements[DihedralGroup[4]]

produce la salida:

{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 es la función que multiplica los elementos del grupo cuando se escribe de esta forma.

Como se nos permite elegir nuestras propias etiquetas, esta función asume estas etiquetas para los elementos del grupo; La asociación entre estas etiquetas y las de la publicación del problema viene dada por:

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 Hay un incorporado.