क्या मारियो इस नक्शे के अंत में जा सकता है

Question

एक प्रोग्राम बनाएं जो निर्धारित करता है, पथ का एक इनपुट दिया गया है, चाहे मारियो अंत तक पहुंच सकता है E, शुरू से चिह्नित, द्वारा चिह्नित S।

एक रास्ता कुछ इस तरह दिखेगा:

S = E
=====

एक मार्ग में, विभिन्न प्रतीक और वे जो प्रतिनिधित्व करते हैं वे हैं:

• =: दीवार / फर्श / छत। मारियो दीवार के माध्यम से नहीं चल सकता है, और एक मंजिल से गिर नहीं सकता है, या छत से पिछले कूद सकता है (वह अपने सिर को मार देगा)
• (space): वायु। मारियो इसके माध्यम से चल सकता है, और इसके माध्यम से कूद सकता है, और इसके माध्यम से गिर सकता है
• S: जहाँ मारियो शुरू होता है, उसे छोड़कर हवा। यह हमेशा इनपुट के बाएं-सबसे कॉलम में दिखाई देगा, जमीनी स्तर पर।
• E: हवा, यह दिखाने के अलावा कि मारियो कहाँ प्राप्त करना चाहता है। यह हमेशा इनपुट के दाहिने-सबसे कॉलम में दिखाई देगा, जमीनी स्तर पर।

इनपुट में हर उस जगह पर जगह होगी जहां मारियो चल सकता था।

मारियो ही आगे बढ़ सकता है; इस उदाहरण में मारियो लक्ष्य तक नहीं पहुंच सकता

S
===

 ===
   E
====

न ही वह इस एक में कर सकते हैं

    E
   ==
== 
  #==
==
   ==
==
S  ==
======

हालांकि, वह उस स्थान पर पहुंच सकता है, #जो (इनपुट में नहीं दिखाई देगा), क्योंकि वह चार कोशिकाओं तक ऊंची छलांग लगा सकता है; मारियो अलौकिक है। उनकी अलौकिकता के एक और उदाहरण के रूप में:

S
=
=
=
=
=
= #
= =
=
=
=
=     E
=======

मारियो Eमहान दूरी गिरने, जीवित रहने और शांति से चलने से मिल सकता है E। ध्यान दें कि वह नहीं पहुंच सकता है #, क्योंकि मारियो सीधे नीचे गिरता है।

मारियो वास्तव में उच्च कूद सकता है , लेकिन तुलना द्वारा बहुत आगे नहीं।

S   E
== ==
 = =

मारियो अंतराल को कूदने का प्रयास कर सकता है, लेकिन वह विफल हो जाएगा, और सीधे अंदर गिर जाएगा। वह अंत तक नहीं पहुंच सकता है।

मारियो इन सभी उदाहरणों में लक्ष्य तक पहुँच सकता है:

 E
 =
 =
 =
S=
==

 =
 =   E
S=   =
==   =
 =   =
 =====

S
=






=  E
====

यह कोड गोल्फ है, इसलिए सबसे कम बाइट्स जीतता है!

Comments

गिरते उदाहरण में, आप उल्लेख करते हैं कि "वह नहीं पहुंच सकता #, क्योंकि मारियो सीधे नीचे गिरता है।" अगर मैं इसे सही ढंग से देख रहा हूं, तो क्या वह सीधे नीचे नहीं गिरेगा #? इसके अलावा, क्या जंप को अधिकतम 4 स्थान और अधिकतम 1 स्थान सही के रूप में परिभाषित किया गया है?

— गिटारपरिक जूल

@GuitarPicker मैंने सोचा कि पहले अस्वस्थ लेकिन अगर आप निकट से देखते हैं तो आप देख सकते हैं कि स्तम्भ के साथ रिक्त स्थान का एक और स्तम्भ है #। दूसरे प्रश्न के रूप में: मैं ओपी नहीं हूं, लेकिन मैं अनुमान लगा रहा हूं कि आप सही हैं। (यही मैंने अपने समाधान में ग्रहण किया है)

