क्या मारियो सिकुड़ते हुए उपग्रह में गिरेगा? (आरेख जोड़ा गया)

Question

सुपर मारियो गैलेक्सी में दो rhombicuboctahedron -shaped * प्लेटफॉर्म हैं जो मारियो के रूप में सिकुड़ते प्लेटफार्मों के साथ टाइल किए गए हैं। क्या मारियो को एक त्रिकोणीय छेद में गिरना चाहिए या एक टाइल जिसे उसने पहले छुआ था, उसके द्वारा छोड़े गए अंतर के कारण, वह कोर के ब्लैक होल द्वारा भस्म हो जाएगा। (देखें: हर्री-स्क्री गैलेक्सी , सी स्लाइड गैलेक्सी )

^{चित्र: MarioWiki.com}

(आप एक 2x2x2 क्यूब के रूप में ग्रह के बारे में सोच सकते हैं जिनके चेहरे को अलग किया गया है और 2x3 "पुलों" द्वारा एक दूसरे से जुड़ा हुआ है।)

दुर्भाग्य से, चूंकि मेरा नियंत्रक बहुत टूट गया है, मारियो कूद नहीं सकता है और चार कार्डिनल दिशाओं तक सीमित है। इसके अतिरिक्त, मारियो बहुत धीरे-धीरे चलता है और उसके बिना एक कदम भी पीछे नहीं हट सकता है क्योंकि उसके गायब होने के पहले प्लेटफॉर्म नहीं है।

मान लेते हैं कि कैमरा हमेशा मारियो के सिर के ऊपर होता है और वह 2x2 चेहरे के निचले भाग में शुरू होता है:

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

आपका कार्यक्रम एक सूची या निर्देशों की स्ट्रिंग U D L R(ऊपर, नीचे, बाएं, दाएं) ले जाएगा, जो कि ग्रह के चारों ओर अब तक कदमों की एक श्रृंखला के रूप में मारियो के चलने का प्रतिनिधित्व करता है। कार्यक्रम दो अलग-अलग आउटपुटों में से एक को आउटपुट कर सकता है: एक जो यह दर्शाता है कि मारियो अभी भी जीवित है और चल रहा है, और दूसरा यह दर्शाता है कि उसके चलने के साथ कहीं, मारियो सिकुड़ उपग्रह में गिर गया है।

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

बेशक, उपरोक्त आरेखों के विपरीत, आपको 3 डी को ध्यान में रखना होगा। यहाँ एक आरेख है जो आपको बेहतर परिदृश्य की कल्पना करने में मदद कर सकता है:

                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-aaaaaaaaaahhh!

LLR - मारियो एक कदम पीछे जाने की कोशिश करता है और गिर जाता है।

UULDR - मारियो एक टाइल को दो बार पार करने का प्रयास करता है और हवा में कदम रखता है।

RRDDDDD - मारियो पहले D पर एक पुल से चलता है (निम्नलिखित चरणों की उपेक्षा करें)।

RRRRDDDDLLLL - मारियो एक त्रिकोण में चलता है और शुरुआती टाइल के माध्यम से गिरता है।

LLLLLLUUUUUURRRRRR - मारियो एक बड़े त्रिकोण में चलता है और शुरुआती टाइल के माध्यम से गिरता है।

UUUUUUUUUUUUUUUUUUUU - मारियो ग्रह के चारों ओर चलता है और शुरुआती टाइल के माध्यम से गिरता है।

RURDRURDRDLDRDLDLDLULDLLUU - मारियो एक अपरंपरागत मार्ग लेता है और अस्त-व्यस्त हो जाता है।

मारियो, महसूस कर रहा है कि वह जिस संकट में है, उसके पास कोई विकल्प नहीं है।

ULLDRDDDRUUU ULLDRDDDRUUL ULLDRDDDRUUR ULLDRDDDRUUD RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRR RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRU RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRL RURDRURDRDLDRDLDLDLULDLLLLLLLLLLLLLLLLURRRRRRRRRRRRRRD

अंत में, "मारियो प्रत्येक टाइल को बिल्कुल एक बार पार करता है" से किसी भी परीक्षण मामले को कॉपी करें और यादृच्छिक पर एक कदम बदलें या जोड़ें। मारियो गिरना चाहिए। (यदि आप अंत में एक कदम जोड़ते हैं, तो मारियो पावर स्टार को हथियाने के लिए गिर जाता है!)

_{* केंटेलिकेटेड क्यूब एक अधिक सही शब्द होगा क्योंकि कुछ चेहरे चौकोर नहीं होते हैं, लेकिन आपको स्वीकार करना होगा - "rhombicuboctahedron" बहता है।}

Comments

क्यूबिक्स या क्यूबिक में इसे हल करने के लिए बोनस अंक

— स्टीफन

यह मारियो गैलेक्सी खेलने की बहुत सारी यादें वापस लाता है - आसानी से सभी समय के मेरे पसंदीदा खेलों में से एक।

— notjagan

@ स्टेफ़ेन या मारियोलैंग: पी

— ईथप्रोडक्शन

@Stephen भले ही यह एक ऑक्टोगन है, हेक्सागोनी एसटी ... Y'know क्या, कभी कोई बात नहीं, जो हेक्सागोनी में ऐसा करेंगे।

— मैजिक ऑक्टोपस Urn

पिछले परीक्षण के मामले से 4 में, मारियो मर नहीं जाता है जब तक कि आप एक अतिरिक्त नहीं जोड़ते हैं R। मैंने यह सुनिश्चित करने के लिए कागज पर काम किया है कि मेरा कोड सही है।

— लेवल रिवर सेंट

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

रूबी, पहला काम करने वाला संस्करण, 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 2 डी मानचित्र पर मैप किया जाता है, जहां 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। यह उन रूपों के रूप में है जिन पर मारियो को कदम रखने की अनुमति है। जैसे ही मारियो उस वर्ग के चारों ओर घूमता है जो वह चालू होता है, शून्य पर सेट होता है, और जिस वर्ग में वह जा रहा है, उसका परीक्षण किया जाता है - वह रहता है इसमें एक 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"]

Comments

अच्छी तरह से किया! मुझे वास्तव में "स्ट्रिप" मैपिंग पसंद है और जिस तरह से आपने कैमरे के कोण के लिए जिम्मेदार है।

— darrylyeo