Yolun bir girdisi verildiğinde, Mario'nun sona ulaşıp ulaşamayacağını E, başlangıçtan, tarafından belirtilip belirtilmediğini belirleyen bir program oluşturun S.

Bir yol şöyle görünecektir:

S = E
=====

Bir yolda, çeşitli semboller ve temsil ettikleri:

• =: duvar / zemin / tavan. Mario duvardan geçemez ve bir yerden geçemez veya tavandan atlayamaz (kafasını vuracaktı)
• (boşluk): hava. Mario bunun üzerinden geçebilir, üzerinden atlayabilir ve içine düşebilir
• S: hava, Mario'nun nerede başladığını göstermek dışında. Bu, her zaman girişin en sol sütununda zemin seviyesinde görünecektir.
• E: hava, Mario'nun nereye gitmek istediğini göstermek dışında. Bu, her zaman girişin en sağ sütununda zemin seviyesinde görünecektir.

Girişte Mario'nun yürüyebileceği her yerde boşluklar olacak.

Mario sadece ilerleyebilir; bu örnekte Mario hedefe ulaşamıyor

S
===

 ===
   E
====

ne de o bu

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

Bununla birlikte, #(girişte görünmeyecek) ile belirtilen boşluğa ulaşabilir , çünkü dört hücreye kadar atlayabilir; Mario insanüstü. Süpermenliğine başka bir örnek olarak:

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

Mario E, büyük mesafeyi düşerek, hayatta kalarak ve sakince yürüyerek ulaşabilir E. #Mario'nun yere düştüğü için ona ulaşamayacağını unutmayın .

Mario gerçekten yüksek atlayabilir , ancak karşılaştırma ile çok ileriye değil.

S   E
== ==
 = =

Mario boşluğu atlamaya çalışabilir, ama başarısız olur ve düz düşer. Sonuna ulaşamaz.

Mario tüm bu örneklerde hedefe ulaşabilir:

 E
 =
 =
 =
S=
==

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

S
=






=  E
====

Bu kod golf, çok az bayt kazanır!

Kayma , 38 27 25 bayt

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

Girdinin bir dikdörtgene doldurulmasını gerektirir, böylece Mario'nun geçmesi gereken her hücrede boşluklar olur (potansiyel olarak boşluklarla dolu bir lider çizgi ile). Baskılar ya (içerir geçerli bir yol temsil eden bir dize S, Eve tüm =Sonuncusu hariç yürüdü) hiçbir yolu varsa ya da hiç.

Burada test edin.

açıklama

Slip, Sp3000'in 2D desen eşleştirme dili tasarım zorluğumuza girişiydi . Bu, biraz sola veya sağa dönüş yapmak için izin verildiğinde veya gerektiğinde motor imlecine talimatlar verebileceğiniz regex'in 2B uzantısı gibi. Ayrıca, imlecin ilerlemesini önleyebileceğiniz ve arka arkaya tek bir konumu (farklı desenlerle) eşleştirmenizi sağlayan kullanışlı bir özelliğe sahiptir.

Kayma, normal ifadeyle çevreyle karşılaştırılabilir bir şeye sahip değildir, ancak herhangi bir konum üzerinde birden çok kez hareket edebildiğiniz için, sadece durumu test edip geri dönebilirsiniz. Bunu, her adımdan sonra sadece yer karosuna geçerek yere atladığımızdan emin olmak için kullanırız.

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 216208207205179 Bayt

Bak, C ve pitonu yendim mi? Ölümlüler arasında gerçek aşkınlığa ulaştım! Tüm şakalar bir yana, bu eğlenceli bir mücadeleydi. Aşağıdaki işlev, girdiyi her biri aynı uzunlukta bir dizi sütun dizesi olarak alır. Bu kurallara aykırı ise lütfen bana bildirin. Çıktı 1, başarılı bir mario çalışması anlamına gelir ve başarısız bir mario çalışması anlamına gelen diğer değerler.

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

Örnek kullanım ve çıktı ile eski mantık (mevcut sürüme benzer). Ayrıca mantığı açıklayan bazı yorumlar

