Super Mario Galaxy comprend deuxplanètes en forme de rhombicuboctaèdre * carrelées de plates-formes qui rétrécissent lorsque Mario traverse. Si Mario tombe dans un trou triangulaire ou un espace laissé par une tuile qu'il a précédemment touchée, il sera consommé par le trou noir au cœur. (Regardez: Hurry-Scurry Galaxy , Sea Slide Galaxy )

^{Image: MarioWiki.com}

(Vous pouvez considérer la planète comme un cube 2x2x2 dont les faces ont été détachées et connectées les unes aux autres par des "ponts" 2x3.)

Malheureusement, comme mon contrôleur est très cassé, Mario ne peut pas sauter et est limité aux quatre directions cardinales. De plus, Mario se déplace très lentement et ne peut même pas revenir en arrière sans avoir d'abord fait disparaître la plateforme derrière lui.

Supposons que la caméra soit toujours au-dessus de la tête de Mario et qu'il commence en bas à droite d'un visage 2x2:

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

Votre programme prendra une liste ou une chaîne de directions U D L R(haut, bas, gauche, droite), représentant la marche de Mario autour de la planète jusqu'à une série d'étapes. Le programme peut produire l'une des deux sorties distinctes: l'une représentant que Mario est toujours vivant et en marche, et l'autre représentant que quelque part le long de sa marche, Mario est tombé dans le satellite rétrécissant.

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

Bien sûr, contrairement aux schémas ci-dessus, vous devrez prendre en compte la 3D. Voici un diagramme qui pourrait vous aider à mieux visualiser le scénario:

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

Donc, selon ce diagramme, cela UUUUURRRRpourrait ressembler à ceci:

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

Et UUUUUUUUULURRRRRRpourrait ressembler à ceci:

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

Que le programme le plus court en octets w-aaaaaaaaaahh!

Cas de test

Sortie 1: toujours en vie

DDDDDLUUUUU - Mario traverse un pont et revient.

RRRRDDDDLLL - Mario marche en triangle.

LLLLLLUUUUUURRRRR - Mario marche dans un triangle plus grand.

ULLDRDDDRU - Mario se met en danger.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR - Mario prend une route non conventionnelle ... et se met en danger.

Mario traverse chaque tuile exactement une fois. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

Sortie 2: W-aaaaaaaaaahh!

LLR - Mario tente de revenir sur un pas et tombe.

UULDR - Mario tente de traverser une tuile deux fois et se met en l'air.

RRDDDDD - Mario sort d'un pont au premier D (ignorez les étapes suivantes).

RRRRDDDDLLLL - Mario marche en triangle et tombe à travers la tuile de départ.

LLLLLLUUUUUURRRRRR - Mario marche dans un triangle plus grand et tombe à travers la tuile de départ.

UUUUUUUUUUUUUUUUUUUU - Mario parcourt la planète et tombe à travers la tuile de départ.

RURDRURDRDLDRDLDLDLULDLLUU - Mario prend une route non conventionnelle et devient désorienté.

Mario, réalisant le péril dans lequel il se trouve, n'a pas le choix.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

Enfin, copiez n'importe quel scénario de test de "Mario traverse chaque tuile exactement une fois" et modifiez ou ajoutez une étape au hasard. Mario devrait tomber. (Si vous ajoutez une étape à la fin, Mario tombe pour attraper la Power Star!)

_{* Le cube cantellé serait un terme plus correct car certaines faces ne sont pas carrées, mais vous devez admettre que le "rhombicuboctaèdre" coule mieux.}

Rubis, golfé, 244 230 octets

Semble fonctionner correctement, testera un peu plus.

->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, première version de travail, 260 octets

Essayez-le en ligne

Fonction lambda prenant un argument chaîne. Renvoie 4 pour vivant, 0 pour mort.

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

Explication

La planche est dépliée en 6 bandes de taille 2x8, représentées par les caractères /\et Oci-dessous. Ceux-ci sont mappés sur une carte 2D 24 * 8, où x = (numéro de bande) * 4 + (position horizontale sur la bande) et y = position verticale sur la bande.

       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

Ceux-ci sont stockés dans un tableau de 8 nombres binaires, donc x augmente vers la gauche et y augmente vers le bas.

Le tableau est initialisé avec 8 copies du numéro 0x33333333 . Cela forme les carrés sur lesquels Mario est autorisé à marcher. Lorsque Mario se déplace autour du carré sur lequel il se trouve, il est mis à zéro et le carré vers lequel il se déplace est testé - il vit qu'il contient un 1 et meurt s'il contient un 0.

Si Mario quitte le haut ou le bas de la bande sur laquelle il se trouve, il passe à une autre bande. S'il marche du côté de la bande sur laquelle il se trouve, s'il est sur une case avec y = 3 ou y = 4, il passe à une autre bande. Si y n'est pas 3 ou 4, il ne passe pas à une autre bande et se retrouve sur une case qui avait 0 dedans depuis le début du jeu, alors il meurt.

Parce que la caméra est toujours au-dessus de la tête de Mario, chaque fois que Mario change de bande, la référence pour les directions doit être tournée de 90 degrés.

Non testé dans le programme de test

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