Tirando los dados

Entonces, estaba tirando dados hace un tiempo y pensé en un desafío.

Dado el cubo con una red tomada de la entrada y una lista de movimientos, encuentre el cuadrado en la parte inferior al final.

Usaré esta imagen para los ejemplos aquí.

Entrada

Usted toma una cadena con una lista de movimientos. La cadena contiene solo las letras mayúsculas ASCII N, S, W y E. Estas corresponden a rodar el cubo un paso en esa dirección.

En la imagen, una N colocaría la cara inferior como 6. En esta imagen, el Norte está lejos de la cámara, el Sur está hacia, el Este está a la derecha y el Oeste está a la izquierda.

También toma una cadena en el siguiente formato: 1P 2P 3P 4P 5P 6P, donde cada P es una posición de N, S, W, E, T y B. T y B son inferiores y superiores.

Los números son la cara con ese número, y la letra representa la posición en la que se encuentra la cara. En caso de que no esté claro, la red siempre estará ordenada por el número, por lo que 1P 2P 3P 4P 5P 6P, nunca 2B 1T 3N 4S 5W 6E.

La posición en la imagen es 1S 2B 3E 4W 5T 6N.

Salida

Su programa debería generar un número que represente el lado inferior.

Casos de prueba

(nothing), 1S 2B 3E 4W 5T 6N -> 2
N, 1S 2B 3E 4W 5T 6N -> 6
NS, 1S 2B 3E 4W 5T 6N -> 2
NWS, 1S 2B 3E 4W 5T 6N -> 2
NWSNWS, 1S 2B 3E 4W 5T 6N -> 2
NWSS, 1S 2B 3E 4W 5T 6N -> 3
NNNNNN, 1S 2B 3E 4W 5T 6N -> 5
SNWEEWS, 1N 2T 3E 4W 5B 6S, 6
SNEEWS, 1N 2T 3W 4S 5B 6E, 4

Otras reglas

También puede suponer que el cubo está en un plano plano infinito, probablemente con algún tipo de fricción.

Lagunas estándar no permitidas, aunque no puedo encontrar ninguna.

Para una entrada no válida, su código puede hacer cualquier cosa excepto iniciar el apocalipsis.

Debido a que este programa debe caber en mis dados, debe ser lo más pequeño posible. Cuento en bytes, con algunas excepciones para idiomas como Carpetas .

CJam, 43 40 37 34 bytes

Gracias a Dennis por ayudarme a ahorrar 6 bytes.

lW%3/$1f=q{i8%"ÉĔɠƂ!"=i\m!=}/c

Pruébalo aquí.

Explicación

lW%    e# Read the first line and reverse it.
S/     e# Split it around spaces.
$      e# Sort it. This puts the faces in order [B E N S T W].
1f=    e# Select the second character from each face, which is the number.
q      e# Read the remainder of the input (the instructions).
{      e# For each instruction...
  i8%  e#   Convert the character (NWSE) to an integer and take modulo 8.
  "ÉĔɠƂ!"=i
       e#   Use that to (cyclically) index this string and convert *that* character
       e#   to an integer.
  \    e#   Swap with the list of faces.
  m!   e#   Generate all permutations of the faces.
  =    e#   Select the permutation corresponding to the above integer.
}/     e# At the end of the loop, the bottom face will be the first character.
c      e# Convert the string to a character, which discards everything but the bottom face.

En cuanto a cómo funciona la asignación de caracteres de instrucción a permutaciones, aquí hay una tabla práctica:

   i   8%  5%  ""=   i   [0 1 2 3 4 5]m!=

N  78   6   1   Ĕ   276  [2 1 4 0 3 5]
W  87   7   2   ɠ   608  [5 0 2 3 1 4]
S  83   3   3   Ƃ   386  [3 1 0 4 2 5]
E  69   5   0   É   201  [1 4 2 3 5 0]

