Würfeln

Also habe ich vor einiger Zeit gewürfelt und an eine Herausforderung gedacht.

Wenn der Würfel ein aus der Eingabe entnommenes Netz und eine Liste von Zügen enthält, finden Sie das Quadrat unten am Ende.

Ich werde dieses Bild für die Beispiele hier verwenden.

Eingang

Sie nehmen eine Zeichenfolge mit einer Liste von Zügen auf. Die Zeichenfolge enthält nur die ASCII-Großbuchstaben N, S, W und E. Diese entsprechen dem Rollen des Würfels um einen Schritt in diese Richtung.

Im Bild würde ein N die Unterseite zu einer 6 machen. In diesem Bild ist Norden von der Kamera entfernt, Süden ist in Richtung, Osten ist rechts und Westen ist links.

Sie können auch eine Zeichenfolge im folgenden Format eingeben: 1P 2P 3P 4P 5P 6P, wobei jedes P eine Position von N, S, W, E, T und B ist. T & B sind unten und oben.

Die Zahlen sind das Gesicht mit dieser Nummer, und der Buchstabe stellt die Position dar, an der sich das Gesicht befindet. Wenn es nicht klar ist, wird das Netz immer nach der Nummer sortiert, also 1P 2P 3P 4P 5P 6P, niemals 2B 1T 3N 4S 5W 6E.

Die Position im Bild ist 1S 2B 3E 4W 5T 6N.

Ausgabe

Ihr Programm sollte eine Zahl ausgeben, die die Unterseite darstellt.

Testfälle

(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

Andere Regeln

Sie können auch annehmen, dass sich der Würfel auf einer unendlichen flachen Ebene befindet, wahrscheinlich mit irgendeiner Reibung.

Standard-Schlupflöcher sind nicht erlaubt, obwohl ich keine finde.

Bei ungültiger Eingabe kann Ihr Code alles tun, außer die Apokalypse zu starten.

Da dieses Programm auf meine Würfel passen sollte, sollte es so klein wie möglich sein. Ich zähle in Bytes, mit einigen Ausnahmen für Sprachen wie Ordner .

CJam, 43 40 37 34 Bytes

Vielen Dank an Dennis, der mir geholfen hat, 6 Bytes zu sparen.

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

Teste es hier.

Erläuterung

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.

Im Folgenden finden Sie eine praktische Tabelle zur Zuordnung von Anweisungszeichen zu Permutationen:

   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]

Ich habe die 5%Spalte eingefügt, da dies implizit durch die zyklische Indizierung in der Zeichenfolge bewirkt wird. Für die vier Permutationen können wir sehen, dass jede von ihnen zwei (gegenüberliegende) Seiten unberührt lässt und die anderen vier zyklisch permutiert.

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

beinhaltet +1 für -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}

Mit Kommentaren:

                                    # 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

Laufen Sie mit

perl -p dice.pl < input.txt

Ausgabe: 262223564

• Update 158 Durch die Verwendung $N, $S, $E, $Wglobaler Variablen werden %t = {N=>, S=>, E=>, $W=>}8 Byte gespart.

• Update 154 Da die Voraussetzung ist , dass das Programm Ausgabe eine Zahl, nicht den Druck des Newline print "$h{B}\n"4 Bytes speichert: print $h{B}.

• update 144 Sparen Sie dabei 10 Bytes

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

  Anstatt von

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

• update 139 Verschieben Sie den regulären Ausdruck für den Befehl ans Ende, um eine Variable zu entfernen und 6 Bytes zu sparen.

• update 135 Sparen Sie 4 Bytes ein @l[0..3,0]statt @l[1..3],$l[0].

• Update 134 Sparen Sie 1 Byte, indem Sie die Zuweisung @l=split//,$$_als Wert verwenden.

• update 132 Sparen Sie 2 Bytes, indem Sie /^\w+/ && $&anstelle von /^(\w+)/ && $1.

• Update 129 Sparen Sie 3 Bytes, indem Sie -panstelle von -n$ _ für den Druck verwenden und zuweisen.

• update 116 Sparen Sie 13 Bytes durch Umschreiben split//, /^\w+/ && $&in /^\w+/g.

Python 2, 204 Bytes

Ich dachte, es wäre Zeit, auf meine eigene Frage zu antworten.

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

Nicht sehr kurz, aber funktioniert.

Rennen wie:

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

Edit : Bytes falsch gezählt. Jetzt länger :(