— कार्लकास्टर

तीसरे उदाहरण में (मारियो के कूदने की ऊँचाई को Eप्रदर्शित करते हुए ), दाएं-सबसे कॉलम में दिखाई नहीं देता है, क्योंकि जमीनी स्तर बाकी के नक्शे से दाईं ओर विस्तृत होता है।

— टेलर लोपेज

@ जोफान:Mario cannot walk through wall , and cannot fall past a floor, or jump past a ceiling

— टाइटस

@ मुझे लगता है कि मैं स्पष्ट हवा में कूदने और अलग-अलग मंजिलों की पसंद पर उतरने के बारे में सोच रहा हूं - क्या वह निचले हिस्से तक पहुंच सकता है?

— जोफान

Answer 1

पर्ची , 38 27 25 बाइट्स

S>(`=<<`P{1,5}>`P>`P*)+#E

एक आयत पर इनपुट करने के लिए इनपुट की आवश्यकता होती है जैसे कि प्रत्येक सेल में रिक्त स्थान होते हैं जिन्हें मारियो को ट्रैवर्स करने की आवश्यकता होती है (संभावित रूप से रिक्त स्थान से भरी अग्रणी रेखा के साथ)। प्रिंट या तो मान्य पथ का प्रतिनिधित्व करने वाला एक स्ट्रिंग (जिसमें शामिल है S, Eऔर =अंतिम को छोड़कर सभी चले गए) या कुछ भी नहीं अगर कोई रास्ता मौजूद नहीं है।

इसका परीक्षण यहां करें।

व्याख्या

स्लिप हमारे 2D पैटर्न से मेल खाने वाली भाषा डिजाइन चुनौती के लिए Sp3000 की प्रविष्टि थी। यह रेगेक्स के 2 डी-एक्सटेंशन की तरह एक सा है जहां आप इंजन के कर्सर को निर्देश दे सकते हैं जब इसे अनुमति दी जाती है या बाएं या दाएं मोड़ की आवश्यकता होती है। इसमें एक सुविधाजनक सुविधा भी है जहां आप कर्सर को आगे बढ़ने से रोक सकते हैं, जिससे आप एक पंक्ति में दो बार (विभिन्न पैटर्न के साथ) एक ही स्थिति से मिलान कर सकते हैं।

स्लिप में रेगेरेक्स में लुकअप के लिए कुछ तुलनीय नहीं है, लेकिन जब से आप किसी भी स्थिति में कई बार आगे बढ़ सकते हैं, तो कोई बस स्थिति का परीक्षण कर सकता है और फिर वापस लौट सकता है। हम इसका उपयोग यह सुनिश्चित करने के लिए करते हैं कि हम प्रत्येक चरण के बाद ग्राउंड टाइल में जाकर जमीन पर कूदें।

S           Match the starting position S.
>           Turn right, so that the cursor points south.
(           One or more times... each repetition of this group represents
            one step to the right.
  `=          Match a = to ensure we've ended up on ground level before.
  <<          Turn left twice, so that the cursor points north.
  `P{1,5}     Match 1 to 5 non-punctuation characters (in our case, either space,
              S or E, i.e. a non-ground character). This is the jump.
  >           Turn right, so that the cursor points east.
  `P          Match another non-ground character. This is the step to the right.
  >           Turn right, so that the cursor points south.
  `P*         Match zero or more non-ground characters. This is the fall.
)+
#           Do not advance the cursor before the next match.
E           Match E, ensuring that the previous path ended on the exit.

Answer 2

जावा 234 230 221 216 208 207 205 179 बाइट्स

देखो, मैं सी और अजगर को हरा दूं? मैंने नश्वर लोगों के बीच सच्चा पारगमन हासिल कर लिया है! सभी एक तरफ मजाक करते हैं, यह एक मजेदार चुनौती थी। निम्न फ़ंक्शन एक समान लंबाई के साथ प्रत्येक कॉलम के तार के इनपुट के रूप में लेता है। यदि यह नियमों के विरुद्ध है तो कृपया मुझे बताएं। यह 1 मतलब है कि एक सफल मारियो रन, और किसी अन्य मूल्य एक असफल मारियो रन का मतलब है।