/**
 *
 * @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=");

    }

}

Piton, 260 239 222 215 209 206 bayt,

ideone üzerinde deneyin (test senaryoları ile)

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))

şöyle çağır: f([' S=', ' E='])

yama notları:

Şimdi, diğer bazı çözümlerde olduğu gibi, girdilerin her biri "" ile başlayan bir dizi sütun dizesi olduğunu varsayar.

Eski giriş formu için sarıcı: g=lambda x:f(map("".join,zip(*([" "*x.index("\n")]+x.split("\n")))))

Ayrıca, Mario'nun üstündeki bloklardan atlayabileceği bir hatayı düzelttim.

açıklamalarla ungolfed versiyonu:

fözyinelemeli olarak Mario'nun taşınabileceği her yöne kendini çağırır y,x. Bu döndürür Trueo ulaştığında "E"ndo zamana kadar tüm işlev çağrıları üzerinden geri gider, gnihayet getiriler 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

Salyangoz , 41 37 29 bayt

Üst üste binen yollardan kaçınmak ve 4 bayt tasarruf etmek için feersum'a teşekkürler.

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

Girdinin bir dikdörtgene doldurulmasını gerektirir, böylece Mario'nun geçmesi gereken her hücrede boşluklar olur (potansiyel olarak boşluklarla dolu bir lider çizgi ile).

Çevrimiçi deneyin!

açıklama

Salyangozlar feersum'un 2D desen eşleştirme dil tasarım zorluğumuza girişiydi . Slip gibi regex'e de benzer, ancak en büyük fark, a) bu iddiayı (bakışlar) ve b) bu ​​iddiaların yanı sıra, ızgaradaki herhangi bir hücreyi iki kez geçmek mümkün olmamasıdır. Bu sorunu biraz zorlaştırır, çünkü Mario'nun bir deliğe düşmesi ve geri atlaması gereken durumlar vardır, örneğin:

S E
= =
===

Bu farklılıkların yanı sıra, iki dilin sözdizimi de oldukça farklıdır.

Bir hücreyi iki kez geçemediğimiz sorunu atlatmak için, yatay bir adımı her zaman dikey bir adımla değiştiririz. Ancak bu, çıkıntının üzerinden geçmeden önce bir düşüşle başa çıkmamız gerektiği anlamına gelir. Yani düşmeler teknik olarak yer karolarından geçecek, ancak bunların sadece açık alanın yanında olmasını sağlayacağız.

=\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 bayt

"Bu her zaman girişin en sol sütununda görünecektir" tarafından 20 bayt
@ RohanJhunjhunwala'nın sütun tabanlı sistemi sayesinde 23 bayt kaydedildi

Test senaryoları ile ideone üzerinde deneyin ...

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

Kullanımı:

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

Açıklanamayan:

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 bayt

<?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)));

beklediğini her satırda komut satırı Unix tarzı satır sonları ile argüman ve sondaki boşluk olarak girdi, çıkış kodu döndürür 1, başarı için 0başarısızlık

fonksiyon dökümü

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
}

testler (m fonksiyonunda)

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

Yakut, 153147 bayt

Üzgünüm, Java ... iş için en iyi golf olmayan lang olarak yerini alıyor!

Girdi, Kayma ve Salyangoz çözümlerinin girdilerinin boş bir dikdörtgenle doldurulmasını nasıl gerektirdiği tarzında tek bir boşlukla başa eklenen bir sütun dizelerinin listesidir.

Çevrimiçi deneyin!

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 bayt (rakip olmayan)

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

Bu meydan okuma yayınlandıktan sonra Grime'ı birkaç kez güncelledim, bu yüzden bu cevap kazanmak için uygun değil. Değişikliklerden bazıları o kadar yenidir ki, bunları TIO'ya getiremedim, ancak bir kez yaptıktan sonra programı deneyebilirsiniz . Her durumda, benim depo doğru bu kodu işleyen bir versiyonunu içeriyor.

Program 1, Mario hedefe ulaşıp ulaşamayacağını yazdırır 0. Giriş, Mario'nun ziyaret etmesi gereken her yerde boşluk içermelidir. Genel girişler için aşağıdaki 57 baytlık bir çözüme sahibim :

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

açıklama

Üst düzey açıklama, Ailk satırda tanımlanan nonterminalin , Mario'nun hedefe ulaşabileceği girişin 1 × 1 alt dikdörtgeniyle eşleşmesidir . Aya değişmez E(Mario zaten hedefte) veya sağ sütundaki başka bir eşleşmeye geçerli bir Mario atlaması içeren bazı 2 × n dikdörtgenin sol sütununda bulunan 1 × 1 desen olarak tanımlanır . İkinci satır , başlangıç ​​karakterini de içeren eşleşme sayısını sayar ve bunu yazdırır.AAS

İşte kodun bir dökümü:

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.

Fikir, \ {,-4}soldaki parçanın Mario'nun yukarı atladığı \ /*boşlukla ve sağdaki parçanın daha sonra düştüğü boşlukla eşleşmesidir. Bir maçın Aüstüne çıkmasını istiyoruz (hedefe ulaşmak istediğimiz için) a =. Her iki sütunun altındaki dikey yığınlar, sütunların aynı yüksekliğe sahip olmasını garanti eder, böylece bunları birleştirebiliriz (ortadaki tek boşluk budur). Yukarıda adı geçen dikdörtgenlere bölünen ve *s ile değiştirilen boşluklarla örnek bir sıçramanın ASCII sanat diyagramı :

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

İkinci satırda, seçenek nilk eşleşmeyi bulmak yerine tüm eşleşmelerin sayılmasını tetikler. Genel çözümde, boşluklar özel girdi dışı karakterler de olabilir ve seçenek girdinin girdi dışı karakterler bile doldurulmasına neden olur.

Umarım tüm bunlar mantıklıdır!