O grupo diedro$D_3$ representa as simetrias de um triângulo equilátero, utilizando a identidade (representado por id), rotações (representados por r1e r2), e as reflexões (representados por s0, s1, e s2).

Sua tarefa é calcular a composição dos elementos . Eles são fornecidos pela tabela de Cayley abaixo:x , y ∈ D $yx$$x, y \in D_3$

  x  id  r1  r2  s0  s1  s2
y  +-----------------------
id | id  r1  r2  s0  s1  s2
r1 | r1  r2  id  s1  s2  s0
r2 | r2  id  r1  s2  s0  s1
s0 | s0  s2  s1  id  r2  r1
s1 | s1  s0  s2  r1  id  r2
s2 | s2  s1  s0  r2  r1  id

Entrada

Qualquer entrada razoável de xe y. Ordem não importa.

Resultado

ycomposto com xou procurando valores na tabela com base em xe y.

Casos de teste

Estes são dados no formulário x y -> yx.

id id -> id
s1 s2 -> r1
r1 r1 -> r2
r2 r1 -> id
s0 id -> s0
id s0 -> s0

Notas sobre E / S

Você pode usar qualquer substituição razoável de id, r1, r2, s0, s1, s2, por exemplo 1, 2, 3, 4, 5, 6, 0, 1, 2, 3, 4, 5ou mesmo [0,0], [0,1], [0,2], [1,0], [1,1], [1,2](aqui o primeiro número representa rotação / reflexão e o segundo é o índice).

Python 2 , 27 bytes

lambda o,O:[o[_]for _ in O]

Experimente online!

Geléia , 1 byte

ị

Um link diádico com y à esquerda ex à direita.

Utiliza as representações do primeiro punho em três números naturais transformados conforme suas ações descrevem:

   name:  id          r1          r2          s0          s1          s2
  value:  [1,2,3]     [2,3,1]     [3,1,2]     [2,1,3]     [1,3,2]     [3,2,1]
(action:  identity    rot-Left    rot-Right   swap-Left   swap-Right  swap-Outer)

Um porto da resposta Python de Jonathan Frech

ịé o "índice de" geléia de átomo, e vetoriza; observe que a geléia é indexada em 1.

Experimente online! Ou veja uma tabela usando os nomes das perguntas .

Para colocar x à esquerda e y à direita, esses valores podem ser usados:

id       r1       r2       s0       s1       s2
[1,2,3]  [3,1,2]  [2,3,1]  [1,3,2]  [3,2,1]  [2,1,3]

... veja aqui .

JavaScript (ES6), 39 bytes

Usa o seguinte mapeamento:

 id | r1 | r2 | s0 | s1 | s2
----+----+----+----+----+----
 2  | 0  | 4  | 1  | 3  | 5

Toma entrada como (x)(y).

x=>y=>'450123234523012323'[(x*51^y)%18]

Experimente online!

JavaScript (ES6), 20 bytes

Usando o formato de E / S de Jonathan Frech :

x=>y=>y.map(n=>x[n])

Experimente online!

Python 2 , 27 26 23 bytes

lambda x,y:(y+x*5**y)%6

Experimente online! Editar: salvou 3 bytes graças a @NieDzejkob. Usa o seguinte mapeamento:

 id | r1 | r2 | s0 | s1 | s2 
----+----+----+----+----+----
 0  | 2  | 4  | 1  | 3  | 5  

APL (Dyalog Classic) , 3 bytes

+.×

Experimente online!

+.× é multiplicação de matrizes

nós representamos o grupo como

id     r1     r2     s0     s1     s2
1 0 0  0 0 1  0 1 0  0 0 1  0 1 0  1 0 0 
0 1 0  1 0 0  0 0 1  0 1 0  1 0 0  0 0 1 
0 0 1  0 1 0  1 0 0  1 0 0  0 0 1  0 1 0 

K (ngn / k) , 1 byte

@

Experimente online!

x@yé a indexação de lista, que é igual à composição das permutações; nós representamos o grupo como

id:0 1 2; r1:1 2 0; r2:2 0 1; s0:2 1 0; s1:1 0 2; s2:0 2 1

Japonês , 2 bytes

Usos o formato de E / S de Jonathan .

gV

Experimente online

JavaScript (Node.js) , 24 19 bytes

(x,y)=>(y+x*5**y)%6

Experimente online! Editar: salvou 2 bytes mudando para **e 3 bytes graças a @NieDzejkob. Usa o seguinte mapeamento:

 id | r1 | r2 | s0 | s1 | s2 
----+----+----+----+----+----
 0  | 2  | 4  | 1  | 3  | 5  

A versão antiga de 24 bytes também funciona em versões antigas do JavaScript:

(x,y)=>(y%2?y+6-x:y+x)%6

Raquete , 42 bytes

(lambda(x y)(modulo(+ y(* x(expt 5 y)))6))

Experimente online!

Uma porta chata da resposta Python de Neil. Usa o mesmo formato de E / S, portanto:

 id | r1 | r2 | s0 | s1 | s2 
----+----+----+----+----+----
 0  | 2  | 4  | 1  | 3  | 5  

05AB1E , 1 byte

è

Resposta da porta do @JonathanAllan Jelly , mas com índices baseados em 0, então as representações são:

id       r1       r2       s0       s1       s2       # Original values
[0,1,2]  [1,2,0]  [2,0,1]  [1,0,2]  [0,2,1]  [2,1,0]  # Values instead

Experimente online ou verifique todas as combinações possíveis ou verifique todos os mapeados de volta para os IDs .

Explicação:

è  # Index the second (implicit) input-list vectorized into the first (implicit) input-list
   # And output the result implicitly

Wolfram Language (Mathematica) , 16 bytes

Mod[#+#2*5^#,6]&

Experimente online!

Outro ponto chato da resposta de Neil, desta vez no Mathematica. É uma função anônima que recebe argumentos na ordem[y, x] .

Aqui está a representação de entrada:

 id | r1 | r2 | s0 | s1 | s2 
----+----+----+----+----+----
 0  | 2  | 4  | 1  | 3  | 5