Двухгранна група $D_4$ - це група симетрії квадрата, тобто ходи, які перетворюють квадрат до себе за допомогою обертань та віддзеркалень. Він складається з 8 елементів: обертання на 0, 90, 180 та 270 градусів і відображення по горизонтальній, вертикальній та двох діагональних осях.

Зображення - це з цієї чудової сторінки Ларрі Ріддла.

Це завдання полягає у складанні цих рухів: задавши два рухи, виведіть хід, еквівалентний виконанню їх один за одним. Наприклад, робити хід 7, за яким рухається крок 4 - це те саме, що робити хід 5.

Зауважте, що перемикання наказу на переміщення 4, а потім на переміщення 7 натомість призводить до переміщення 6.

Результати наведені в таблиці нижче; це таблиця Кейлі групи $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}$$

Виклик

Ваша мета - реалізувати цю операцію якомога менше байтів, але крім коду, ви також вибираєте мітки, які представляють ходи від 1 до 8. На мітках має бути 8 чітких чисел від 0 до 255 , або 8 -байтові символи, які представляють їхні кодові точки.

Ваш код отримає дві мітки з обраних вами 8, і повинен вивести мітку, що відповідає їхньому складу, у двогранній групі $D_4$ .

Приклад

Скажіть, що ви вибрали символи C, O, M, P, U, T, E, R для руху 1 по 8 відповідно. Тоді ваш код повинен реалізувати цю таблицю.

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

Враховуючи входи E і P, ви повинні виводити U. Вашими входами завжди будуть дві букви C, O, M, P, U, T, E, R, а ваш вихід завжди повинен бути одним з цих літер.

Текстова таблиця для копіювання

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

Рубін , 18 байт

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

Безумовно

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

Спробуйте в Інтернеті!

Використовує такі кодові числа від 0 до 7

Для введення коду:

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

По порядку за запитанням

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

Пояснення

/являє собою переворот у лінії y=xі |являє собою переворот по осі y.

Можна згенерувати будь-якого з симетрій групи D4, по черзі гортати в цих двох лініях для прикладу з /подальшим |дає /|що поворот на 90 градусів проти годинникової стрілки.

Загальна кількість послідовних обертів дає дуже зручне зображення для арифметичних маніпуляцій.

Якщо перший хід - це обертання, ми можемо просто додати кількість переворотів:

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

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

Якщо перший хід є відображенням, ми виявляємо, що у нас є однакові відображення /та |символи поруч. Оскільки рефлексія самооборотна, ми можемо скасувати ці перевертання по черзі. Тому нам потрібно відняти один хід від іншого

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

Мова Вольфрама (Mathematica) , 31 байт

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

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

Спробуйте в Інтернеті!

Пояснення:

$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

Try it online! Port of my answer to Cayley Table of the Dihedral Group $D_3$. Edit: Saved 3 bytes thanks to @NieDzejkob. Saved 2 bytes thanks to @xnor for suggesting the and (rather than xnor) operator. Uses the following mapping:

 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

Input is a list of length two in Ans.
Output is the number at the (row, column) index in the table.

There could be a better compression method which would save bytes, but I'll have to look into that.

Examples:

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

Explanation:
(Newlines have been added for readability.)

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"

Here's a 155 byte solution, but it just hardcodes the matrix and gets the index.
I found it to be more boring, so I didn't make it my official submission:

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

---

Note: TI-BASIC is a tokenized language. Character count does not equal byte count.

Jelly, 6 bytes

N⁹¡+%8

A dyadic Link accepting the first transform on the right and the second transform on the left which yields the composite transform.

Where the transforms are:

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

Try it online! ...Or see the table mapped back onto the labels in the question.

(The arguments could be taken in the other order using the 6 byter, _+Ḃ?%8)

How?

Each label is the length of a sequence of alternating hor and +ve transforms which is equivalent to the transform (e.g. 180 is equivalent to hor, +ve, hor, +ve).

The composition A,B is equivalent to the concatenation of the two equivalent sequences, and allows simplification to subtraction or addition modulo eight...

Використовуючи 7, 4приклад запитання, який ми маємо +ve, 90c:
hor, +ve, hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve, hor, +ve

... але так як hor, horце у idнас є:
hor, +ve, hor, +ve, hor, +ve , +ve, hor, +ve, hor, +ve

... і так як +ve, +veце idми маємо:
hor, +ve, hor, +ve, hor , hor, +ve, hor, +ve

... і ми можемо повторити ці скасування, щоб:
hor
..еквівалентно відніманню довжин (7-6=1).

Коли відміни неможливі, ми просто додаємо довжини (наприклад, 90a, 180 $\rightarrow$ 2+4=6 $\rightarrow$ 90c).

Нарешті, зауважимо, що послідовність довжиною вісім є idтаким чином, ми можемо взяти отриману довжину послідовності за модулем вісім.

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

---

Це також на 1 байт коротше, ніж ця реалізація, використовуючи лексикографічні індекси перестановки:

œ?@ƒ4Œ¿

... однонадійне Посилання, що приймає [first, second], з мітками:

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 байт

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

Спробуйте в Інтернеті! Порт моєї відповіді на Кейлі Таблиця Діеградної групи$D_3$але гольф вниз, використовуючи пропозиції на мою відповідь Python. Використовується таке відображення:

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

Старіші версії JavaScript можуть підтримуватися різними способами для 22-х байт:

(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

Іржа , 16 байт

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

Спробуйте в Інтернеті!

Відповідь Піфана на адресу алефальфи. Але коротше.

В'яз , 42 байти 19 байт

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

Порт версії Nile.js Ніла

Спробуйте в Інтернеті

Попередня версія:

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

Пітон, 82 71 байт

0-7

-11 байт завдяки лише ASCII

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

ТІО

Scala , 161 байт

Вибір КОМП'ЮТЕРА як етикетки.

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)

Спробуйте в Інтернеті!

Scala , 70 байт

Вибір 0-7 власних цілих чисел як міток.

Стиснув матрицю в 32-байтний рядок ASCII, кожна пара чисел n0, n1 в 1 символ c = n0 + 8 * n1 + 49. Починаючи з 49 до того, що у кодованому рядку у нас немає \

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

Спробуйте в Інтернеті!

C # (Visual C # Interactive Compiler) , 17 байт

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

Порт Альпегальфа відповідь Пітона.

Спробуйте в Інтернеті!

Perl 6 , 19 байт

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

Порт Нілового рішення Python .

Спробуйте в Інтернеті!

Мова Вольфрама (Mathematica), 7 байт (кодування UTF-8)

#⊙#2&

Чиста функція, яка бере два аргументи. Символ, що ⊙подається тут, як насправді приватний символ Unicode Fethde Mathematica (3 байти), який представляє функціюPermutationProduct .

Mathematica знає про двогранні групи, і вона представляє елементи різних груп як перестановки, написані за допомогою Cyclesкоманди. Наприклад, запуск команди

GroupElements[DihedralGroup[4]]

дає вихід:

{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 це функція, що примножує групові елементи, коли пишеться у цій формі.

Оскільки нам дозволяється вибирати власні мітки, ця функція передбачає ці мітки для елементів групи; асоціація між цими мітками та тими, що знаходяться в проблемному дописі, задається:

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 Там є вбудований.