Rolando os dados

Então, eu estava lançando dados há um tempo e pensei em um desafio.

Dado o cubo com uma rede retirada da entrada e uma lista de movimentos, encontre o quadrado na parte inferior no final.

Vou usar esta imagem para os exemplos aqui.

Entrada

Você pega uma sequência com uma lista de movimentos. A sequência contém apenas as letras maiúsculas ASCII N, S, W e E. Elas correspondem a rolar o cubo um passo nessa direção.

Na figura, um N tornaria a face inferior de 6. Nesta imagem, o Norte está longe da câmera, o Sul está na direção, o Leste está à direita e o Oeste está à esquerda.

Você também pode inserir uma sequência no seguinte formato: 1P 2P 3P 4P 5P 6P, em que cada P é uma posição de N, S, W, E, T e B. As notas T e B são inferior e superior.

Os números são a face com esse número e a letra representa a posição em que a face se encontra. Caso não esteja claro, a rede será sempre ordenada pelo número, portanto, 1P 2P 3P 4P 5P 6P, nunca 2B 1T 3N 4S 5W 6E.

A posição na imagem é 1S 2B 3E 4W 5T 6N.

Resultado

Seu programa deve gerar um número representando o lado inferior.

Casos de teste

(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

Outras regras

Você também pode assumir que o cubo está em um plano plano infinito, provavelmente com algum tipo de atrito.

As brechas padrão não são permitidas, apesar de não encontrar nenhuma.

Para entrada inválida, seu código pode fazer qualquer coisa, exceto iniciar o apocalipse.

Como esse programa deve caber nos meus dados, deve ser o menor possível. Conto em bytes, com algumas exceções para idiomas como pastas .

CJam, 43 40 37 34 bytes

Agradeço ao Dennis por me ajudar a economizar 6 bytes.

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

Teste aqui.

Explicação

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.

Quanto ao funcionamento do mapeamento de caracteres de instrução para permutações, aqui está uma tabela útil:

   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]

Eu incluí a 5%coluna porque é isso que a indexação cíclica na string faz implicitamente. Nas quatro permutações, podemos ver que cada uma delas deixa dois lados (opostos) intocados e permuta ciclicamente os outros quatro.

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

inclui +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}

Com comentários:

                                    # 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

Correr com

perl -p dice.pl < input.txt

Resultado: 262223564

• atualização 158 O uso de $N, $S, $E, $Wvariáveis ​​globais em vez de %t = {N=>, S=>, E=>, $W=>}salva 8 bytes.

• update 154 Uma vez que a exigência é que a saída do programa um número, não a impressão da nova linha print "$h{B}\n"salva 4 bytes: print $h{B}.

• atualização 144 Economize 10 bytes fazendo

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

  ao invés de

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

• atualização 139 Mova a expressão regular para o comando até o final para eliminar uma variável, economizando 6 bytes.

• atualização 135 Salve 4 bytes em @l[0..3,0]vez de @l[1..3],$l[0].

• atualização 134 Salve 1 byte usando a atribuição @l=split//,$$_como valor.

• atualização 132 Salve 2 bytes fazendo em /^\w+/ && $&vez de /^(\w+)/ && $1.

• atualização 129 Salve 3 bytes usando em -pvez de -ne atribuindo $ _ para impressão.

• atualização 116 Salve 13 bytes reescrevendo split//, /^\w+/ && $&para /^\w+/g.

Python 2, 204 bytes

Achei que era hora de responder à minha própria pergunta.

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']

Não é muito curto, mas funciona.

Correr como:

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

Editar : bytes contados incorretos. Agora mais. :(