슈퍼 마리오 갤럭시 는마리오가 가로 질러 가면서 줄어드는 플랫폼으로 타일 된2 개의 마름모꼴 8 면체 * 행성을 특징으로합니다. 마리오가 삼각형 구멍에 빠지거나 이전에 만진 타일에 의해 남겨진 틈에 빠지면 코어의 블랙홀에 의해 소비됩니다. (시계 : Hurry-Scurry Galaxy , Sea Slide Galaxy )

^{이미지 : MarioWiki.com}

(행성을 2x3 "브릿지"에 의해 서로 분리하고 연결 한 2x2x2 큐브로 생각할 수 있습니다.)

불행히도, 내 컨트롤러가 매우 손상 되었기 때문에 Mario는 점프 할 수 없으며 4 개의 기본 방향으로 제한됩니다. 또한 Mario는 매우 느리게 움직이며, 그 뒤에 플랫폼이 먼저 사라지지 않으면 한 단계라도 되돌릴 수 없습니다.

카메라가 항상 Mario의 머리 위에 있고 2x2 얼굴의 오른쪽 하단에서 시작한다고 가정 해 봅시다.

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

당신의 프로그램은 U D L R일련의 단계까지 지구를 돌아 다니는 마리오의 산책을 나타내는 방향 목록 (위, 아래, 왼쪽, 오른쪽)을 취할 것입니다. 이 프로그램은 마리오가 여전히 살아 있고 걷는다는 것을 나타내는 하나, 그리고 그의 걷는 곳 어딘가에있는 마리오가 수축하는 위성에 빠졌다는 것을 나타내는 두 가지 별개의 출력 중 하나를 출력 할 수 있습니다.

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

물론 위의 다이어그램과 달리 3D를 고려해야합니다. 시나리오를보다 잘 시각화하는 데 도움이되는 다이어그램은 다음과 같습니다.

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

따라서이 다이어그램에 따르면 UUUUURRRR다음과 같이 보일 수 있습니다.

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

그리고 UUUUUUUUULURRRRRR다음과 같이 보일 수 있습니다 :

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

가장 짧은 프로그램 바이트 수 w-aaaaaaaaaahh!

테스트 사례

출력 1 : 여전히 살아남

DDDDDLUUUUU -마리오는 다리를 건너 갔다가 돌아옵니다.

RRRRDDDDLLL -마리오는 삼각형으로 걸어갑니다.

LLLLLLUUUUUURRRRR -마리오는 더 큰 삼각형으로 걷습니다.

ULLDRDDDRU 마리오는 위험에 처해있다.

RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRR -마리오는 틀에 얽매이지 않는 길을 ... 위험에 처하게됩니다.

마리오는 모든 타일을 정확히 한 번 교차합니다. DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

출력 2 : W-aaaaaaaaaahh!

LLR -마리오는 걸음을 되 찾으려고합니다.

UULDR -마리오는 타일을 두 번 교차시키고 공중으로 들어갑니다.

RRDDDDD -마리오는 첫 번째 D에서 다리를 걷습니다 (다음 단계는 무시).

RRRRDDDDLLLL -마리오는 삼각형으로 걸어 시작 타일을 통과합니다.

LLLLLLUUUUUURRRRRR -마리오는 더 큰 삼각형으로 걸어 시작 타일을 통과합니다.

UUUUUUUUUUUUUUUUUUUU -마리오는 지구 주위를 걷다가 시작 타일을 통과합니다.

RURDRURDRDLDRDLDLDLULDLLUU -마리오는 틀에 얽매이지 않는 길을 잃고 방향이 바뀝니다.

그가 처한 위험을 깨닫는 마리오는 선택의 여지가 없습니다.

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

마지막으로 "Mario는 모든 타일을 정확히 한 번 교차합니다"의 테스트 사례를 복사하고 임의로 한 단계 씩 변경하거나 추가합니다. 마리오는 넘어 져야한다. (끝에 단계를 추가하면 Mario가 Power Star를 갖기 위해 넘어집니다!)

_{* 일부면이 정사각형이 아니기 때문에 칸 틸라 큐브 가 더 정확한 용어 일 것입니다.}

루비, golfed, (244) 230 바이트

잘 작동하는 것 같고 조금 더 테스트 할 것입니다.

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

루비, 첫 번째 작업 버전, 260 바이트

온라인으로 사용해보십시오

문자열 인수를 취하는 Lambda 함수 살아있는 경우 4를, 죽은 경우 0을 리턴합니다.

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

설명

보드는 아래 의 /\및 O문자로 표시되는 2x8 크기의 6 스트립으로 펼쳐집니다 . 이들은 24 * 8 2D 맵에 매핑되는데, 여기서 x = (스트립 번호) * 4 + (스트립의 수평 위치) 및 y = 스트립의 수직 위치입니다.

       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

이들은 8 개의 이진수 배열로 저장되므로 x는 왼쪽으로 증가하고 y는 아래로 증가합니다.

배열은 8 개의 사본으로 초기화됩니다 0x33333333. 이것은 마리오가 밟을 수있는 사각형을 형성합니다. Mario가 켜져있는 사각형 주위를 이동하면 0으로 설정되고 이동하는 사각형이 테스트됩니다. 1을 포함하고 0을 포함하면 죽습니다.

Mario가 켜져있는 스트립의 맨 위나 맨 아래를 벗어나면 다른 스트립으로 이동합니다. 그가 스트립의 측면에서 걷다가 켜져 있다면, y = 3 또는 y = 4 인 사각형에 있으면 다른 스트립으로 이동합니다. y가 3 또는 4가 아닌 경우, 그는 다른 스트립으로 이동하지 않고 게임의 시작 부분에서 0을 가진 사각형으로 끝나므로 죽습니다.

카메라는 항상 Mario의 머리 위에 있기 때문에 Mario가 스트립을 변경할 때마다 방향 기준이 90도 회전해야합니다.

테스트 프로그램에서 언 골프

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