Lăn xúc xắc

Vì vậy, tôi đã gieo xúc xắc một lúc trước và nghĩ về một thử thách.

Cho khối lập phương có một mạng được lấy từ đầu vào và một danh sách các bước di chuyển, tìm hình vuông ở phía dưới ở cuối.

Tôi sẽ sử dụng hình ảnh này cho các ví dụ ở đây.

Đầu vào

Bạn lấy một chuỗi với một danh sách các di chuyển. Chuỗi chỉ chứa các chữ cái ASCII viết hoa N, S, W và E. Chúng tương ứng với việc lăn khối lập phương một bước theo hướng đó.

Trong ảnh, một N sẽ biến mặt dưới thành 6. Trong ảnh này, North cách xa máy ảnh, Nam hướng về phía đông, Đông ở bên phải và Tây ở bên trái.

Bạn cũng nhận một chuỗi theo định dạng sau: 1P 2P 3P 4P 5P 6P, trong đó mỗi P là một vị trí từ N, S, W, E, T và B. T & B là dưới cùng và trên cùng.

Các số là mặt có số đó và chữ cái thể hiện vị trí của mặt đó. Trong trường hợp không rõ ràng, mạng sẽ luôn được sắp xếp theo số, vì vậy 1P 2P 3P 4P 5P 6P, không bao giờ là 2B 1T 3N 4S 5W 6E.

Vị trí trong ảnh là 1S 2B 3E 4W 5T 6N.

Đầu ra

Chương trình của bạn sẽ xuất ra một số đại diện cho phía dưới.

Các trường hợp thử nghiệm

(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

Các quy tắc khác

Bạn cũng có thể giả sử khối lập phương nằm trên một mặt phẳng vô hạn, có thể có một loại ma sát nào đó.

Các sơ hở tiêu chuẩn không được phép, mặc dù tôi không thể tìm thấy bất kỳ.

Đối với đầu vào không hợp lệ, mã của bạn có thể làm bất cứ điều gì ngoại trừ bắt đầu ngày tận thế.

Bởi vì chương trình này phải phù hợp với súc sắc của tôi, nên nó càng nhỏ càng tốt. Tôi đếm bằng byte, với một số ngoại lệ cho các ngôn ngữ như Thư mục .

CJam, 43 40 37 34 byte

Cảm ơn Dennis đã giúp tôi tiết kiệm 6 byte.

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

Kiểm tra nó ở đây.

Giải trình

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.

Về cách ánh xạ các ký tự chỉ dẫn đến hoán vị hoạt động, đây là một bảng tiện dụng:

   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]

Tôi đã bao gồm 5% cột bởi vì đó là những gì mà việc lập chỉ mục theo chu kỳ vào chuỗi không hoàn toàn. Đối với bốn hoán vị, chúng ta có thể thấy rằng mỗi trong số chúng để lại hai mặt (đối diện) không bị ảnh hưởng và hoán vị theo chu kỳ bốn mặt còn lại.

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

bao gồm +1 cho -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}

Với nhận xét:

                                    # 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

Chạy với

perl -p dice.pl < input.txt

Đầu ra: 262223564

• cập nhật 158 Sử dụng $N, $S, $E, $Wbiến toàn cục thay vì%t = {N=>, S=>, E=>, $W=>} tiết kiệm 8 byte.

• cập nhật 154 Vì yêu cầu là chương trình xuất ra một số, không in dòng mới sẽ print "$h{B}\n"tiết kiệm 4 byte:print $h{B} .

• cập nhật 144 Lưu 10 byte bằng cách thực hiện

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

  thay vì

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

• cập nhật 139 Di chuyển regex cho lệnh đến hết để loại bỏ một biến, tiết kiệm 6 byte.

• cập nhật 135 Lưu 4 byte @l[0..3,0]thay vì @l[1..3],$l[0].

• cập nhật 134 Lưu 1 byte bằng cách sử dụng gán @l=split//,$$_làm giá trị.

• cập nhật 132 Lưu 2 byte bằng cách thực hiện /^\w+/ && $&thay vì/^(\w+)/ && $1 .

• cập nhật 129 Lưu 3 byte bằng cách sử dụng -pthay vì-n và gán $ _ để in.

• cập nhật 116 Lưu 13 byte bằng cách viết lại split//, /^\w+/ && $&vào /^\w+/g.

Python 2, 204 byte

Nghĩ rằng đã đến lúc trả lời câu hỏi của riêng tôi.

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

Không ngắn lắm, nhưng hoạt động.

Chạy như:

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

Chỉnh sửa : Đếm byte sai. Bây giờ lâu hơn. :