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

เส้นทางจะมีลักษณะดังนี้:

S = E
=====

ในเส้นทางสัญลักษณ์ต่าง ๆ และสิ่งที่เป็นตัวแทนคือ:

• =: ผนัง / พื้น / เพดาน มาริโอไม่สามารถเดินทะลุกำแพงและไม่สามารถล้มลงบนพื้นหรือกระโดดข้ามเพดาน (เขาจะตีหัว)
• (ช่องว่าง): อากาศ มาริโอสามารถเดินผ่านสิ่งนี้และกระโดดผ่านมันและผ่านมันไป
• S: อากาศยกเว้นการแสดงตำแหน่งที่มาริโอเริ่ม สิ่งนี้จะปรากฏในคอลัมน์ซ้ายสุดของอินพุตที่ระดับพื้นดิน
• E: อากาศยกเว้นแสดงตำแหน่งที่มาริโอต้องการรับ สิ่งนี้จะปรากฏในคอลัมน์ขวาสุดของอินพุตที่ระดับพื้นดิน

อินพุตจะมีช่องว่างในทุกที่ที่มาริโอสามารถเดินได้

มาริโอสามารถก้าวไปข้างหน้าเท่านั้น ในตัวอย่างนี้มาริโอไม่สามารถไปถึงเป้าหมายได้

S
===

 ===
   E
====

และเขาไม่สามารถอยู่ในนี้

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

อย่างไรก็ตามเขาสามารถเข้าถึงพื้นที่ที่แสดงด้วย#(ซึ่งจะไม่ปรากฏในอินพุต) เนื่องจากเขาสามารถกระโดดได้สูงถึงสี่เซลล์สูง มาริโอเป็นมนุษย์ธรรมดา เป็นอีกตัวอย่างหนึ่งของความเหนือมนุษย์ของเขา:

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

มาริโอจะได้รับไปโดยลดลงระยะทางที่ดีที่รอดตายและเดินอย่างใจเย็นไปE Eโปรดทราบว่าเขาไม่สามารถเข้าถึงได้#เพราะมาริโอตกลงไป

มาริโอสามารถกระโดดจริงๆสูง แต่ไม่ไกลมากไปข้างหน้าโดยการเปรียบเทียบ

S   E
== ==
 = =

มาริโออาจพยายามกระโดดข้ามช่องว่าง แต่เขาจะล้มเหลวและตกลงไปเขาไม่สามารถไปให้ถึงจุดจบได้

มาริโอสามารถบรรลุเป้าหมายในตัวอย่างเหล่านี้ทั้งหมด:

 E
 =
 =
 =
S=
==

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

S
=






=  E
====

นี่คือรหัสกอล์ฟดังนั้นจำนวนน้อยที่สุดที่จะชนะ!

สลิป , 38 27 25 ไบต์

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

ต้องมีการป้อนข้อมูลที่จะเสริมให้เป็นรูปสี่เหลี่ยมผืนผ้าเพื่อให้มีช่องว่างในทุกเซลล์ที่มาริโอต้องผ่าน (อาจเป็นเส้นนำที่เต็มไปด้วยช่องว่าง) พิมพ์ทั้งสตริงที่แสดงเส้นทางที่ถูกต้อง (ซึ่งรวมถึงS, Eและทุก=เดินบนยกเว้นที่ผ่านมา) หรือไม่มีอะไรถ้าเส้นทางไม่มี

ทดสอบที่นี่

คำอธิบาย

การจัดส่งเป็นทางเข้าของ Sp3000 ในการออกแบบภาษาที่จับคู่รูปแบบ 2D ของเรา มันเป็นเหมือนส่วนต่อขยายแบบสองมิติของ regex ที่คุณสามารถให้คำแนะนำกับเคอร์เซอร์ของเครื่องยนต์เมื่อได้รับอนุญาตหรือจำเป็นต้องเลี้ยวซ้ายหรือขวา นอกจากนี้ยังมีคุณสมบัติที่สะดวกซึ่งคุณสามารถป้องกันเคอร์เซอร์ไม่ให้เลื่อนไปมาช่วยให้คุณจับคู่ตำแหน่งเดียวสองครั้งในแถวเดียว (มีลวดลายแตกต่างกัน)

สลิปไม่ได้มีสิ่งที่เทียบเคียงกับ lookarounds ใน regex แต่เนื่องจากคุณสามารถเลื่อนตำแหน่งใด ๆ หลาย ๆ ครั้งหนึ่งสามารถทดสอบเงื่อนไขแล้วกลับมา เราใช้สิ่งนี้เพื่อให้แน่ใจว่าเราจะกระโดดเมื่ออยู่บนพื้นดินโดยการย้ายเข้าไปในกระเบื้องพื้นหลังจากแต่ละขั้นตอน

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.

