Bir yol listesi verildiğinde, doğru yolu girin.

Yol örneği:

    /\
----+/
    |

• -ve |yatay ve dikey yollardır.
• /ve \90 ° dönüşler.
• +akım yönüne bağlı olarak a -veya a |olarak muamele edilir .

Yollar herhangi bir yöne gidebilir ve bir karakter birden çok yolda kullanılabilir.

Girdi şu şekilde olacaktır:

       /--\
A------+--+--#
B------/  \--:
C------------#
D------------#

• A, B, CVe Dyol başlar vardır
• # bir duvar (yol kötü)
• : sonu (yol doğru)

Yani burada çıktı olacak B.

Varsayabilirsiniz:

• :ve #her zaman soldan ulaşılacak.
• Bir yolun başlangıcının sağındaki karakter her zaman olacaktır -.
• Yollar her zaman iyi şekillendirilecektir.
• #ve :her zaman aynı sütunda olur.
• Her zaman sadece bir :ve 4 yol olacaktır.

Test senaryoları

A------#
B------#
C------#
D------:
=>
D

A-\ /---:
B-+-/ /-#
C-+---+-#
D-+---/
  \-----#
=>
B

  /-\
A-+\\---#
B-/\-\/-#
C----++-#
D----+/
     \--:
=>
A

A-\
B-+\
C-++\/----#
D-+++//---:
  \++-//--#
   \+--//-#
    \---/
=>
A

  /-\
A-+-/-\
B-+-+-\--#
C-+-/ |/-#
D-\---++-#
  \---+/
      \--:
=>
B

Bu kod golf olduğundan , en kısa cevap kazanır.

Kayma , 47 bayt

`a(?,[`-+]*((`/<|`\>)[`|+]*(`/>|`\<)[`-+]*)*`:)

Burada test edin.

Belgelenmemiş özellikler için Yay ...

açıklama

Slip temel olarak iki boyutlu normal ifade sözdizimidir ve varsayılan olarak Slip programları eşleşen girdilerin alt kümesini yazdırır. Bu durumda sadece geçerli bir yolla eşleşiyorum. Tüm yolun yazdırılmasını önlemek için, (?,...)içinde eşleşen karakterlerin çıktıdan çıkarılması gerektiğini belirten belgelenmemiş grupları kullanıyorum.

Çünkü regex gelince, maalesef, bazı çoğaltma var \ve /ihtiyaç biz yatay veya dikey hareket olmanıza bağlı olarak farklı tedavi edilmesi. Artı tarafta, yolun yatay olarak başladığını ve bittiğini bildiğimiz için , her seferinde iki tanesiyle eşleşebilmemiz için eşit sayıda \veya /her yolda olduğunu biliyoruz.

`a             # Match a letter.
(?,            # Match but don't include in output...
  [`-+]*       #   Match a horizontal piece of path, consisting of - or +.
  (            #   Match 0 or more vertical segments...
    (`/<|`\>)  #     Match a / and turn left, or a \ and turn right.
    [`|+]*     #     Match a vertical piece of path, consisting of | or +.
    (`/>|`\<)  #     Match a / and turn right, or a \ and turn left.
    [`-+]*     #     Match a horizontal piece of path, consisting of - or +.
  )*
  `:           #   Match a : to ensure that this is the correct path.
)

Python, 221 bayt

def P(s,c=""):
 l=s.split("\n")
 v=[0,-1]
 p=[(i,l[i].index(":"))for i in range(len(l))if":"in l[i]][0]
 while c in"-:|+/\\":
    p=map(sum,zip(p,v))
    c=l[p[0]][p[1]]
    v=v[::1-(c=="\\")*2]
    if"/"==c:v=[-v[1],-v[0]]
 return c

İlk girinti sadece bir boşluk, while döngüsünde ise bir sekmedir.

JavaScript (ES6), 117 104 bayt

p=>(r=d=>(c="\\/ABCD".indexOf(p[x+=[-1,-w,w,1][d]])+1)>2?p[x]:r(d^c))(0,w=p.indexOf`
`+1,x=p.indexOf`:`)

Test senaryoları:

let f =
p=>(r=d=>(c="\\/ABCD".indexOf(p[x+=[-1,-w,w,1][d]])+1)>2?p[x]:r(d^c))(0,w=p.indexOf`
`+1,x=p.indexOf`:`)

var p0 = 'A------#\nB------#\nC------#\nD------:',
    p1 = 'A-\\ /---:\nB-+-/ /-#\nC-+---+-#\nD-+---/  \n  \\-----#',
    p2 = '  /-\\    \nA-+\\\\---#\nB-/\\-\\/-#\nC----++-#\nD----+/  \n     \\--:',
    p3 = 'A-\\        \nB-+\\       \nC-++\\/----#\nD-+++//---:\n  \\++-//--#\n   \\+--//-#\n    \\---/  ',
    p4 = '  /-\\     \nA-+-/-\\   \nB-+-+-\\--#\nC-+-/ |/-#\nD-\\---++-#\n  \\---+/  \n      \\--:';

console.log(p0, '=>', f(p0));
console.log(p1, '=>', f(p1));
console.log(p2, '=>', f(p2));
console.log(p3, '=>', f(p3));
console.log(p4, '=>', f(p4));

Yakut, 140 bayt

->s{(?A..?D).find{|l,c|x=h=1
v=0
y=s[/.*#{l}/m].count$/
(v,h=c==?/?[-h,-v]:c==?\\?[h,v]:[v,h]
y+=v
x+=h)until(c=s.lines[y][x])=~/(:)|#/
$1}}

Repl.it'te deneyin: https://repl.it/CyJv

Ungolfed

->s{
  (?A..?D).find {|l,c|
    x = h = 1
    v = 0
    y = s[/.*#{l}/m].count $/

    ( v, h = c == ?/ ? [-h,-v] : c == ?\\ ? [h,v] : [v,h]
      y += v
      x += h
    ) until (c = s.lines[y][x]) =~ /(:)|#/

    $1
  }
}

Perl 211 Bayt

sub f{for($s=-1;++$s<~~@_;){if($_[$s][0]ne' '){$r=$s;$c=$m=0;$n=1;while($_[$r][$c]ne'#'){if($_[$r][$c]eq':'){return$_[$s][0];}($m,$n)=$_[$r][$c]eq'/'?(-$n,-$m):$_[$r][$c]eq'\\'?($n,$m):($m,$n);$r+=$m;$c+=$n;}}}}

Ungolfed:

sub q{
    for($start = -1; ++$start <~~@_;) {
        if($_[$start][0] ne ' ') {
            $row = $start;
            $col = $rowMove = 0;
            $colMove = 1;
            while($_[$row][$col] ne '#') {
                if($_[$row][$col] eq ':') {
                    return $_[$start][0];
                }
                ($rowMove, $colMove) =  $_[$row][$col] eq '/' ? (-$colMove,-$rowMove) : 
                                        $_[$row][$col] eq '\\' ? ($colMove,$rowMove) : 
                                        ($rowMove, $colMove);
                $row += $rowMove;
                $col += $colMove;
            }
        }
    }
}

Bu benim ilk Perl golf, bu yüzden önerilerinizi bekliyoruz :)