Lancio dei dadi

Quindi, stavo lanciando i dadi qualche tempo fa e ho pensato a una sfida.

Dato il cubo con una rete presa dall'input e un elenco di mosse, trova il quadrato in fondo alla fine.

Userò questa immagine per gli esempi qui.

Ingresso

Prendi una stringa con un elenco di mosse. La stringa contiene solo le lettere ASCII maiuscole N, S, W ed E. Queste corrispondono al rotolamento del cubo di un passo in quella direzione.

Nella foto, una N renderebbe la faccia inferiore a 6. In questa immagine, il Nord è lontano dalla fotocamera, il Sud è verso, l'Est è giusto e l'Ovest è lasciato.

Prendi anche una stringa nel seguente formato: 1P 2P 3P 4P 5P 6P, dove ogni P è una posizione tra N, S, W, E, T e B. T & B sono in basso e in alto.

I numeri sono la faccia con quel numero e la lettera rappresenta la posizione in cui si trova la faccia. Nel caso in cui non sia chiara, la rete sarà sempre ordinata dal numero, quindi 1P 2P 3P 4P 5P 6P, mai 2B 1T 3N 4S 5W 6E.

La posizione nell'immagine è 1S 2B 3E 4W 5T 6N.

Produzione

Il tuo programma dovrebbe generare un numero che rappresenta il lato inferiore.

Casi 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

Altre regole

Puoi anche supporre che il cubo si trovi su un piano piatto infinito, probabilmente con una sorta di attrito.

Scappatoie standard non consentite, anche se non riesco a trovarne.

Per input non validi, il tuo codice potrebbe fare qualsiasi cosa tranne avviare l'apocalisse.

Poiché questo programma dovrebbe adattarsi ai miei dadi, dovrebbe essere il più piccolo possibile. Conto in byte, con alcune eccezioni per le lingue come Cartelle .

CJam, 43 40 37 34 byte

Grazie a Dennis per avermi aiutato a salvare 6 byte.

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

Provalo qui.

Spiegazione

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.

Per quanto riguarda il modo in cui funziona la mappatura dei caratteri di istruzione alle permutazioni, ecco una tabella pratica:

   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]

Ho incluso la 5%colonna perché è quello che fa implicitamente l'indicizzazione ciclica nella stringa. Per le quattro permutazioni possiamo vedere che ognuna di esse lascia intatte due lati (opposti) e permuta ciclicamente le altre quattro.

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

include +1 per -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 commenti:

                                    # 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

Corri con

perl -p dice.pl < input.txt

Produzione: 262223564

• aggiornamento 158 L' uso di $N, $S, $E, $Wvariabili globali invece di %t = {N=>, S=>, E=>, $W=>}salvare 8 byte.

• aggiornamento 154 Poiché il requisito è che l'uscita programma un numero, non stampa il newline print "$h{B}\n"salva 4 byte: print $h{B}.

• aggiornamento 144 Salvare 10 byte facendo

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

  invece di

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

• aggiornamento 139 Spostare la regex per il comando alla fine per eliminare una variabile, salvando 6 byte.

• aggiornamento 135 Salva 4 byte su @l[0..3,0]anziché @l[1..3],$l[0].

• aggiornamento 134 Salvare 1 byte utilizzando l'assegnazione @l=split//,$$_come valore.

• aggiornamento 132 Salvare 2 byte facendo /^\w+/ && $&invece di /^(\w+)/ && $1.

• aggiornamento 129 Salvare 3 byte utilizzando -pinvece di -ne assegnando $ _ per la stampa.

• aggiornamento 116 Salva 13 byte riscrivendoli split//, /^\w+/ && $&in /^\w+/g.

Python 2, 204 byte

Ho pensato che fosse tempo di rispondere alla mia domanda.

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

Non molto corto, ma funziona.

Correre come:

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

Modifica : byte conteggiati errati. Adesso più a lungo. :(