¿Mario caerá en el satélite cada vez más pequeño? (Diagrama agregado)

23

Super Mario Galaxy presenta dosplanetas con forma de rombocuboctaedro * en mosaico con plataformas que se encogen a medida que Mario se cruza. Si Mario cae en un agujero triangular o en un espacio dejado por un azulejo que tocó anteriormente, el agujero negro en el núcleo lo consumirá. (Ver: Galaxy apresurada , galaxia de Sea Slide )

Imagen: MarioWiki.com

Imagen: MarioWiki.com

(Puedes pensar en el planeta como un cubo de 2x2x2 cuyas caras se han separado y conectado entre sí mediante 2x3 "puentes").

Desafortunadamente, dado que mi controlador está muy roto, Mario no puede saltar y está limitado a las cuatro direcciones cardinales. Además, Mario se mueve muy lentamente y no puede retroceder ni un solo paso sin que primero desaparezca la plataforma detrás de él.

Supongamos que la cámara siempre está por encima de la cabeza de Mario y comienza en la parte inferior derecha de una cara de 2x2:

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

Su programa tomará una lista o cadena de direcciones, U D L R(arriba, abajo, izquierda, derecha), que representa la caminata de Mario alrededor del planeta hasta una serie de pasos. El programa puede generar una de dos salidas distintas: una que representa que Mario todavía está vivo y caminando, y la otra que representa que en algún momento de su caminata, Mario ha caído en el Satélite Reductor.

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

Por supuesto, a diferencia de los diagramas anteriores, tendrá que tener en cuenta el 3D. Aquí hay un diagrama que puede ayudarlo a visualizar mejor el escenario:

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

Entonces, de acuerdo con este diagrama, UUUUURRRRpodría verse así:

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

Y UUUUUUUUULURRRRRRpodría verse así:

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

¡Que el programa más corto en bytes w-aaaaaaaaaahh!

Casos de prueba

Salida 1: todavía vivo

DDDDDLUUUUU - Mario cruza un puente y regresa.

RRRRDDDDLLL - Mario camina en un triángulo.

LLLLLLUUUUUURRRRR - Mario camina en un triángulo más grande.

ULLDRDDDRU - Mario se pone en peligro.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR - Mario toma una ruta poco convencional ... y se pone en peligro.

Mario cruza cada ficha exactamente una vez. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

Salida 2: W-aaaaaaaaaahh!

LLR - Mario intenta retroceder un paso y se cae.

UULDR - Mario intenta cruzar un azulejo dos veces y sale al aire.

RRDDDDD - Mario sale de un puente en la primera D (ignore los siguientes pasos).

RRRRDDDDLLLL - Mario camina en un triángulo y cae a través del mosaico inicial.

LLLLLLUUUUUURRRRRR - Mario camina en un triángulo más grande y cae a través del mosaico inicial.

UUUUUUUUUUUUUUUUUUUU - Mario camina alrededor del planeta y cae a través del mosaico inicial.

RURDRURDRDLDRDLDLDLULDLLUU - Mario toma una ruta poco convencional y se desorienta.

Mario, al darse cuenta del peligro en el que se encuentra, no tiene otra opción.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

Finalmente, copie cualquier caso de prueba de "Mario cruza cada mosaico exactamente una vez" y cambie o agregue un paso al azar. Mario debería caerse. (¡Si agrega un paso al final, Mario cae para agarrar la Power Star!)

* Cubo cantelado sería un término más correcto ya que algunas caras no son cuadradas, pero hay que admitir que el "rombocuboctaedro" fluye mejor.

Darrylyeo
fuente
3
Puntos de bonificación por resolver esto en Cubix o Cubically
Stephen
Esto me trae tantos recuerdos de jugar a Mario Galaxy, fácilmente uno de mis juegos favoritos de todos los tiempos.
notjagan
77
@StepHen o MarioLANG: P
ETHproductions
@Stephen a pesar de que es un octógono, una hexagonía sti ... ¿Sabes qué? No importa, quién haría esto en hexAgony.
Urna mágica del pulpo
En el cuarto del último caso de prueba, Mario no muere a menos que agregue un extra R. He resuelto esto en papel para asegurarme de que mi código sea correcto.
Level River St

Respuestas:

6

Rubí, golfizado, 244 230 bytes

Parece funcionar bien, probará un poco más.

->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, primera versión de trabajo, 260 bytes.

Pruébalo en línea

Función Lambda tomando un argumento de cadena. Devuelve 4 por vivo, 0 por muerto.

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

Explicación

El tablero se despliega en 6 tiras de tamaño 2x8, representadas por los caracteres /\y a Ocontinuación. Estos se asignan en un mapa 2D 24 * 8, donde x = (número de tira) * 4 + (posición horizontal en la tira) e y = posición vertical en la tira.

       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

Estos se almacenan en una matriz de 8 números binarios, por lo que x aumenta hacia la izquierda ey aumenta hacia abajo.

La matriz se inicializa con 8 copias del número 0x33333333. Esto forma los cuadrados en los que Mario puede pisar. A medida que Mario se mueve alrededor del cuadrado en el que se encuentra, se establece en cero, y el cuadrado al que se mueve se prueba: vive con un 1 y muere si contiene un 0.

Si Mario sale de la parte superior o inferior de la tira en la que se encuentra, se mueve a otra tira. Si sale del lado de la franja en la que está, si está en un cuadrado con y = 3 o y = 4, se mueve a otra franja. Si y no es 3 o 4, no se mueve a otra tira y termina en una casilla que tenía 0 desde el principio del juego, por lo que muere.

Debido a que la cámara siempre está por encima de la cabeza de Mario, cada vez que Mario cambia de tira, la referencia de las direcciones debe girarse 90 grados.

Sin golf en el programa de prueba

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"]
Level River St
fuente
¡Bien hecho! Realmente me gusta el mapeo "strip" y la forma en que tomaste en cuenta el ángulo de la cámara.
darrylyeo