Rzucanie kostką

Więc rzuciłem kostką jakiś czas temu i pomyślałem o wyzwaniu.

Biorąc pod uwagę sześcian z siatką pobraną z danych wejściowych i listą ruchów, znajdź kwadrat na dole na końcu.

Użyję tego obrazu do przykładów tutaj.

Wejście

Bierzesz ciąg z listą ruchów. Ciąg zawiera tylko duże litery ASCII N, S, W i E. Odpowiadają one zwinięciu kostki o jeden krok w tym kierunku.

Na zdjęciu jedna litera N sprawiłaby, że dolna ściana ma wartość 6. Na tym zdjęciu północ jest z dala od kamery, południe jest w kierunku, wschód jest w prawo, a zachód jest w lewo.

Możesz również wziąć ciąg w następującym formacie: 1P 2P 3P 4P 5P 6P, gdzie każdy P jest pozycją z N, S, W, E, T i B. T & B są na dole i na górze.

Liczby są twarzą z tym numerem, a litera oznacza pozycję, w której znajduje się twarz. W przypadku, gdy nie jest jasne, sieć zawsze będzie uporządkowana według numeru, więc 1P 2P 3P 4P 5P 6P, nigdy 2B 1T 3N 4S 5W 6E.

Pozycja na zdjęciu to 1S 2B 3E 4W 5T 6N.

Wynik

Twój program powinien wypisać liczbę reprezentującą dolną stronę.

Przypadki testowe

(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

Inne zasady

Możesz również założyć, że sześcian znajduje się na nieskończonej płaskiej płaszczyźnie, prawdopodobnie z pewnym rodzajem tarcia.

Standardowe luki zabronione, chociaż nie mogę ich znaleźć.

W przypadku nieprawidłowych danych wejściowych kod może zrobić wszystko oprócz rozpoczęcia apokalipsy.

Ponieważ ten program powinien pasować na moje kości, powinien być jak najmniejszy. Liczę w bajtach, z pewnymi wyjątkami dla języków takich jak Foldery .

CJam, 43 40 37 34 bajtów

Dzięki Dennis za pomoc w oszczędzeniu 6 bajtów.

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

Sprawdź to tutaj.

Wyjaśnienie

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.

Jeśli chodzi o sposób odwzorowywania znaków instrukcji na permutacje, oto przydatna tabela:

   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]

Uwzględniłem 5%kolumnę, ponieważ to właśnie robi niejawne indeksowanie cykliczne w ciągu. W przypadku czterech permutacji widzimy, że każda z nich pozostawia dwie (przeciwne) strony nietknięte i cyklicznie permutuje pozostałe cztery.

Perl, 166 158 154 144 139 135 134 132 116 116 bajtów

zawiera +1 dla -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}

Z komentarzami:

                                    # 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

Biegnij z

perl -p dice.pl < input.txt

Wynik: 262223564

• aktualizacja 158 Używanie $N, $S, $E, $Wzmiennych globalnych zamiast %t = {N=>, S=>, E=>, $W=>}zapisywania 8 bajtów.

• Aktualizacja 154 Od wymogiem jest to, że wyjście programu liczbą, nie drukując przełamane print "$h{B}\n"oszczędza 4 bajty: print $h{B}.

• aktualizacja 144 Zaoszczędź 10 bajtów

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

  zamiast

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

• aktualizacja 139 Przenieś regex polecenia do końca, aby wyeliminować zmienną, oszczędzając 6 bajtów.

• aktualizacja 135 Zapisz 4 bajty @l[0..3,0]zamiast @l[1..3],$l[0].

• aktualizacja 134 Zapisz 1 bajt, używając przypisania @l=split//,$$_jako wartości.

• aktualizacja 132 Zapisz 2 bajty, wykonując /^\w+/ && $&zamiast /^(\w+)/ && $1.

• aktualizacja 129 Zaoszczędź 3 bajty, używając -pzamiast -ni przypisując $ _ do drukowania.

• aktualizacja 116 Zapisz 13 bajtów, przepisując split//, /^\w+/ && $&do /^\w+/g.

Python 2, 204 bajty

Myślałem, że nadszedł czas, aby odpowiedzieć na moje własne pytanie.

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

Niezbyt krótki, ale działa.

Uruchom jako:

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

Edycja : Niepoprawne zliczanie bajtów. Teraz dłużej. :(