कोपा शैल अनुक्रम

Question

विभिन्न सुपर मारियो खेलों में हरे और लाल कोप्पा ट्रोपा के गोले सपाट सतहों पर घर्षणहीन रूप से स्लाइड कर सकते हैं और ईंट ब्लॉक को नष्ट कर सकते हैं जो उनके रास्ते में हैं। जब कोई शेल ईंट से टकराता है तो ब्लॉक टूट जाता है, इसे खाली जगह में बदल देता है, और कोपा शेल दिशा को उलट देता है। एक उदाहरण के रूप में, यहां लाल खोल देखें ।

मान लीजिए कि एक सुपर मारियो स्तर सिर्फ एक ब्लॉक ऊंचा है और हर ग्रिड सेल या तो एक ईंट या खाली जगह है, जो सबसे बाईं सेल को छोड़कर एक दाहिनी ओर चलती शेल है। स्तर भी आवधिक है , इसलिए यदि शेल स्तर के दाएं या बाएं किनारे से बाहर निकलता है तो यह विपरीत दिशा में पुन: पेश करेगा। इस स्थिति में खोल बंद रहेगा और स्तर के सभी ईंट ब्लॉकों को तब तक तोड़ता रहेगा जब तक कि कोई और अधिक न हो। अंतिम ईंट ब्लॉक के टूटने के बाद शेल कितनी दूर तक जाएगा?

चुनौती

एक गैर-नकारात्मक दशमलव पूर्णांक में होने वाले प्रोग्राम या फ़ंक्शन को लिखें। बिना किसी अग्रणी शून्य (केवल अपवाद 0 के साथ) में बाइनरी में व्यक्त यह संख्या, एक-ब्लॉक-उच्च स्तर के लेआउट को एन्कोड करती है। A 1एक ईंट ब्लॉक है और एक 0खाली जगह है।

कोप्पा शैल स्तर के बहुत बाएं किनारे पर डाला गया है और शुरू में दाएं घूम रहा है। उदाहरण के लिए, इनपुट 39से जुड़ा स्तर है

>100111

क्योंकि 100111बाइनरी में 39 है, और >और <सही प्रतिनिधित्व करते हैं और क्रमश: गोले चलती छोड़ दिया है।

बहुत अंतिम ईंट ब्लॉक (उर्फ 1) टूट जाने के बाद आपको शेल द्वारा यात्रा की गई कुल दूरी को प्रिंट या वापस करने की आवश्यकता होती है ।

के लिए आउटपुट 39है 7और स्तर में परिवर्तन इस तरह दिखता है:

Level      Cumulative Distance
>100111    0
<000111    0
>000110    0
0>00110    1
00>0110    2
000>110    3
000<010    3
00<0010    4
0<00010    5
<000010    6
000001<    7
000000>    7  <-- output

इसी प्रकार, इसके लिए आउटपुट 6है 1:

Level    Cumulative Distance
>110     0
<010     0
001<     1
000>     1  <-- output

बाइट्स में सबसे छोटा कोड जीतता है।

संदर्भ के लिए, यहां इनपुट के 0लिए आउटपुट हैं 20:

0 0
1 0
2 0
3 0
4 0
5 0
6 1
7 1
8 0
9 0
10 1
11 2
12 2
13 1
14 3
15 3
16 0
17 0
18 1
19 3
20 2

और यहाँ इनपुट के लिए आउटपुट हैं 1000।

Answer 1

सीजेएम, 29 26 24 बाइट्स

3 बाइट बचाने के लिए Sp3000 का धन्यवाद।

q~2b{_1&}{W\({%}*0+}w],(

परीक्षण सूट। (यह एसटीडीआईएन पर दिए गए पूर्णांक से सभी परिणामों को प्रिंट करता है।)

व्याख्या

यह अपने सिर पर कल्पना को थोड़ा बदल देता है: शेल को बाइनरी स्ट्रिंग के माध्यम से स्थानांतरित करने के बजाय, हम बाइनरी स्ट्रिंग को स्थानांतरित करते हैं और रिवर्स करते हैं जैसे कि शेल हमेशा सामने होता है, दाईं ओर इंगित करता है:

q~      e# Read and evaluate the input.
2b      e# Convert to base-2 to get the "level".
{_1&}{  e# While there is a 1 in the level...
  W\    e#   Put a -1 below the level.
  (     e#   Pull off the first digit, i.e. the cell the shell is pointing at.
  {     e#   If it's a 1 (i.e. a brick)...
    %   e#     Reverse the level, consuming the -1. This isequivalent to reversing the 
        e#     shell in place.
  }*
  0+    e#   Append a zero. If the cell was a brick, this just replaces it with an empty
        e#   cell. Otherwise, this rotates the level by one cell. This is equivalent 
        e#   to moving the shell one cell through the periodic level.
        e#   Note that if the leading cell was 0, the -1 remains on the stack.
}w
],(     e# Wrap the stack in an array, get its length and decrement.

Answer 2

पायथ, 24 बाइट्स

&.WsH_XZeaYxZ1 0jQ2ssPBY

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

निम्नलिखित 22 बाइट्स कोड को भी करना चाहिए। यह वर्तमान में काम नहीं करता है, Pyth संकलक में बग के कारण।

&u_XGeaYxG1ZjQ2)ssPBPY

संपादित करें: बग को ठीक किया गया, लेकिन निश्चित रूप से समाधान की गिनती नहीं है।

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

आगे और पीछे से बारी-बारी से मैं निम्नलिखित कार्य करता हूं:

• मैं 1 की खोज करता हूं
• इस सूचकांक को सूची में रखकर याद करें
• इसे 1 से 0 तक अपडेट करें

जब कोई 1s शेष नहीं होता है, तो मैं दूरी की गणना करता हूं। महत्वपूर्ण है: शेल अंतिम दूरी को छोड़कर, सूची में प्रत्येक दूरी को दो बार (आगे और पीछे) घुमाता है।

&.WsH_XZeaYxZ1 0jQ2ssPBY   implicit: Y = empty list
                jQ2        convert input number to binary
 .WsH                      start with Z=^; 
                           while the sum(Z) > 0, apply the the following to Z:
           xZ1                index of 1 in Z
         aY                   append this to Y
        e                     take the last element of Y (=this index)
      XZ       0              set this 1 (at index ^) in Z to 0
     _                        and revert the order of Z
                           this returns a list of zeros
&                          don't print ^, print the next thing
                     PBY   creates the list [Y, Y[:-1]]
                    s      combine these lists
                   s       sum up the distances