Finde den richtigen Weg

13

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 , gewinnt die kürzeste Antwort.

TuxCrafting
quelle
Wird es jemals zwei Wege geben, die auf dasselbe Ereignis zurückzuführen sind /oder \?
Martin Ender
@ MartinEnder Ja
TuxCrafting
Oh, es ist im letzten Testfall. Könnte es wert sein, ausdrücklich erwähnt zu werden.
Martin Ender
Wird das :immer von links erreicht werden oder könnte es auch von oben oder unten erreicht werden? Mit anderen Worten, könnte es andere Zeichen als #oder :in der letzten Spalte geben?
Martin Ender
1
SILOS antworte bitte?
Rohan Jhunjhunwala

Antworten:

14

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.
)
Martin Ender
quelle
9
+1 für glücklichen Code:)
betseg
6

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.

Loovjo
quelle
2

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

Arnauld
quelle
1

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
  }
}
Jordan
quelle
0

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

Riley
quelle