ซูเปอร์มาริโอกาแล็กซี่มีสองรอมบิคิวบอกทาฮีดรอน -shaped ดาวเคราะห์ * กระเบื้องกับแพลตฟอร์มที่หดตัวเป็นมาริโอวิ่งข้าม หากมาริโอตกลงไปในหลุมสามเหลี่ยมหรือช่องว่างที่เหลืออยู่จากกระเบื้องที่เขาสัมผัสก่อนหน้านี้เขาจะถูกหลุมดำที่แกนกลางถูกกลืนไปหมด (ดู:กาแล็คซี่ Hurry-Scurry , Galaxy Slide Sea )

^{ภาพ: MarioWiki.com}

(คุณสามารถคิดว่าดาวเคราะห์เป็นลูกบาศก์ 2x2x2 ซึ่งใบหน้าถูกแยกออกและเชื่อมต่อกันด้วย 2x3 "สะพาน")

น่าเสียดายเนื่องจากตัวควบคุมของฉันเสียมากมาริโอไม่สามารถกระโดดได้และถูก จำกัด ไว้ที่สี่ทิศทางสำคัญ นอกจากนี้มาริโอก็เคลื่อนไหวช้ามากและไม่สามารถหวนกลับแม้แต่ขั้นตอนเดียวโดยที่ไม่มีแพลตฟอร์มอยู่ข้างหลังเขาก่อนหายไป

สมมติว่ากล้องอยู่เหนือศีรษะของมาริโอเสมอและเขาเริ่มที่มุมขวาล่างของใบหน้า 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

ในที่สุดคัดลอกกรณีทดสอบใด ๆ จาก "มาริโอข้ามกระเบื้องทุกครั้ง" และเปลี่ยนหรือเพิ่มหนึ่งขั้นตอนโดยการสุ่ม มาริโอควรจะตก (หากคุณเพิ่มขั้นตอนไปจนสิ้นสุดมาริโอก็จะคว้า Power Star!)

_{* ลูกบาศก์ที่มีตาเรตเป็นคำที่ถูกต้องมากขึ้นเนื่องจากบางใบหน้าไม่ได้เป็นสี่เหลี่ยมจัตุรัส แต่คุณต้องยอมรับว่า - "rhombicuboctahedron" ไหลดีกว่า}

ทับทิม, กอล์ฟ, 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}

คำอธิบาย

กระดานจะถูกกางออกเป็น 6 แถบขนาด 2x8 โดยมีตัวอักษร/\และOด้านล่าง สิ่งเหล่านี้ถูกแมปไปยังแผนที่ 2 มิติ 24 * 8 โดยที่ 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 จะเพิ่มลง

อาเรย์ถูกทำให้เป็น intialized 8 สำเนาของจำนวน 0x33333333สำเนาของจำนวน รูปแบบนี้เป็นสี่เหลี่ยมมาริโอได้รับอนุญาตให้เหยียบ ในขณะที่มาริโอเคลื่อนที่ไปรอบ ๆ จัตุรัสที่เขาตั้งอยู่จะถูกตั้งค่าเป็นศูนย์และสี่เหลี่ยมที่เขากำลังเคลื่อนที่ไปนั้นถูกทดสอบ - เขาใช้ชีวิตมันประกอบด้วย 1 และตายถ้ามันมี 0

หากมาริโอเดินออกจากด้านบนหรือด้านล่างของแถบที่เขาอยู่เขาจะย้ายไปที่แถบอื่น หากเขาเดินออกจากด้านข้างของแถบที่เขาอยู่ถ้าเขาอยู่ในสี่เหลี่ยมที่มี y = 3 หรือ y = 4 เขาจะย้ายไปที่แถบอื่น ถ้า y ไม่ใช่ 3 หรือ 4 เขาจะไม่ย้ายไปที่แถบอื่นและลงเอยด้วยสี่เหลี่ยมจัตุรัสซึ่งมี 0 ในนั้นตั้งแต่เริ่มเกมเขาจึงตาย

เนื่องจากกล้องอยู่เหนือหัวของมาริโอเสมอเมื่อใดก็ตามที่มาริโอเปลี่ยนแถบการอ้างอิงสำหรับทิศทางจะต้องหมุน 90 องศา

Ungolfed ในโปรแกรมทดสอบ

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