Süper Mario Galaxy , Mario geçerken küçülen platformlarla döşenmiş,iki eşkenar dörtgen şeklinde * gezegene sahiptir. Mario üçgen bir deliğe düşerse veya daha önce dokunduğu bir kiremitin bıraktığı bir boşluğa, çekirdekteki kara delik tarafından tüketilir. (İzle: Acele-Scurry Gökadası , Deniz Kayan Gökadası )

^{Image: MarioWiki.com}

(Gezegeni, yüzleri 2x3 "köprüler" ile birbirine bağlanmış ve birbirine bağlanmış 2x2x2 küp olarak düşünebilirsiniz.)

Maalesef, kontrolörüm çok kırıldığından, Mario atlayamıyor ve dört kardinal yönle sınırlı. Ek olarak, Mario çok yavaş hareket eder ve ilk önce arkasındaki platformun ortadan kalkması olmadan bir adım bile geri çekilemez.

Kamera her zaman Mario'nun başının üstünde olduğunu ve 2x2 yüzün sağ alt köşesinde başladığını varsayalım:

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

Programınız, U D L RMario'nun gezegen etrafında bir dizi adım kadar yürüdüğünü temsil eden bir liste veya yön dizisi (yukarı, aşağı, sol, sağ) alacaktır . Program iki farklı çıktıdan birini çıkarabilir: biri Mario'nun hala hayatta ve yürüdüğünü, diğeri ise yürüyüşü boyunca bir yerin, Shrinking Satellite'e düştüğünü gösterir.

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

Tabii ki, yukarıdaki diyagramlardan farklı olarak, 3D'yi hesaba katmanız gerekecektir. İşte senaryoyu daha iyi görmenize yardımcı olabilecek bir şema:

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

Yani bu şemaya göre, UUUUURRRRşuna benzeyebilir:

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

Ve UUUUUUUUULURRRRRRşuna benzeyebilir:

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

Bayt cinsinden en kısa program w-aaaaaaaaaahh!

Test Kılıfları

Çıktı 1: Hala Canlı

DDDDDLUUUUU - Mario bir köprüden geçip yürür.

RRRRDDDDLLL - Mario bir üçgen içinde yürür.

LLLLLLUUUUUURRRRR - Mario daha büyük bir üçgende yürür.

ULLDRDDDRU - Mario kendini tehlikeye atıyor.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR - Mario alışılmadık bir rota izler ... ve kendini tehlikeye atar.

Mario her döşemeyi bir kez geçiyor. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

Çıktı 2: W-aaaaaaaaaahh!

LLR - Mario bir adım geri çekilmeye kalkar ve düşer.

UULDR - Mario iki kez döşemeyi geçmeye çalışır ve havaya çıkar.

RRDDDDD - Mario ilk D'de bir köprüden yürür (izleyen adımları yoksay).

RRRRDDDDLLLL - Mario bir üçgen içinde yürür ve başlangıç ​​döşemesinden geçer.

LLLLLLUUUUUURRRRRR - Mario daha büyük bir üçgenle yürür ve başlangıç ​​döşemesine geçer.

UUUUUUUUUUUUUUUUUUUU - Mario gezegenin her tarafında dolaşıyor ve başlangıç ​​taşına düşüyor.

RURDRURDRDLDRDLDLDLULDLLUU - Mario alışılmadık bir rota izler ve şaşırır hale gelir.

Mario, içinde bulunduğu tehlikenin farkına varmadan, başka seçenek bırakmadı.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

Son olarak, "Mario her döşemeyi bir kez geçirir" den herhangi bir test vakasını kopyalayın ve rastgele bir adım değiştirin veya ekleyin. Mario düşmeli. (Sonuna bir adım eklerseniz, Mario Power Star'ı tutmaya düşer!)

_{* Bazı yüzler kare olmadığından katlanmış küp daha doğru bir terimdir, ancak şunu itiraf etmeniz gerekir - "rhombicuboctahedron" daha güzel akar.}

Yakut, golf oynadı, 244 230 bayt

İyi çalışıyor gibi görünüyor, biraz daha test edecek.

->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, ilk çalışan sürüm, 260 bayt

Çevrimiçi deneyin

Bir string argüman alarak Lambda işlevi. Canlı için 4, ölü için 0 döndürür.

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

açıklama

Tahta, aşağıdaki /\ve Okarakterleri ile temsil edilen 6 x 2 boyda şeritler halinde açılır . Bunlar, 24 x 8 2B harita üzerinde eşlenir; burada x = (şerit numarası) * 4 + (şerit üzerinde yatay konum) ve y = şerit üzerinde dikey konum.

       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

Bunlar, 8li ikili sayılar dizisinde depolanır, böylece x sola doğru artar ve y aşağı doğru artar.

Dizi, numaranın 8 kopyası ile intialize edilir 0x33333333. Bu, Mario'nun basmasına izin verilen kareleri oluşturur. Mario karenin etrafında hareket ederken sıfıra ayarlanır ve hareket ettiği kare test edilir - içinde bir 1 içerir, 0 ise ölür.

Mario, üzerinde bulunduğu şeridin üstünden veya altından çıkarsa, başka bir şeride geçer. Şeridin kenarından uzaklaşırsa üzerinde, y = 3 veya y = 4 olan bir karede ise, başka bir şeride geçer. Eğer y, 3 ya da 4 değilse, başka bir şeride geçmez ve oyunun başından itibaren içinde 0 olan bir kare üzerinde sona erer, bu yüzden ölür.

Kamera her zaman Mario'nun başının üstünde olduğundan, Mario şerit değiştirdiğinde, yön referansları 90 derece döndürülmelidir.

Test programında Ungolfed

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