Essendo programmatori, guardarci flettere non è molto interessante. Oggi lo cambiamo! In questa sfida farai esx e fletti gli esaflexagoni.

Di

Per un'introduzione video, guarda i video di Viharts sui flexagon

Un flexagon è una forma che puoi flettere per rivelare facce diverse da quella superiore e inferiore; stiamo realizzando un hexahexaflexagon, che ha 6 facce. Vedi l'immagine qui sotto su come piegare un hexahexaflexagon da una striscia di carta.

Amostra entrambi i lati della striscia. I due triangoli bianchi sono incollati insieme. Ecco come lo fletteresti:

Di seguito è riportato un diagramma dei possibili stati e delle loro relazioni:

I cerchi colorati rappresentano i 6 triangoli con lo stesso numero della prima immagine. Ognuno dei cerchi ha due colori: il fondo rappresenta la faccia posteriore (cosa vedresti se capovolgi il tuo flexagon), che non devi considerare in questa sfida.

I cerchi grigi sullo sfondo rappresentano come si può flettere i flexagon in un determinato Stato: ci sono 4 modi diversi di flettersi, noi chiamiamo questi Left, Right, Upe Down. In realtà non ti fletti in queste direzioni, l'importante è che alcuni siano opposti.
Se sei al centro puoi usare Lefte Rightandare agli altri al centro. Per uscire dal centro che usi Upe Down. Se non sei al centro non puoi usarloLeftoppure Right.

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

Sfida

Crea una funzione o un programma che prenda come input ciò che dovrebbe essere sulle 18 facce anteriori e sulle 18 facce posteriori di un flexagon, una sequenza di flessioni sinistra, destra, su e giù, e restituisce le 8 facce visibili dopo le flessioni.

Calcolo di esempio elaborato:

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"

Esempio di implementazione: http://jdoodle.com/a/18A

Input e output attesi:

> hexaflexaperplexia flexagationdevices RRL
= efxeli

> loremipsumdolorsit hexaflexamexicania RUU
= riuort

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

> abcdefghijklmnopqr stuvwxyz1234567890 RRRRLLUDDUUUULDD
= uv1278

Regole

• È possibile accettare input e restituire output in modo ragionevole
• Se l'input è impossibile, è necessario indicarlo in qualche modo distinto dall'output normale
• Si applicano scappatoie standard
• Questo è Codegolf. Il codice più corto in byte vince.

Haskell (Lambdabot), 270 234 byte

(!)=((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] = [sinistra, destra, su, giù]

Grazie a @Damien per molti byte!