Geben Sie bei einer Liste von Pfaden den richtigen Pfad aus.

Beispiel für einen Pfad:

    /\
----+/
    |

• -und |sind horizontale und vertikale Pfade.
• /und \sind um 90 ° gedreht.
• +wird als -oder als |abhängig von der aktuellen Richtung behandelt.

Pfade können in jede Richtung verlaufen und ein Zeichen kann in mehreren Pfaden verwendet werden.

Die Eingabe wird folgendermaßen aussehen:

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

• A, B , CUnd Dsind Pfad beginnt
• # ist eine Mauer (der Weg ist schlecht)
• : ist das Ende (der Weg ist korrekt)

Also hier wird die Ausgabe sein B .

Sie können annehmen:

• : und # wird immer von links erreicht.
• Das Zeichen rechts vom Anfang eines Pfades ist immer - .
• Pfade werden immer gut geformt sein.
• # und : wird immer in der gleichen Spalte sein.
• Es wird immer nur einen :und vier Pfade geben.

Testfälle

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

Da dies Codegolf ist , gewinnt die kürzeste Antwort.

Beleg , 47 Bytes

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

Teste es hier.

Yay für undokumentierte Funktionen ...

Erläuterung

Slip ist im Grunde eine zweidimensionale Regex-Syntax. Standardmäßig geben Slip-Programme die Teilmenge der Eingabe aus, mit der sie übereinstimmen. In diesem Fall stimme ich einfach mit einem gültigen Pfad überein. Um zu verhindern, dass der gesamte Pfad gedruckt wird, verwende ich den undokumentierten Pfad(?,...) Gruppen, die lediglich angeben, dass die darin enthaltenen Zeichen in der Ausgabe weggelassen werden sollen.

Wie für die regex, leider gibt es einige Überschneidungen , da \und /müssen unterschiedlich behandelt werden , je nachdem , ob wir horizontal oder vertikal zu bewegen. Positiv ist, dass wir wissen, dass der Pfad horizontal beginnt und endet, und dass in jedem Pfad eine gerade Anzahl \oder eine gerade Anzahl vorhanden ist /, sodass wir zwei von ihnen gleichzeitig zuordnen können.

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

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

Der erste Einzug ist nur ein Leerzeichen, in der while-Schleife ein Tabulator.

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

Testfälle:

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 Bytes

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

Versuchen Sie es auf repl.it: 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 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;}}}}

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

Dies ist mein erster Perl-Golf, daher sind Vorschläge willkommen :)