Diberikan daftar jalur, output jalur yang benar.

Contoh jalur:

    /\
----+/
    |

• -dan |jalur horizontal dan vertikal.
• /dan \berbelok 90 °.
• +diperlakukan sebagai a -atau |tergantung dari arah saat ini.

Path dapat menuju ke arah mana pun dan sebuah karakter dapat digunakan di banyak path.

Masukan akan seperti ini:

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

• A, B, CDan Dadalah jalan mulai
• # adalah tembok (jalannya buruk)
• : adalah akhirnya (jalannya benar)

Jadi di sini hasilnya akan B.

Anda dapat mengasumsikan:

• :dan #akan selalu dijangkau dari kiri.
• Karakter di sebelah kanan awal jalan akan selalu -.
• Jalan akan selalu terbentuk dengan baik.
• #dan :akan selalu berada di kolom yang sama.
• Akan selalu ada hanya satu :dan 4 jalur.

Uji kasus

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

Karena ini adalah kode-golf , jawaban terpendek menang.

Menyelinap , 47 byte

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

Uji di sini.

Yay untuk fitur tidak berdokumen ...

Penjelasan

Slip pada dasarnya adalah sintaks regex dua dimensi dan secara default program Slip mencetak subset dari input yang mereka cocokkan. Dalam hal ini saya hanya mencocokkan jalur yang valid. Untuk mencegah pencetakan seluruh jalur, saya menggunakan yang tidak berdokumen(?,...) grup yang hanya menunjukkan bahwa karakter yang cocok di dalamnya harus dihilangkan dari output.

Adapun regex, sayangnya, ada beberapa duplikasi karena \dan /perlu diperlakukan berbeda tergantung pada apakah kita bergerak secara horizontal atau vertikal. Di sisi positifnya, karena kita tahu bahwa jalan dimulai dan berakhir secara horizontal, kita tahu bahwa ada bilangan genap \atau /di setiap jalur, sehingga kita bisa mencocokkan keduanya di satu waktu.

`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 byte

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

Indentasi pertama hanya satu ruang, di loop sementara itu adalah tab.

Javascript (ES6), 117 104 byte

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

Kasus uji:

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

Ruby, 140 byte

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

Cobalah di repl.it: https://repl.it/CyJv

Tidak disatukan

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

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

Tidak Disatukan:

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

Ini adalah golf Perl pertama saya, jadi saran dipersilahkan :)