Étant donné une liste de chemins, sortez le chemin correct.

Exemple de chemin:

    /\
----+/
    |

• -et |sont des chemins horizontaux et verticaux.
• /et \sont des virages à 90 °.
• +est traité comme un -ou |selon la direction actuelle.

Les chemins peuvent aller dans n'importe quelle direction et un personnage peut être utilisé dans plusieurs chemins.

L'entrée sera comme ceci:

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

• A, B, CEt Dsont le chemin commence
• # est un mur (le chemin est mauvais)
• : est la fin (le chemin est correct)

Voici donc la sortie B.

Vous pouvez supposer:

• :et #sera toujours atteint par la gauche.
• Le caractère à droite du début d'un chemin sera toujours -.
• Les chemins seront toujours bien formés.
• #et :sera toujours dans la même colonne.
• Il n'y aura toujours qu'un :et 4 chemins.

Cas de test

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

Puisqu'il s'agit de code-golf , la réponse la plus courte gagne.

Caleçon , 47 octets

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

Testez-le ici.

Ouais pour les fonctionnalités non documentées ...

Explication

Slip est essentiellement une syntaxe regex bidimensionnelle et par défaut, les programmes Slip impriment le sous-ensemble de l'entrée qu'ils correspondent. Dans ce cas, je fais simplement correspondre un chemin valide. Pour empêcher l'impression de tout le chemin, j'utilise le documentaire(?,...) groupes qui indiquent simplement que les caractères correspondants à l'intérieur doivent être omis de la sortie.

En ce qui concerne l'expression régulière, malheureusement, il y a une certaine duplication car \et /doivent être traités différemment selon que nous nous déplaçons horizontalement ou verticalement. Du côté positif, puisque nous savons que le chemin commence et se termine horizontalement, nous savons qu'il y a un nombre pair de \ou /dans chaque chemin, de sorte que nous pouvons faire correspondre deux d'entre eux à la fois.

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

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

La première indentation n'est qu'un espace, dans la boucle while c'est un onglet.

Javascript (ES6), 117 104 bytes

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

Cas de test:

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

Rubis, 140 octets

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

Essayez-le sur repl.it: https://repl.it/CyJv

Non golfé

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

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

Non golfé:

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

Ceci est mon premier golf Perl, donc les suggestions sont les bienvenues :)