int m(String[]a){int l=a.length-1,z=a[l].indexOf(69),m=a[0].indexOf(83),i=1,x;a[l]=a[l].replace("E"," ");for(;i<=l;m=x,i++){if(m-(x=a[i].indexOf('='))>3|x<1)return-1;}return m-z;}

उदाहरण के उपयोग और आउटपुट के साथ यहां पुराना तर्क (जो वर्तमान संस्करण के समान है) है। साथ ही कुछ टिप्पणियाँ तर्क की व्याख्या करते हुए

/**
 *
 * @author Rohans
 */
public class Mario {

    int m(String[] a) {
//declare variables for the finish the location of mario and the length
        int z, l = a.length - 1, m = a[0].indexOf("S");
        //treat the exit as a space
        z = a[l].indexOf("E");
        a[l] = a[l].replaceAll("E", " ");
        //go through the map
        for (int i = 1, x, r = 1; i <= l; i++) {
            //if mario can safely jump to the next platform (it picks the highest one)
            if (((x = a[i].indexOf("=")) != 0 && (x = a[i].indexOf(" =")) == -1) || m - x > 4) {
                return 0;
            }
            //adjust marios y location
            m = x;
        }
        //make sure mario made it to the end of the level
        return m == z ? 1 : 0;
    }

    public static void MarioTest(String... testCase) {
        System.out.println(new Mario().m(testCase) == 1 ? "Mario made it" : "Mario did not make it");
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        MarioTest("   S=", "=====", "     =", "     =", "=   =", "     E=");

    }

}

Comments

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— २०:०६ पर सुपारी

काम नहीं करता है अगर सही रास्ता एक पहुंच से नीचे है "="

— कार्ल

@KarlKastor, आप मुझे मिल गए, लेकिन दिए गए परीक्षण का मामला सही है। मुद्दा यह है कि ऑप ने इस बात को स्पष्ट नहीं किया है कि क्या प्रत्येक चरण में कई तरीके हो सकते हैं

— रोहन झुनझुनवाला

ठीक है, मुझे लगता है कि वहाँ होगा क्योंकि मैं हमेशा अधिक सामान्य संस्करण मान लेगा अगर अतिरिक्त बाधा निर्दिष्ट नहीं की जाती है।

— कार्लकस्टर

@ कर्लकास्टर योर उर राइट

— रोहन झुनझुनवाला

Answer 3

पायथन, 260 239 222 215 209 206 बाइट्स,

इसे आइडोन पर परखें (परीक्षण मामलों के साथ)

f=lambda m,y=-1,x=0:f(m,m[0].find("S"))if y<0else y<len(m[0])-1and x<len(m)and m[x][y]!="="and(m[x][y]=="E"or m[x][y+1]=="="and any(f(m,y-i,x+1)for i in range(5)[:(m[x][y::-1]+"=").find("=")])or f(m,y+1,x))

जैसे कॉल करें: f([' S=', ' E='])

पैच नोट्स:

अब, कुछ अन्य समाधानों की तरह, माना जाता है कि इनपुट कॉलुमैन स्ट्रिंग्स का एक सरणी है, प्रत्येक एक "" से शुरू होता है

पुराने इनपुट फॉर्म के लिए आवरण: g=lambda x:f(map("".join,zip(*([" "*x.index("\n")]+x.split("\n")))))

इसके अलावा, मैंने एक बग तय किया जहां मारियो उसके ऊपर ब्लॉक के माध्यम से कूद सकता है।

स्पष्टीकरण के साथ ungolfed संस्करण:

fमारियो अपने आप को सभी दिशाओं में बुला सकता है y,x। Trueजब यह पहुंचता है तो यह वापस लौटता है "E"nd, जो gअंत में लौटने तक सभी फ़ंक्शन कॉल के माध्यम से वापस चला जाता है True।

