Super Mario Galaxy có haihành tinh hình thoi * hình thoi * được lát bằng các nền tảng co lại khi Mario chạy ngang qua. Nếu Mario rơi vào một lỗ hình tam giác hoặc một khoảng trống do một viên gạch mà anh ta chạm vào trước đó, anh ta sẽ bị lỗ đen ở lõi tiêu thụ. (Xem: Galaxy Hurry-Scurry , Sea Slide Galaxy )

^{Hình: MarioWiki.com}

(Bạn có thể nghĩ hành tinh này là một khối lập phương 2x2x2 có các mặt được tách ra và kết nối với nhau bằng các "cầu nối" 2x3.)

Thật không may, vì bộ điều khiển của tôi rất hỏng, Mario không thể nhảy và bị giới hạn ở bốn hướng chính. Ngoài ra, Mario di chuyển rất chậm và không thể lấy lại dù chỉ một bước mà không có nền tảng phía sau biến mất.

Giả sử máy ảnh luôn ở trên đầu của Mario và anh ta bắt đầu ở phía dưới bên phải của khuôn mặt 2x2:

      ■ ■
      ■ ■
      ■ ■
■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ M ■ ■ ■
      ■ ■
      ■ ■
      ■ ■

Chương trình của bạn sẽ lấy một danh sách hoặc chuỗi chỉ đường, U D L R(lên, xuống, trái, phải), đại diện cho Mario đi vòng quanh hành tinh cho đến một loạt các bước. Chương trình có thể tạo ra một trong hai kết quả đầu ra khác nhau: một đại diện cho thấy Mario vẫn còn sống và đang đi bộ, và một đại diện khác cho thấy ở đâu đó trên đường đi bộ, Mario đã rơi vào Vệ tinh thu nhỏ.

RR:   ■ ■                 RRD:  ■ ■                 RRL:  ■ ■      
      ■ ■                       ■ ■                       ■ ■      
      ■ ■                       ■ ■                       ■ ■      
■ ■ ■ ■ ■ ■ ■ ■           ■ ■ ■ ■ ■ ■ ■ ■           ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ □ □ M ■           ■ ■ ■ ■ □ □ □ ■           ■ ■ ■ ■ □ M □ ■
      ■ ■    \                  ■ ■   M                   ■ ■  \
      ■ ■     Let's-a go!       ■ ■    \                  ■ ■   W-aaaaaaaaaahh!
      ■ ■                       ■ ■     W-aaaaaaaaaahh!   ■ ■

Tất nhiên, không giống như các sơ đồ trên, bạn sẽ phải tính đến 3D. Đây là một sơ đồ có thể giúp bạn hình dung kịch bản tốt hơn:

                Top 2x2 face
   <- clockwise           anticlockwise ->
   -   ■    -    ■    -    ■    -    ■   -
     /   \     /   \     /   \     /   \  
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■    Left and right
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ M ■ ■ ■ ■ ■ ■ ■ ■ ■    edges wrap around.
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
     \   /     \   /     \   /     \   /  
   -   ■    -    ■    -    ■    -    ■   -
   <- anticlockwise           clockwise ->
               Bottom 2x2 face

Vì vậy, theo sơ đồ này, UUUUURRRRcó thể trông như thế này:

   -   ■    -    ■    -    □    -    ■   -
     /   \     /   \     /   \     /   \  
   ■       ■ ■       ■ □       □ ■       ■
   ■       ■ ■       ■ □       □ ■       ■
   ■       ■ ■       ■ □       □ ■       ■
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ ■ ■ ■ M ■ ■ ■ ■ ■
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
     \   /     \   /     \   /     \   /  
   -   ■    -    ■    -    ■    -    ■   -

Và UUUUUUUUULURRRRRRcó thể trông như thế này:

   -   ■    -    ■    -    □    -    □   -
     /   \     /   \     /   \     /   \  
   ■       ■ ■       ■ □       ■ ■       □
   ■       ■ ■       ■ □       ■ ■       □
-> □       ■ ■       ■ □       ■ ■       □ ->
<- □ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ ■ ■ ■ M □ □ □ □ □ <-
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ □ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
   ■       ■ ■       ■ ■       ■ ■       ■
     \   /     \   /     \   /     \   /  
   -   ■    -    ■    -    ■    -    ■   -

Có thể chương trình ngắn nhất tính bằng byte w-aaaaaaaaaahh!

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

Đầu ra 1: Vẫn còn sống

DDDDDLUUUUU - Mario đi qua một cây cầu và trở lại.

RRRRDDDDLLL - Mario đi trong một hình tam giác.

LLLLLLUUUUUURRRRR - Mario đi trong một hình tam giác lớn hơn.

