In Super Mario Galaxy gibt es zwei rhombicuboctahedron-förmige * Planeten, die mit Plattformen gekachelt sind, die schrumpfen, wenn Mario überquert wird . Sollte Mario in ein dreieckiges Loch oder in eine Lücke fallen, die ein zuvor berührtes Plättchen hinterlassen hat, wird er vom schwarzen Loch im Kern verzehrt. (Siehe: Eile-Scurry-Galaxie , Sea Slide-Galaxie )

^{Bild: MarioWiki.com}

(Sie können sich den Planeten als einen 2x2x2-Würfel vorstellen, dessen Gesichter durch 2x3 "Brücken" voneinander getrennt und miteinander verbunden wurden.)

Da mein Controller sehr kaputt ist, kann Mario leider nicht springen und ist auf die vier Hauptrichtungen beschränkt. Außerdem bewegt sich Mario sehr langsam und kann nicht einmal einen Schritt zurückverfolgen, ohne dass die Plattform hinter ihm verschwindet.

Nehmen wir an, die Kamera befindet sich immer über Marios Kopf und er beginnt rechts unten auf einem 2x2-Gesicht:

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

Ihr Programm enthält eine Liste oder eine Reihe von Anweisungen U D L R(oben, unten, links, rechts), die Marios Umrundung des Planeten in mehreren Schritten darstellen. Das Programm kann eine von zwei verschiedenen Ausgaben ausgeben: eine, die darstellt, dass Mario noch lebt und läuft, und die andere, die darstellt, dass Mario irgendwo auf seinem Weg in den schrumpfenden Satelliten gefallen ist.

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

Natürlich müssen Sie im Gegensatz zu den obigen Diagrammen die 3D berücksichtigen. Hier ist ein Diagramm, das Ihnen helfen könnte, das Szenario besser zu visualisieren:

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

Nach diesem Diagramm UUUUURRRRkönnte es also so aussehen:

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

Und UUUUUUUUULURRRRRRkönnte so aussehen:

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

Möge das kürzeste Programm in Bytes w-aaaaaaaaahh!

Testfälle

Ausgang 1: noch am Leben

DDDDDLUUUUU - Mario geht über eine Brücke und zurück.

RRRRDDDDLLL - Mario geht in einem Dreieck.

LLLLLLUUUUUURRRRR - Mario geht in einem größeren Dreieck.

ULLDRDDDRU - Mario gerät in Gefahr.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR - Mario geht einen unkonventionellen Weg ... und gerät in Gefahr.

Mario überquert jedes Plättchen genau einmal. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

Ausgang 2: W-aaaaaaaaaahh!

LLR - Mario versucht einen Schritt zurückzuverfolgen und fällt ab.

UULDR - Mario versucht zweimal eine Fliese zu überqueren und tritt in die Luft.

RRDDDDD - Mario geht beim ersten D von einer Brücke (ignoriere alle folgenden Schritte).

RRRRDDDDLLLL - Mario geht im Dreieck und fällt durch das Startplättchen.

LLLLLLUUUUUURRRRRR - Mario geht in einem größeren Dreieck und fällt durch das Startplättchen.

UUUUUUUUUUUUUUUUUUUU - Mario umrundet den Planeten und fällt durch das Startplättchen.

RURDRURDRDLDRDLDLDLULDLLUU - Mario geht einen unkonventionellen Weg und wird desorientiert.

Mario, der die Gefahr erkennt, in der er sich befindet, hat keine andere Wahl.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

Kopieren Sie abschließend einen beliebigen Testfall aus "Mario kreuzt jedes Plättchen genau einmal" und ändern oder fügen Sie einen Schritt nach dem Zufallsprinzip hinzu. Mario sollte fallen. (Wenn Sie einen Schritt zum Ende hinzufügen, fällt Mario, um den Power Star zu ergreifen!)

_{* Cantellated Würfel wäre ein richtigerer Begriff, da einige Gesichter nicht quadratisch sind, aber Sie müssen zugeben - "Rhombicuboctahedron" fließt besser.}

Ruby, Golf, 244 230 Bytes

Scheint gut zu funktionieren, wird ein bisschen mehr testen.

->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, erste Arbeitsversion, 260 Bytes

Probieren Sie es online aus

Lambda-Funktion, die ein Zeichenfolgenargument verwendet. Gibt 4 für lebendig, 0 für tot zurück.

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

Erläuterung

Die Tafel ist in 6 Streifen der Größe 2x8 aufgeteilt, die durch die Zeichen /\und Ounten dargestellt werden. Diese werden auf eine 24 * 8 2D-Karte abgebildet, wobei x = (Streifennummer) * 4 + (horizontale Position auf dem Streifen) und y = vertikale Position auf dem Streifen.

       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

Diese werden in einem Array von 8 Binärzahlen gespeichert, sodass x nach links und y nach unten zunimmt.

Das Array wird mit 8 Kopien der Nummer initialisiert 0x33333333. Dies bildet die Quadrate, auf die Mario treten darf. Während sich Mario um das Feld bewegt, auf dem er sich befindet, wird es auf Null gesetzt, und das Feld, auf das er sich bewegt, wird getestet - er lebt, es enthält eine 1 und stirbt, wenn es eine 0 enthält.

Wenn Mario vom oberen oder unteren Ende des Strips geht, auf dem er sich befindet, wechselt er zu einem anderen Strip. Wenn er die Seite des Streifens verlässt, auf der er sich befindet, wenn er sich auf einem Feld mit y = 3 oder y = 4 befindet, bewegt er sich zu einem anderen Streifen. Wenn y nicht 3 oder 4 ist, bewegt er sich nicht auf einen anderen Streifen und landet auf einem Feld, auf dem von Beginn des Spiels an 0 war, sodass er stirbt.

Da sich die Kamera immer über Marios Kopf befindet, muss der Richtungsbezug bei jedem Streifenwechsel um 90 Grad gedreht werden.

Ungolfed im Testprogramm

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