スーパーマリオギャラクシーは、マリオが走るにつれて縮小するプラットフォームでタイル張りされた2つの菱形八面体形*の惑星を備えています。マリオが三角形の穴または以前に触れたタイルによって残された隙間に落ちた場合、彼はコアのブラックホールによって消費されます。（ウォッチ： Hurry-Scurry Galaxy、 Sea Slide Galaxy）

^{画像：MarioWiki.com}

（惑星は、2x3の "ブリッジ"で面が切り離されて互いに接続された2x2x2の立方体と考えることができます。）

残念ながら、私のコントローラーは非常に壊れているため、マリオはジャンプできず、4つの基本的な方向に制限されています。さらに、マリオは非常にゆっくりと移動し、最初に彼の後ろのプラットフォームが消えない限り、1歩でも戻ることができません。

カメラは常にマリオの頭の上にあり、マリオは2x2の顔の右下から開始すると仮定します。

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

あなたのプログラムはU D L R、マリオが惑星を歩き回る一連のステップを表す、リストまたは一連の方向（上、下、左、右）を取ります。プログラムは、2つの異なる出力の1つを出力できます。1つは、マリオがまだ生きて歩いていることを表し、もう1つは、彼の散歩のどこかでマリオが収縮衛星に落ちたことを表します。

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 -マリオは型破りなルートをたどります...そして危険にさらされます。

マリオは、すべてのタイルを1回だけクロスします。 DDDDLUUUULLLLDDDLUUULLLLDDDDLUUUULLLLDDDLUUULLLURRRUUURDDDRRRRUUURDDDRRRRUUURDDDRRRRUUUUURDDDDD DLDRDLDLLLDRRRDDDDLLLLLLLLLDRRRRRRRRRDDDDLLLDRRRDDDRUUURRRRULLLLUUUURRRULLLUUUUURDRURDRUURULURU

出力2：W-aaaaaaaaaahh！

LLR -マリオはステップをたどろうとし、脱落します。

UULDR -マリオはタイルを2回横切り、空中に飛び込もうとします。

RRDDDDD -最初のDでマリオが橋から降ります（以下の手順は無視してください）。

RRRRDDDDLLLL -マリオは三角形を歩き、開始タイルを抜けます。

LLLLLLUUUUUURRRRRR -マリオは大きな三角形を歩き、開始タイルを抜けます。

UUUUUUUUUUUUUUUUUUUU -マリオは惑星の周りを歩き回り、開始タイルを抜けます。

RURDRURDRDLDRDLDLDLULDLLUU -マリオは型破りなルートを取り、混乱します。

マリオは、彼がいる危険に気づいて、選択の余地がありません。

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

最後に、「マリオがすべてのタイルを1回だけクロス」からテストケースをコピーし、ランダムに1ステップ変更または追加します。マリオが落ちるはずです。（最後にステップを追加すると、マリオが落ちてパワースターをつかむ！）

_{* 角張った立方体は、一部の面が正方形ではないため、より正確な用語になりますが、「菱形立方八面体」の流れが良くなることを認めなければなりません。}

ルビー、ゴルフ、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}

Ruby、最初の作業バージョン、260バイト

オンラインで試す

文字列引数を取るラムダ関数。生きている場合は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}

説明

ボードは、以下の/\およびで表されるサイズ2x8の6つのストリップに展開されOます。これらは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個の2進数の配列に格納されるため、xは左に向かって増加し、yは下に向かって増加します。

配列は、番号の8つのコピーで初期化され0x33333333ます。これは、マリオが踏むことができる正方形を形成します。マリオが正方形の周りを移動すると、彼は0に設定され、移動先の正方形がテストされます。1が含まれていて、0が含まれている場合は死亡します。

マリオが自分が乗っているストリップの上部または下部を離れると、別のストリップに移動します。彼がストリップの側面を離れて歩くと、彼はオンになり、y = 3またはy = 4の正方形にいると、別のストリップに移動します。yが3または4でない場合、彼は別のストリップに移動せず、ゲームの最初から0が入っていた正方形に到達するため、彼は死にます。

カメラは常にマリオの頭の上にあるため、マリオがストリップを変更するたびに、方向の参照は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"]