Super Mario Galaxy memiliki duaplanet * rhombicuboctahedron -shaped * dengan ubin yang menyusut ketika Mario melintas. Jika Mario jatuh ke dalam lubang segitiga atau celah yang ditinggalkan oleh ubin yang sebelumnya disentuh, ia akan dikonsumsi oleh lubang hitam di intinya. (Tonton: Galaksi Cepat-Gegas , Galaksi Geser Laut )

^{Gambar: MarioWiki.com}

(Anda dapat menganggap planet ini sebagai kubus 2x2x2 yang wajahnya telah terlepas dan terhubung satu sama lain dengan 2x3 "jembatan".)

Sayangnya, karena pengontrol saya sangat rusak, Mario tidak bisa melompat dan terbatas pada empat arah mata angin. Selain itu, Mario bergerak sangat lambat dan tidak dapat melacak bahkan satu langkah tanpa terlebih dahulu platform di belakangnya menghilang.

Mari kita asumsikan kamera selalu di atas kepala Mario dan dia mulai di kanan bawah wajah 2x2:

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

Program Anda akan mengambil daftar atau serangkaian arah, U D L R(atas, bawah, kiri, kanan), yang mewakili perjalanan Mario mengelilingi planet sejauh serangkaian langkah. Program ini dapat menampilkan salah satu dari dua output yang berbeda: yang satu menyatakan bahwa Mario masih hidup dan berjalan, dan yang lain menyatakan bahwa di suatu tempat di sepanjang perjalanannya, Mario telah jatuh ke dalam Satelit Shrinking.

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

Tentu saja, tidak seperti diagram di atas, Anda harus memperhitungkan 3D. Berikut diagram yang mungkin membantu Anda memvisualisasikan skenario dengan lebih baik:

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

Jadi menurut diagram ini, UUUUURRRRmungkin terlihat seperti ini:

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

Dan UUUUUUUUULURRRRRRmungkin terlihat seperti ini:

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

Semoga program terpendek dalam byte w-aaaaaaaaaahh!

Uji Kasus

Output 1: Masih Hidup

DDDDDLUUUUU - Mario berjalan melintasi jembatan dan kembali.

RRRRDDDDLLL - Mario berjalan dalam segitiga.

LLLLLLUUUUUURRRRR - Mario berjalan di segitiga yang lebih besar.

ULLDRDDDRU - Mario menempatkan dirinya dalam bahaya.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR - Mario mengambil rute yang tidak konvensional ... dan menempatkan dirinya dalam bahaya.

Mario melintasi setiap ubin tepat sekali. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

Output 2: W-aaaaaaaaaahh!

LLR - Mario mencoba menelusuri satu langkah dan jatuh.

UULDR - Mario mencoba untuk melintasi ubin dua kali dan melangkah ke udara.

RRDDDDD - Mario berjalan dari jembatan di D pertama (abaikan langkah-langkah berikut).

RRRRDDDDLLLL - Mario berjalan dalam segitiga dan jatuh melalui ubin awal.

LLLLLLUUUUUURRRRRR - Mario berjalan di segitiga yang lebih besar dan jatuh melalui ubin awal.

UUUUUUUUUUUUUUUUUUUU - Mario berjalan sepanjang jalan di sekitar planet ini dan jatuh melalui ubin awal.

RURDRURDRDLDRDLDLDLULDLLUU - Mario mengambil rute yang tidak konvensional dan menjadi bingung.

Mario, menyadari bahaya yang dia hadapi, dibiarkan tanpa pilihan.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

Terakhir, salin semua test case dari "Mario melintasi setiap ubin tepat sekali" dan ubah atau tambahkan satu langkah secara acak. Mario harus jatuh. (Jika Anda menambahkan langkah ke akhir, Mario jatuh untuk meraih Power Star!)

_{* Cantellated cube akan menjadi istilah yang lebih benar karena beberapa wajah tidak persegi, tetapi Anda harus mengakui - "rhombicuboctahedron" mengalir lebih baik.}

Ruby, golf, 244 230 byte

Tampaknya bekerja dengan baik, akan menguji lebih sedikit.

->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, versi pertama yang berfungsi, 260 byte

Cobalah online

Fungsi Lambda mengambil argumen string. Mengembalikan 4 untuk hidup, 0 untuk mati.

->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}

Penjelasan

Papan dibuka menjadi 6 strip ukuran 2x8, diwakili oleh /\dan Okarakter di bawah ini. Ini dipetakan ke peta 2D 24 * 8, di mana x = (nomor strip) * 4 + (posisi horizontal pada strip) dan y = posisi vertikal pada strip.

       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

Ini disimpan dalam array 8 angka biner, jadi x meningkat ke kiri dan y meningkat turun.

Array disengaja dengan 8 salinan nomor 0x33333333. Ini membentuk kotak yang diizinkan untuk diinjak Mario. Saat Mario bergerak di sekitar alun-alun dia berada diatur ke nol, dan alun-alun dia pindah ke diuji - dia hidup itu berisi 1, dan mati jika mengandung 0.

Jika Mario berjalan dari atas atau bawah strip yang dia pakai, dia pindah ke strip lain. Jika dia berjalan dari sisi strip yang dia pakai, jika dia berada di bujur sangkar dengan y = 3 atau y = 4 dia pindah ke strip lain. Jika y bukan 3 atau 4, dia tidak pindah ke strip lain dan berakhir di kotak yang memiliki 0 di dalamnya sejak awal permainan, jadi dia mati.

Karena kamera selalu di atas kepala Mario, setiap kali Mario mengganti strip, referensi untuk arah harus diputar 90 derajat.

Tidak digabungkan dalam program uji

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