def g(x):
    #create a array of strings which are the rows of the input
    global m
    m=x.split("\n")
    m=[" "*len(m[0])]+m # because Mario can jump over sometimes
    #Mario starts at the S
    return f([i for i,a in enumerate(m) if a[0]=="S"][0],0)

def f(y,x):
    #print y,x
    if y>len(m)-2 or x>=len(m[0]) or y<0: return False #out of bounds
    if m[y][x]=="E":return True #Reached the goal
    if m[y][x]=="=":return False #We got stuck inside a wall
    if m[y+1][x]=="=": #if you have ground under your feet
        for i in range(5): #jump max 4
            if f(y-i,x+1): #go one forward and try to go further from there
                return True
    return f(y+1,x) ##fall down

Comments

यदि कूदना मदद नहीं करता है, तो आप जमीन से गिरते हैं। elseफाइनल से पहले जोड़ें return?

— टाइटस

Answer 4

घोंघे , 41 37 29 बाइट्स

अतिव्यापी रास्तों से बचने और 4 बाइट्स बचाने के लिए कुछ मदद के लिए फ़र्सम का धन्यवाद।

=\S(^=d=\=u\ ,4(r!\=d.),r),\E

एक आयत पर इनपुट करने के लिए इनपुट की आवश्यकता होती है जैसे कि प्रत्येक सेल में रिक्त स्थान होते हैं जिन्हें मारियो को ट्रैवर्स करने की आवश्यकता होती है (संभावित रूप से रिक्त स्थान से भरी अग्रणी रेखा के साथ)।

इसे ऑनलाइन आज़माएं!

व्याख्या

घोंघे हमारे 2D पैटर्न मिलान भाषा डिजाइन चुनौती के लिए फ़र्सम की प्रविष्टि थी। स्लिप की तरह यह भी रेगेक्स की तरह ही है, लेकिन प्रमुख अंतर यह है कि क) यह एक दावे (लुक) और बी) को इन सिद्धांतों से अलग करता है, किसी भी सेल को दो बार ग्रिड में बदलना संभव नहीं है। इस समस्या को थोड़ा मुश्किल बना देता है, क्योंकि ऐसे मामले हैं जहां मारियो को एक छेद में गिरने और वापस बाहर कूदने की जरूरत है, जैसे:

S E
= =
===

इन अंतरों के अलावा, दो भाषाओं का वाक्य विन्यास भी काफी भिन्न होता है।

इस समस्या को दरकिनार करने के लिए कि हम एक सेल को दो बार पार नहीं कर सकते, हम हमेशा एक ऊर्ध्वाधर कदम के साथ एक क्षैतिज चरण को वैकल्पिक करते हैं। हालांकि, इसका मतलब यह है कि हम को आगे बढ़ने से पहले एक गिरावट को संभालना होगा। इसलिए फॉल्स तकनीकी रूप से ग्राउंड टाइल्स से गुजरेंगे लेकिन हम यह सुनिश्चित करेंगे कि वे केवल खुली जगह के बगल में ही हों।

=\S        Ensure that the match starts on an S, without actually matching it.
(          This group matches zero or more steps to the right (with a potential
           vertical step after each one).
  ^=         Match a non-ground cell, stepping right (on the first iteration,
             there is no step yet, so this matches the S).
  d=\=       Ensure that there's a ground tile below, so that the step ends on
             a valid position.
  u\ ,4      Match 0 to 4 spaces going up. This the optional jump.
  (          This group matches zero or more steps down, if a fall is valid here.
    r!\=       Ensure that there is no ground-tile right of the current cell.
    d.         Take one step down onto any character.
  ),
  r          Reset the direction to right for the next iteration.
),
\E        Match the exit.

Answer 5

सी, 256 236 213 197 बाइट्स

20 बाइट्स "द्वारा सहेजा गया है यह हमेशा इनपुट के बाएं-सबसे कॉलम में दिखाई देगा"
23 बाइट्स @ RohanJhunjhunwala के कॉलम-आधारित सिस्टम के लिए धन्यवाद