He incluido la 5%columna porque eso es lo que la indexación cíclica en la cadena hace implícitamente. Para las cuatro permutaciones podemos ver que cada una de ellas deja intactos dos lados (opuestos) y permuta cíclicamente a los otros cuatro.

Perl, 166 158 154 144 139 135 134 132 116 bytes

incluye +1 para -p

s/(\d)(.)/$h{$2}=$1/eg;$N='NTSB',$S='STNB',$E='ETWB',$W='WTEB';map{@h{@l}=@h{(@l=$$_=~/./g)[1..3,0]}}/\w/g;$_=$h{B}

Con comentarios:

                                    # example input: "NS, 1S 2B 3E 4W 5T 6N"
s/(\d)(.)/$h{$2}=$1/eg;             # construct %h ( S=>1, B=>2, E=>3, W=>4, B=>2, N=>6 )

                                    # = Transformations =
$N='NTSB',                          # N becomes T, T becomes S, S becomes B, B becomes N
$S='STNB',
$E='ETWB',
$W='WTEB';

map {                               # iterate the moves "NS"
    @h{ @l } =                      # LHS: bulk-assign new values; @l defined in RHS
      @h{                           # RHS: init @l, transform
          (@l=$$_=~/./g)            # get transform, put ('N','T','S','B') in @l for LHS
          [1..3,0]                  # construct a rotated slice for RHS
    }    
} /\w/g;                            # match the movements in list context

$_=$h{B}                            # assign the bottom face to output.

, 1S 2B 3E 4W 5T 6N
N, 1S 2B 3E 4W 5T 6N
NS, 1S 2B 3E 4W 5T 6N
NWS, 1S 2B 3E 4W 5T 6N
NWSNWS, 1S 2B 3E 4W 5T 6N
NWSS, 1S 2B 3E 4W 5T 6N
NNNNNN, 1S 2B 3E 4W 5T 6N
SNWEEWS, 1N 2T 3E 4W 5B 6S
SNEEWS, 1N 2T 3W 4S 5B 6E

Corre con

perl -p dice.pl < input.txt

Salida: 262223564

• actualización 158 El uso de $N, $S, $E, $Wvariables globales en lugar de %t = {N=>, S=>, E=>, $W=>}guardar 8 bytes.

• actualización 154 Dado que el requisito es que la salida del programa un número, no la impresión de la nueva línea print "$h{B}\n"ahorra 4 bytes: print $h{B}.

• actualización 144 Ahorre 10 bytes haciendo

  ($s)=/^(\w+),/;            s/(\d)(.)/$h{$2}=$1/eg;
  

  en lugar de

  ($s,@i)=split /,? |\n/;    %h=reverse map{split//}@i;
  

• actualización 139 Mueva la expresión regular para el comando hasta el final para eliminar una variable, ahorrando 6 bytes.

• actualización 135 Guardar 4 bytes en @l[0..3,0]lugar de @l[1..3],$l[0].

• actualizar 134 Guardar 1 byte utilizando la asignación @l=split//,$$_como valor.

• actualización 132 Ahorre 2 bytes haciendo en /^\w+/ && $&lugar de /^(\w+)/ && $1.

• actualización 129 Ahorre 3 bytes usando en -plugar de -ny asignando $ _ para imprimir.

• actualización 116 Guardar 13 bytes reescribiendo split//, /^\w+/ && $&en /^\w+/g.

Python 2, 204 bytes

Pensé que era hora de responder a mi propia pregunta.

def x(p,m):
    d={p[3*i-2]:i for i in range(1,7)}
    for j in m:n=2if j in'NE'else-2;x='BSTN'if j in'NS'else'BETW';d[x[0]],d[x[1]],d[x[2]],d[x[3]]=d[x[1+n]],d[x[(2+n)%4]],d[x[(3+n)%4]],d[x[0+n]]
    print d['B']

No muy corto, pero funciona.

Correr como:

x('1B 2T 3N 4S 5W 6E','SNEEWS')
#Output: 4

Editar : bytes contados incorrectos. Ahora mas largo. :(