Java 234 230 221 216 208 207 205 179 ไบต์

ดูสิฉันชนะ C และ python หรือไม่ ฉันประสบความสำเร็จในการมีชัยเหนือมนุษย์จริง ๆ ! ทุกเรื่องตลกนี่เป็นความท้าทายที่สนุก ฟังก์ชั่นต่อไปนี้รับอินพุตเป็นอาร์เรย์ของสตริงคอลัมน์แต่ละอันมีความยาวเท่ากัน หากสิ่งนี้ขัดกับกฎโปรดแจ้งให้เราทราบ ผลลัพธ์ 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=");

    }

}

Python, 260 239 222 215 209 206 Bytes,

ลองใช้กับ ideone (พร้อมกรณีทดสอบ)

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='])

บันทึกการแก้ไข:

ทีนี้เช่นเดียวกับโซลูชันอื่น ๆ สมมติว่าอินพุตเป็นอาร์เรย์ของสตริง coloumn ซึ่งแต่ละตัวเริ่มต้นด้วย ""

กระดาษห่อสำหรับรูปแบบการป้อนข้อมูลเก่า: g=lambda x:f(map("".join,zip(*([" "*x.index("\n")]+x.split("\n")))))

นอกจากนี้ฉันแก้ไขข้อผิดพลาดที่มาริโอสามารถกระโดดผ่านบล็อกด้านบนเขาได้

เวอร์ชันที่ไม่มีคำอธิบายพร้อมคำอธิบาย:

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

หอยทาก , 41 37 29 ไบต์

ขอบคุณ feersum สำหรับความช่วยเหลือในการหลีกเลี่ยงเส้นทางที่ทับซ้อนกันและประหยัด 4 ไบต์

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

ต้องมีการป้อนข้อมูลที่จะเสริมให้เป็นรูปสี่เหลี่ยมผืนผ้าเพื่อให้มีช่องว่างในทุกเซลล์ที่มาริโอต้องผ่าน (อาจเป็นเส้นนำที่เต็มไปด้วยช่องว่าง)

ลองออนไลน์!

คำอธิบาย

หอยทากเป็นรายการของ feersum ในการออกแบบการจับคู่รูปแบบ 2D ของเรา เช่นเดียวกับ Slip ก็คล้ายกับ regex แต่ความแตกต่างที่สำคัญคือ a) อันนี้รองรับการยืนยัน (lookarounds) และ b) นอกเหนือจากการยืนยันเหล่านี้มันเป็นไปไม่ได้ที่จะสำรวจเซลล์ใด ๆ ในตารางสองครั้ง นั่นทำให้ปัญหานี้ยุ่งยากเล็กน้อยเนื่องจากมีบางกรณีที่มาริโอต้องตกลงไปในหลุมและกระโดดกลับออกมาเช่น:

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.

C, 256 236 213 197 ไบต์

20 ไบต์ถูกบันทึกโดย "นี่จะปรากฏในคอลัมน์ซ้ายสุดของอินพุต"
23 ไบต์ที่บันทึกด้วยระบบคอลัมน์ของ @ RohanJhunjhunwala

ลองใช้ด้วย ideone พร้อมกรณีทดสอบ ...

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");}

Ungolfed พร้อมคำอธิบาย:

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
}

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
}

การทดสอบ (ในฟังก์ชั่น m)

$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>';

Ruby, 153 147 ไบต์

ขออภัย Java ... จุดของคุณในฐานะที่ไม่ใช่นักกอล์ฟที่ดีที่สุดสำหรับงานกำลังถูกครอบงำ!

อินพุตคือรายการของสตริงคอลัมน์ซึ่งมีพื้นที่เพียงหนึ่งเดียวในรูปแบบของวิธีการแก้ปัญหา Slip และ Snails ต้องการอินพุตของพวกเขาจะถูกเสริมด้วยสี่เหลี่ยมผืนผ้าของพื้นที่ว่าง

ลองออนไลน์!

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

Grime, 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

คำอธิบาย

คำอธิบายระดับสูงคือ nonterminal ที่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 ของการกระโดดตัวอย่างแบ่งออกเป็นรูปสี่เหลี่ยมผืนผ้าดังกล่าวและมีช่องว่างแทนที่ด้วย*s:

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

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

ฉันหวังว่าทั้งหมดนี้จะสมเหตุสมผล!