ULLDRDDDRU - Mario đặt mình vào tình trạng nguy hiểm.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR - Mario đi một con đường độc đáo ... và rơi vào tình trạng nguy hiểm.

Mario vượt qua mọi ô chính xác một lần. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

Kết quả 2: W-aaaaaaaaaahh!

LLR - Mario cố gắng lấy lại một bước và rơi xuống.

UULDR - Mario cố gắng vượt qua một viên gạch hai lần và bước lên không trung.

RRDDDDD - Mario đi ra khỏi cây cầu ở D đầu tiên (bỏ qua mọi bước sau).

RRRRDDDDLLLL - Mario đi trong một hình tam giác và rơi qua gạch bắt đầu.

LLLLLLUUUUUURRRRRR - Mario đi trong một hình tam giác lớn hơn và rơi qua gạch bắt đầu.

UUUUUUUUUUUUUUUUUUUU - Mario đi bộ khắp hành tinh và rơi qua viên gạch bắt đầu.

RURDRURDRDLDRDLDLDLULDLLUU - Mario đi một con đường độc đáo và trở nên mất phương hướng.

Mario, nhận ra sự nguy hiểm mà anh ta đang ở, không còn lựa chọn nào khác.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

Cuối cùng, sao chép bất kỳ trường hợp thử nghiệm nào từ "Mario vượt qua mọi ô chính xác một lần" và thay đổi hoặc thêm một bước ngẫu nhiên. Mario nên gục ngã. (Nếu bạn thêm một bước vào cuối, Mario rơi xuống để lấy Ngôi sao quyền lực!)

_{* Khối lập phương sẽ là một thuật ngữ chính xác hơn vì một số khuôn mặt không vuông, nhưng bạn phải thừa nhận - "rhombicuboctahedron" chảy đẹp hơn.}

Ruby, chơi gôn, 244 230 byte

Có vẻ hoạt động tốt, sẽ kiểm tra thêm một chút.

->s{a=[8**8/5]*8
v=[-1,x=d=0,1,0]
y=m=4
s.chars{|c|a[y]&=~(1<<x) 
y+=v[e="URDL".index(c)+d&3]
x+=v[e-1]
r= ~0**q=x/4
i=q+x&1
j=q+y&1
y%9>7&&(y=4-i;x+=4-j*11-x%2;d+=r)
x&2>0&&-y/2==-2&&(y=i*7;x+=6-x%2*9+j;d-=r)
m*=1&a[y]>>x%=24}
m}

Ruby, phiên bản làm việc đầu tiên, 260 byte

Dùng thử trực tuyến

Hàm Lambda lấy một đối số chuỗi. Trả về 4 cho còn sống, 0 cho chết.

->s{a=[0x333333]*8
v=[0,-1,0,1]
x=d=0
y=m=4
s.chars{|c|a[y]&=~(1<<x) 
e="URDL".index(c)+d
x+=v[e%4]
y+=v[-~e%4]
p=x&-2
q=x/4%2
y%9>7&&(d-=q*2-1;y,x=4-(q+x)%2,(p+4-(q+y)%2*11)%24)
x&2>0&&-y/2==-2&&(y,x=(q+x)%2*7,(p+6-x%2*8+(q+y)%2)%24;d+=q*2-1)
m*=a[y]>>x&1}
m}

Giải trình

Bảng được mở ra thành 6 dải kích thước 2x8, được thể hiện bằng /\và các Oký tự bên dưới. Chúng được ánh xạ lên bản đồ 2D 24 * 8, trong đó x = (số dải) * 4 + (vị trí ngang trên dải) và y = vị trí dọc trên dải.

       Map        4         2         0          Initial state of array a
                 /         /         /   
                / /       / /       / /          1100110011001100110011
               / /       / /       / /           1100110011001100110011 
              O /       O /       O /            1100110011001100110011
             O O       O O       O O             1100110011001100110011
      \     / O \     / O \     / X              110011001100110011001X
     \ \   / / \ \   / / \ \   / /               1100110011001100110011
      \ \ / /   \ \ / /   \ \ / /                1100110011001100110011
       \ O /     \ O /     \ O /                 1100110011001100110011
        O O       O O       O O 
         O \       O \       O \                 X=Mario's start point 
          \ \       \ \       \ \  
           \ \       \ \       \ \    
            \         \         \
             5         3         1

Chúng được lưu trữ trong một mảng gồm 8 số nhị phân, vì vậy x tăng sang trái và y tăng xuống.