परीक्षण मामलों के साथ, विचारधारा पर इसे आज़माएं ...

k,y,x,h;f(v,l)char**v;{h=strlen(*v);x=strcspn(*v,"S");while(y<l&x<h)if(v[y][x]==69)return 0;else if(v[y][x+1]^61)x++;else{if(v[y+1][x]==61)while(k<4)if(v[y+1][x-++k]^61){x-=k;break;}y++;}return 1;}

उपयोग:

$ ./mario "S=" " =" " =" " =" "E="
main(c,v)char**v;{printf("%s",f(v+1,c-1)==0?"true":"false");}

---

स्पष्टीकरण के साथ अपुष्ट:

k,y,x,h; //omitting int for saving 4 bytes, global variables initialize as 0 by default
f(v,l)char**v;{ //saving 2 bytes
    h=strlen(v[0]); //get height of map
    x=strcspn(v[0],"S"); //where is start point?
    while(y<l&&x<h) //while not out of bounds
        if(v[y][x]==69)return 0; //if we hit end return 0 (69 is ASCII E)
        else if(v[y][x+1]!=61)x++; //we fall one block if there isn't floor underneath us (61 is ASCII =)
        else{
            if(v[y+1][x]==61) //if there is a wall in front of us
                while(k<4) //start counting
                    if(v[y+1][x-++k]!=61){ //if found a way
                        x-=k; //go to there
                        break; //we don't want to jump multiple times
                    }
            y++; //finally, walk one block forwards
        }
    return 1; //if out of bounds
}

Comments

Ideone का कहना है कि एक रनटाइम त्रुटि है

— TuxCrafting

रुकिए, आप मोबाइल पर कोडिंग कर रहे हैं

— ಠ_ you

— हां

( विश्वासघात का मतलब नहीं है , सिर्फ निष्पक्षता सुनिश्चित करने के लिए) @ TCxCräftîñg: क्या यह समाधान आपकी चुनौती के अनुरूप है क्योंकि यह स्ट्रिंग्स की एक सरणी लेता है (पहले से ही "\ n" पर विभाजित है) और इनपुट की लंबाई और चौड़ाई के रूप में भी है नक्शा (आपकी चुनौती में इनपुट का हिस्सा नहीं)?

— कार्लकास्टर

यह एक रनटाइम त्रुटि फेंकता है यदि समाधान पथ की तुलना में कम रास्ता संभव है

— कार्लकास्टर

Answer 6

PHP, 399 338 284 265 251 बाइट्स

