Siendo programadores, vernos flexionar no es muy interesante. ¡Hoy cambiamos eso! En este desafío, lex y flexionarán hexaflexágonos.

Acerca de

Para una introducción en video, vea videos de viharts en flexágonos

Un flexágono es una forma que puede flexionar para revelar caras distintas a la superior e inferior; Estamos haciendo un hexahexaflexágono, que tiene 6 caras. Vea la imagen a continuación sobre cómo doblar un hexahexaflexágono de una tira de papel.

Amuestra ambos lados de la tira. Los dos triángulos blancos están pegados. Así es como lo flexionarías:

A continuación se muestra un diagrama de posibles estados y sus relaciones:

Los círculos de colores representan los 6 triángulos con el mismo número de la primera imagen. Cada uno de los círculos tiene dos colores: la parte inferior representa la cara posterior (lo que vería si voltea su flexágono), que no tiene que considerar en este desafío.

Los círculos grises en el fondo representan cómo se puede flexionar su flexagon en cualquier estado: hay 4 formas diferentes para flexionar, nosotros llamamos a estas Left, Right, Upy Down. En realidad no se flexiona en estas direcciones, lo importante es que algunos son opuestos entre sí.
Si estás en el centro puedes usar Lefty Rightpara ir a los otros centros. Para salir del centro usas Upy Down. Si no estás en el centro no puedes usarLefto Right.

Left/Down = clockwise
Right/Up  = anti-clockwise

Desafío

Cree una función o programa que tome como entrada lo que debería estar en las 18 caras frontales y las 18 caras posteriores de un flexágono, una secuencia de flexiones izquierda, derecha, arriba y abajo, y devuelva las 8 caras visibles después de las flexiones.

Ejemplo de cálculo elaborado:

flex "hexaflexaperplexia" 
     "flexagationdevices" 
     [Right, Right, Left]

Divide a strip of paper into 18 triangles:
1/2\3/1\2/3\1/2\3/1\2/3\1/2\3/1\2/3   Front
4/4\5/5\6/6\4/4\5/5\6/6\4/4\5/5\6/6   Back

Write "hexaflexaperplexia" on the front of the paper strip:
1/2\3/1\2/3\1/2\3/1\2/3\1/2\3/1\2/3

hexaflexaperplexia
123123123123123123
h  a  e  p  p  x     Face 1, Initially the front face
 e  f  x  e  l  i    Face 2, Initially the back face
  x  l  a  r  e  a   Face 3, Initially hidden


Write "flexagationdevices" on the back of the paperstrip:
4/4\5/5\6/6\4/4\5/5\6/6\4/4\5/5\6/6

flexagationdevices
445566445566445566
fl    at    ev       Face 4, up from 3
  ex    io    ic     Face 5, up from 2
    ag    nd    es   Face 6, up from 1


Flex it [Right, Right, Left]
  The initial visible face is 1: "haeppx"
  flexing Right ..
  The current visible face is 2: "efxeli"
  flexing Right ..
  The current visible face is 3: "xlarea"
  flexing Left ..
  The current visible face is 2: "efxeli"
  flexed [Right, Right, Left]!

outputting "efxeli"

Implementación de ejemplo: http://jdoodle.com/a/18A

Entrada y salida esperada:

> hexaflexaperplexia flexagationdevices RRL
= efxeli

> loremipsumdolorsit hexaflexamexicania RUU
= riuort

> abcdefghijklmnopqr stuvwxyz1234567890 UL
= I can't flex that way :(

> abcdefghijklmnopqr stuvwxyz1234567890 RRRRLLUDDUUUULDD
= uv1278

Reglas

• Puede tomar la entrada y devolver la salida de cualquier manera razonable
• Si la entrada es imposible, debe indicarlo de una manera distinta de la salida normal
• Se aplican lagunas estándar
• Esto es Codegolf. El código más corto en bytes gana.

Haskell (Lambdabot), 270 234 bytes

(!)=((map(snd<$>).groupBy((.fst).(==).fst).sortOn fst).).zip.cycle
o n(a,b)|n>1||b<1=(mod(a+[-1,1,0,0]!!n)3,mod(b+[0,0,-1,1]!!n)3)
(x&y)d|(g,h)<-foldl(flip(.))id(o<$>d)(0,0)=([0,1,2]!x++[3,3,4,4,5,5]!y)!!([0,5,1,1,4,2,2,3,0]!!(3*g+h))

Uso:

> (&) "hexaflexaperplexia" "flexagationdevices" [1,3]
"exioic"

[0,1,2,3] = [izquierda, derecha, arriba, abajo] ¡

Gracias a @Damien por muchos bytes!