Các mảng được intialized với 8 bản sao của số 0x33333333. Điều này tạo thành các hình vuông Mario được phép bước lên. Khi Mario di chuyển xung quanh hình vuông, anh ta đang ở vị trí 0 và hình vuông anh ta đang di chuyển được kiểm tra - anh ta sống ở đó chứa 1 và chết nếu nó chứa 0.

Nếu Mario đi ra khỏi đỉnh hoặc đáy của dải anh ta đang ở, anh ta chuyển sang dải khác. Nếu anh ta đi ra khỏi phía của dải anh ta đang ở, nếu anh ta ở trên một hình vuông có y = 3 hoặc y = 4 anh ta chuyển sang dải khác. Nếu y không phải là 3 hoặc 4, anh ta không di chuyển đến một dải khác và kết thúc trên một hình vuông có 0 trong đó từ đầu trò chơi, vì vậy anh ta chết.

Bởi vì máy ảnh luôn ở trên đầu của Mario, bất cứ khi nào Mario thay đổi dải, tham chiếu cho các hướng phải được xoay 90 độ.

Ungolfed trong chương trình thử nghiệm

f=->s{                             #Move sequence is taken as string argument s.
  a=[0x333333]*8                   #Setup board as an array of 8 copies of 1100110011001100110011.
  v=[0,-1,0,1]                     #Displacements for moving.
  x=d=0                            #Mario starts at 0,4.
  y=m=4                            #d=offset for directions. m=4 when Mario is alive (value chosen for golfing reasons) 0 when dead.

  s.chars{|c|                      #For each character c in s
    a[y]&=~(1<<x)                  #Set the square where Mario is to 0.

    e="URDL".index(c)+d            #Decode the letter and add the offset 
    x+=v[e%4]                      #x movement direction is v[e%4]   
    y+=v[-~e%4]                    #y movement direction is v[(e+1)%4]
    p=x&-2                         #p is a copy of x with the last bit set to zero (righthand edge of strip).
    q=x/4%2                        #q is 0 for an even number strip, 1 for an odd number strip.
    y%9>7&&(                       #If y out of bounds (8 or -1)
      d-=q*2-1;                    #Adjust d so directions will be interpreted correctly on the next move.
      y,x=
        4-(q+x)%2,                 #y becomes 3 or 4 depending on the values of q and x.
        (p+4-(q+y)%2*11)%24        #If q+y is even, move 1 strip left. if even, move 2 strips right. Take x%24.  
    )
    x&2>0&&-y/2==-2&&(             #If x&2>0 Mario has walked sideways off a strip. If y is 3 or 4, move him to a different strip.
      y,x=                       
        (q+x)%2*7,                 #y becomes 0 or 7, depending on the values of q and x.
        (p+6-x%2*8+(q+y)%2)%24;    #If x%2 is even, move 2 strips left. If odd, move 1 strip right*. Pick the left or right column of the strip depending on (q+y)%2. Take x%24 
        d+=q*2-1                   #Adjust d so directions will be interpreted correctly on the next move.
    )

    m*=a[y]>>x&1                   #Multiply m by the value (0 or 1) of the current square. Mario is either alive (4) or dead (0).  
    #puts x,y,m,a.map{|i|"%022b"%i}#Uncomment this line for diagnostics.
  }
m}                                 #Return value of m.  


#Still alive, return value 4
puts f["DDDDDLUUUUU"] # Mario walks across a bridge and back.
puts f["RRRRDDDDLLL"] # Mario walks in a triangle.
puts f["LLLLLLUUUUUURRRRR"] # Mario walks in a bigger triangle.
puts f["ULLDRDDDRU"] # Mario puts himself in peril.
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRR"] # Mario takes an unconventional route... and puts himself in peril.
puts f["DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD"] 
puts f["DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU"]

#Dead, return value 0

puts f["LLR"] #  Mario attempts to retrace a step and falls off.
puts f["UULDR"] #  Mario attempts to cross a tile twice and steps into air.
puts f["RRDDDDD"] #  Mario walks off a bridge at the first D (ignore any following steps).
puts f["RRRRDDDDLLLL"] #  Mario walks in a triangle and falls through the starting tile.
puts f["LLLLLLUUUUUURRRRRR"] #  Mario walks in a bigger triangle and falls through the starting tile.
puts f["UUUUUUUUUUUUUUUUUUUU"] #  Mario walks all the way around the planet and falls through the starting tile.
puts f["RURDRURDRDLDRDLDLDLULDLLUU"] # 

puts f["ULLDRDDDRUUU"] 
puts f["ULLDRDDDRUUL"] 
puts f["ULLDRDDDRUUR"] 
puts f["ULLDRDDDRUUD"] 
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR"] #text case in q is wrong. one more R added to make the kill.
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRU"] 
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRL"] 
puts f["RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRD"]