<?function w($m,$p){$w=strpos($m,"
")+1;if($p>strlen($m)|($p%$w)>$w-2|$p<0|'='==$m[$p])return 0;if('E'==$m[$p])die(1);if('='!=$m[$p+$w])return w($m,$p+$w);else for(;$z<5&'='!=$m[$q=$p-$w*$z];$z++)if(w($m,$q+1))die(1);}die(w($m=$argv[1],strpos($m,S)));

यूनिक्स शैली लाइन के साथ कमांड लाइन तर्क के रूप में इनपुट की उम्मीद करता है और हर पंक्ति में रिक्त स्थान को पीछे छोड़ता है 1, 0विफलता के लिए सफलता के लिए निकास कोड देता है

कार्य करने के लिए ब्रेकडाउन

function w($m,$p) // function walk
{
    $w=strpos($m,"\n")+1;
    if($p<0|$p>strlen($m)|($p%$w)>$w-2  // too high / too low / too far right
        | '='==$m[$p]                   // or inside a wall
    )return 0;
    if('E'==$m[$p])return 1;            // Exit found
    if('='!=$m[$p+$w])return w($m,$p+$w); // no wall below: fall down
    else for($z=0;$z<5                  // else: jump
        & '='!=$m[$q=$p-$w*$z]          // do not jump through walls
        ;$z++)
        if(w($m,$q+1))                  // try to walk on from there
            return 1;
    // no success, return failure (NULL)
}
function m($i){$argv=[__FILE__,$i];
    return w($m=$argv[1],strpos($m,S));     // walk through map starting at position of S
}

परीक्षण (फ़ंक्शन एम पर)

$cases=[
    // examples
    "S = E\n=====",0,
    "S   \n=== \n    \n ===\n   E\n====",0,
    "    E \n   == \n==    \n   == \n==    \n   == \n==    \nS  == \n======",0,
    "S      \n=      \n=      \n=      \n=      \n=      \n=      \n= =    \n=      \n=      \n=      \n=     E\n=======",1,
    "S   E\n== ==\n = = ",0,
    " E\n =\n =\n =\nS=\n==",1,
    "      \n =    \n =   E\nS=   =\n==   =\n =   =\n =====",1,
    "S   \n=   \n    \n    \n    \n    \n    \n    \n=  E\n====",1,
    // additional cases
    "S \n= \n=E",1,
    " == \n == \n    \nS==E\n==  ",1
];
echo'<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';
while($cases)
{
    $m=array_shift($cases);
    $e=array_shift($cases);
    $y=m($m);
    $w=strpos($m,"\n");
    echo"<tr><td><div style=background-color:yellow;width:",$w*8,"px><pre>$m</pre></div>width=$w</td>
        <td>$y</td><td>$e</td><td>",$e-$y?'N':'Y',"</td></tr>";
}
echo'</table>';

Comments

जो कोई भी: क्या आप कृपया मुझे बताएंगे कि आपने इसे क्यों ठुकरा दिया?

— टाइटस

Answer 7

रूबी, 153 147 बाइट्स

क्षमा करें, जावा ... नौकरी के लिए सबसे अच्छा गैर-गोल्फ लैंग के रूप में आपका स्थान लिया जा रहा है!

इनपुट कॉलम स्ट्रिंग्स की एक सूची है, जो कि स्लिप और घोंघे के समाधान की शैली में एक ही स्थान के साथ जुड़ा हुआ है, उनके इनपुट को खाली स्थान की आयत के साथ गद्देदार करने की आवश्यकता होती है।

इसे ऑनलाइन आज़माएं!

f=->m,j=0,s=p{c,n=m[j,2]
s||=c=~/S/
e=c=~/E/
s+=1 while(k=c[s+1])&&k!=?=
s==e||(0..4).any?{|i|k&&s>=i&&c[s-i,i]!~/=/&&n&&n[s-i]!=?=&&f[m,j+1,s-i]}}

Comments

nooooo .... लेकिन u ने स्तंभों के तार के मेरे तरीके को "उधार" किया

— रोहन झुनझुनवाला

वैसे मेरा मतलब है कि सभी शांत बच्चे पहले से ही ऐसा कर रहे थे। बाद में पंक्तियों को संशोधित करने के लिए "क्विक फिक्स" को कॉलम में संशोधित करने के लिए, अपने वर्तमान कोड को 10 बाइट्स तक आपके जावा में रखने के लिए "क्विक फिक्स" कर सकते हैं, लेकिन वास्तविक समाधान भले ही छोटा हो

— वैल्यू इंक

Answer 8

ग्रिम, 46 बाइट्स (गैर-प्रतिस्पर्धात्मक)

A=\E|[S ]&<\ {,-4}/0/./* \ /*/A/\=/./*>
n`\S&A

मैंने इस चुनौती के पोस्ट होने के बाद कई बार Grime को अपडेट किया है, इसलिए यह उत्तर जीतने के योग्य नहीं है। कुछ परिवर्तन इतने नए हैं कि मैं उन्हें TIO में लाने में सक्षम नहीं हूं, लेकिन एक बार जब मैं ऐसा करता हूं, तो आप प्रोग्राम को आज़मा सकते हैं । किसी भी स्थिति में, मेरे भंडार में एक संस्करण है जो इस कोड को सही ढंग से संभालता है।

1यदि मारियो लक्ष्य तक पहुँच सकता है, और 0यदि नहीं तो प्रोग्राम प्रिंट करता है । इनपुट को उन सभी स्थानों पर रिक्त स्थान समाहित करना है, जहाँ मारियो को जाने की जरूरत है। सामान्य जानकारी के लिए, मेरे पास निम्नलिखित 57 बाइट समाधान हैं:

A=\E|[ \bS]&<[ \b]{,-4}/0/[]/* [ \b]/*/A/\=/[]/*>
nb`\S&A

व्याख्या

उच्च-स्तरीय व्याख्या यह है कि Aपहली पंक्ति पर परिभाषित गैर-समरूप , इनपुट के 1 × 1 उप-आयत से मेल खाता है जहां मारियो लक्ष्य तक पहुंच सकता है। Aको या तो शाब्दिक के रूप में परिभाषित किया गया है E(मारियो पहले से ही लक्ष्य पर है), या 1 × 1 पैटर्न के रूप में जो कि कुछ 2 × n आयत के बाएं स्तंभ पर है जिसमें एक वैध मारियो कूदता है Aजो दाएं कॉलम के दूसरे मैच के लिए है। दूसरी पंक्ति गिनती के मैचों की संख्या को Aभी शामिल करती है जिसमें प्रारंभ वर्ण Sऔर प्रिंट होते हैं।

यहाँ कोड का ब्रेक-डाउन है:

A=\E|[ S]&<\ {,-4}/0/./* \ /*/A/\=/./*>
A=                                       Define A as
  \E|                                    a literal E, or
     [ S]&                               a literal space or S
          <                           >  contained in a larger rectangle
                                         that this bracketed expression matches.
           \ {,-4}/0/./*                 Left half of the bracketed expression:
           \ {,-4}                        Rectangle of spaces with height 0-4,
                  /                       below that
                   0                      the 1x1 rectangle we're currently matching,
                    /.                    below that any 1x1 rectangles
                      /*                  stacked any number of times vertically.
                         \ /*/A/\=/./*   Right half of the bracketed expression:
                         \ /*             Spaces stacked vertically,
                             /A           below that another match of A,
                               /\=        below that a literal =,
                                  /./*    below that 1x1 rectangles stacked vertically.

विचार यह है कि \ {,-4}बाईं ओर का हिस्सा उस स्थान से मेल खाता है जिसके माध्यम से मारियो ऊपर की ओर कूदता है, और \ /*दाईं ओर का हिस्सा उस अंतरिक्ष गर्त से मेल खाता है जिसे वह फिर नीचे गिरता है। हमें आवश्यकता है कि वह उस मैच के लिए उतरे A(जब से हम लक्ष्य तक पहुंचना चाहते हैं) =। दोनों स्तंभों के नीचे ऊर्ध्वाधर ढेर बस गारंटी देंगे कि स्तंभों की ऊंचाई समान है, इसलिए हम उन्हें समेट सकते हैं (जो बीच में एकल स्थान करता है)। यहाँ एक उदाहरण छलांग का ASCII कला आरेख है, जो पूर्वोक्त आयतों में टूटा हुआ है, और इसके द्वारा प्रतिस्थापित स्थानों के साथ *:

Left column:     Right column:   +---+---+
a = \ {,-4}      d = \ /*        | * | * |
b = 0            e = A           +   +   + d
c = ./*          f = \=          | * | * |
                 g = ./*       a +   +---+
                                 | * | * | e
                                 +   +---+
                                 | * | = | f
                                 +---+---+
                               b | S | = |
                                 +---+   | g
                               c | = | * |
                                 +---+---+

दूसरी पंक्ति में, विकल्प nपहले मैच को खोजने के बजाय सभी मैचों की गिनती को ट्रिगर करता है। सामान्य समाधान में, रिक्त स्थान विशेष आउट-ऑफ-इनपुट वर्ण भी हो सकते हैं और विकल्प bइनपुट को आउट-ऑफ़-इनपुट वर्णों के साथ गद्देदार होने का कारण बनता है।

मुझे आशा है कि यह सब समझ में आता है!