Super Mario Galaxy zawiera dwieplanety w kształcie rombu o kształcie kwadratu * wyłożone kafelkami z platformami, które kurczą się, gdy Mario biegnie. Jeśli Mario wpadnie w trójkątną dziurę lub szczelinę pozostawioną przez wcześniej dotknięty kafelek, zostanie pochłonięty przez czarną dziurę w rdzeniu. (Oglądaj: Hurry-Scurry Galaxy , Sea Slide Galaxy )

^{Zdjęcie: MarioWiki.com}

(Możesz myśleć o planecie jako sześcianie 2x2x2, którego twarze zostały odłączone i połączone ze sobą 2x3 „mostami”.)

Niestety, ponieważ mój kontroler jest bardzo zepsuty, Mario nie może skakać i ogranicza się do czterech głównych kierunków. Dodatkowo Mario porusza się bardzo powoli i nie może cofnąć się nawet o jeden krok bez uprzedniego zniknięcia platformy za sobą.

Załóżmy, że kamera zawsze znajduje się nad głową Mario, a on zaczyna w prawym dolnym rogu twarzy 2x2:

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

Twój program pobierze listę lub ciąg wskazówek U D L R(w górę, w dół, w lewo, w prawo), reprezentujących marsz Mario wokół planety do tej pory jako szereg kroków. Program może wysyłać jeden z dwóch różnych wyników: jeden reprezentujący, że Mario wciąż żyje i idzie, a drugi reprezentujący to, że gdzieś w trakcie marszu Mario wpadł do zmniejszającej się satelity.

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

Oczywiście, w przeciwieństwie do powyższych diagramów, będziesz musiał wziąć pod uwagę 3D. Oto schemat, który może pomóc w lepszej wizualizacji scenariusza:

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

Zgodnie z tym diagramem UUUUURRRRmoże wyglądać następująco:

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

I UUUUUUUUULURRRRRRmoże wyglądać tak:

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

Niech najkrótszy program w bajtach w-aaaaaaaaaah!

Przypadki testowe

Wyjście 1: wciąż żywe

DDDDDLUUUUU - Mario idzie przez most iz powrotem.

RRRRDDDDLLL - Mario chodzi w trójkącie.

LLLLLLUUUUUURRRRR - Mario chodzi w większym trójkącie.

ULLDRDDDRU - Mario naraża się na niebezpieczeństwo.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR - Mario wybiera niekonwencjonalną drogę ... i naraża się na niebezpieczeństwo.

Mario przecina każdą płytkę dokładnie raz. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

Wyjście 2: W-aaaaaaaaaah!

LLR - Mario próbuje cofnąć się o krok i spada.

UULDR - Mario próbuje dwukrotnie przejść przez kafelek i wchodzi w powietrze.

RRDDDDD - Mario wychodzi z mostu w pierwszym D (zignoruj ​​kolejne kroki).

RRRRDDDDLLLL - Mario chodzi w trójkącie i spada przez płytkę początkową.

LLLLLLUUUUUURRRRRR - Mario idzie większym trójkątem i spada przez płytkę początkową.

UUUUUUUUUUUUUUUUUUUU - Mario chodzi dookoła planety i spada przez płytkę początkową.

RURDRURDRDLDRDLDLDLULDLLUU - Mario wybiera niekonwencjonalną trasę i staje się zdezorientowany.

Mario, zdając sobie sprawę z niebezpieczeństwa, w którym się znajduje, nie ma wyboru.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

Na koniec skopiuj dowolny przypadek testowy z „Mario krzyżuje każdy kafel dokładnie raz” i zmień lub dodaj losowo jeden krok. Mario powinien upaść. (Jeśli dodasz krok do końca, Mario upada po Power Star!)

_{* Kantellowany sześcian byłby bardziej poprawnym terminem, ponieważ niektóre twarze nie są kwadratowe, ale musisz przyznać, że „rombowo-kwadratowy” płynie ładniej.}

Rubinowy, golfowy, 244 230 bajtów

Wydaje się, że działa dobrze, przetestuje trochę więcej.

->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, pierwsza działająca wersja, 260 bajtów

Wypróbuj online

Funkcja lambda przyjmująca argument ciągu. Zwraca 4 za żywych, 0 za martwych.

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

Wyjaśnienie

Plansza jest rozłożona na 6 pasków o rozmiarze 2x8, reprezentowanych przez znaki /\i Oponiżej. Są one odwzorowane na mapie 2D 24 * 8, gdzie x = (numer paska) * 4 + (pozycja pozioma na pasku), ay = pozycja pionowa na pasku.

       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

Są one przechowywane w tablicy 8 liczb binarnych, więc x zwiększa się w lewo, a y rośnie w dół.

Tablica jest zainicjalizowana 8 kopiami numeru 0x33333333. To tworzy kwadraty, na które Mario może nadepnąć. Gdy Mario porusza się po kwadracie, na którym się znajduje, jest ustawiony na zero, a kwadrat, na który się porusza, jest testowany - żyje, że zawiera 1, i umiera, jeśli zawiera 0.

Jeśli Mario zejdzie z górnej lub dolnej części paska, na którym jest, przechodzi do innego paska. Jeśli zejdzie z boku paska, jest na nim, jeśli jest na kwadracie z y = 3 lub y = 4, przechodzi do innego paska. Jeśli y nie jest równe 3 lub 4, nie przesuwa się do innego paska i kończy na polu, na którym od początku było 0, więc umiera.

Ponieważ kamera jest zawsze nad głową Mario, za każdym razem, gdy Mario zmienia pasek, odniesienie dla kierunków musi zostać obrócone o 90 stopni.

Niegolfowany w programie testowym

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