Lancer les dés

Donc, je jetais des dés il y a un moment et j'ai pensé à un défi.

Étant donné le cube avec un filet pris en entrée et une liste de mouvements, trouvez le carré en bas à la fin.

J'utiliserai cette image pour les exemples ici.

Contribution

Vous prenez une chaîne avec une liste de mouvements. La chaîne contient uniquement les lettres majuscules ASCII N, S, W et E. Celles-ci correspondent au roulement du cube d'un pas dans cette direction.

Dans l'image, un N ferait la face inférieure un 6. Dans cette image, le Nord est loin de la caméra, le Sud est vers, l'Est est à droite et l'Ouest est à gauche.

Vous prenez également une chaîne au format suivant: 1P 2P 3P 4P 5P 6P, où chaque P est une position de N, S, W, E, T et B. T & B sont en bas et en haut.

Les chiffres sont le visage avec ce numéro, et la lettre représente la position du visage. Dans le cas où ce n'est pas clair, le filet sera toujours ordonné par le numéro, donc 1P 2P 3P 4P 5P 6P, jamais 2B 1T 3N 4S 5W 6E.

La position dans l'image est 1S 2B 3E 4W 5T 6N.

Production

Votre programme devrait sortir un nombre représentant le côté inférieur.

Cas de test

(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

Autres règles

Vous pouvez également supposer que le cube est sur un plan plat infini, probablement avec une sorte de friction.

Les failles standard interdites, même si je n'en trouve aucune.

Pour une entrée invalide, votre code peut faire autre chose que démarrer l'apocalypse.

Parce que ce programme devrait tenir sur mes dés, il devrait être aussi petit que possible. Je compte en octets, à quelques exceptions près pour les langues comme les dossiers .

CJam, 43 40 37 34 octets

Merci à Dennis de m'avoir aidé à économiser 6 octets.

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

Testez-le ici.

Explication

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 ce qui concerne le fonctionnement du mappage des caractères d'instruction aux permutations, voici un tableau pratique:

   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]

J'ai inclus la 5%colonne parce que c'est ce que fait l'indexation cyclique dans la chaîne implicitement. Pour les quatre permutations, nous pouvons voir que chacune d'elles laisse deux côtés (opposés) intacts et permute cycliquement les quatre autres.

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

comprend +1 pour -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}

Avec commentaires:

                                    # 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

Courir avec

perl -p dice.pl < input.txt

Production: 262223564

• update 158 L' utilisation de $N, $S, $E, $Wvariables globales au lieu d' %t = {N=>, S=>, E=>, $W=>}économiser 8 octets.

• mise à jour 154 Étant donné que l'exigence est que la sortie du programme un numéro, pas l' impression de la nouvelle ligne print "$h{B}\n"permet d' économiser 4 octets: print $h{B}.

• mise à jour 144 Économisez 10 octets en faisant

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

  au lieu de

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

• update 139 Déplacez le regex de la commande à la fin pour éliminer une variable, économisant 6 octets.

• mise à jour 135 Enregistrez 4 octets sur @l[0..3,0]au lieu de @l[1..3],$l[0].

• update 134 Enregistrez 1 octet en utilisant l'affectation @l=split//,$$_comme valeur.

• mise à jour 132 Enregistrez 2 octets en faisant /^\w+/ && $&au lieu de /^(\w+)/ && $1.

• mettre à jour 129 Enregistrer 3 octets en utilisant au -plieu de -net attribuer $ _ pour l' impression.

• mise à jour 116 Enregistrer 13 octets en réécrivant split//, /^\w+/ && $&dans /^\w+/g.

Python 2, 204 octets

J'ai pensé qu'il était temps de répondre à ma propre question.

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

Pas très court, mais ça marche.

Courir comme:

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

Modifier : nombre d'octets incorrect. Maintenant plus longtemps. :(