Đưa ra một danh sách các đường dẫn, xuất ra đường dẫn chính xác.

Ví dụ về đường dẫn:

    /\
----+/
    |

• -và |là các đường ngang và dọc.
• /và \được quay 90 °.
• +được coi là một -hoặc một |tùy thuộc vào hướng hiện tại.

Các đường dẫn có thể đi theo bất kỳ hướng nào và một ký tự có thể được sử dụng trong nhiều đường dẫn.

Đầu vào sẽ như thế này:

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

• A, B, CVà Dlà con đường bắt đầu
• # là một bức tường (đường dẫn là xấu)
• : là kết thúc (đường dẫn là chính xác)

Vì vậy, ở đây đầu ra sẽ được B.

Bạn có thể giả sử:

• :và #sẽ luôn luôn đạt được từ bên trái.
• Nhân vật ở bên phải của một con đường sẽ luôn luôn như vậy -.
• Con đường sẽ luôn được hình thành tốt.
• #và :sẽ luôn ở trong cùng một cột.
• Sẽ luôn chỉ có một :và 4 con đường.

Các trường hợp thử nghiệm

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

Vì đây là môn đánh gôn , câu trả lời ngắn nhất sẽ thắng.

Trượt , 47 byte

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

Kiểm tra nó ở đây.

Yay cho các tính năng không có giấy tờ ...

Giải trình

Trượt về cơ bản là một cú pháp regex hai chiều và theo mặc định, các chương trình Trượt in tập hợp con của đầu vào mà chúng khớp. Trong trường hợp này, tôi chỉ đơn giản là phù hợp với một đường dẫn hợp lệ. Để ngăn việc in toàn bộ đường dẫn, tôi sử dụng các (?,...)nhóm không có giấy tờ mà chỉ đơn giản chỉ ra rằng các ký tự khớp với bên trong nên được bỏ qua từ đầu ra.

Thật không may, đối với regex, thật không may, có một số trùng lặp vì \và /cần được xử lý khác nhau tùy thuộc vào việc chúng ta di chuyển theo chiều ngang hay chiều dọc. Về mặt tích cực, vì chúng ta biết rằng đường dẫn bắt đầu và kết thúc theo chiều ngang, chúng ta biết rằng có một số chẵn \hoặc /trong mỗi đường dẫn, do đó chúng ta có thể khớp hai trong số chúng cùng một lúc.

`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

Sự chú ý đầu tiên chỉ là một khoảng trắng, trong vòng lặp while là một 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`:`)

Các trường hợp thử nghiệm:

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

Hãy thử nó trên repl.it: https://repl.it/CyJv

Ung dung

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

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

Ung dung:

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

Đây là sân gôn Perl đầu tiên của tôi, vì vậy các đề xuất đều được chào đón :)