Ich liebe> <>,> <> ist das Leben! 2D-Sprachen sind unglaublich! In dieser Herausforderung müssen Sie sagen, ob eine "fischreiche" Straße ein Ende hat, während Sie Code-Golf spielen.

Definition

Eine fischreiche Straße besteht aus Kacheln, darunter die folgenden:

v (go down)
> (go right)
^ (go up)
< (go left)
/ (mirror)
\ (mirror)

Jedes andere Zeichen (außer -|+) kann als Ablenkung angesehen werden, z. B. einige Blumen (oder Fischköpfe) am Straßenrand.

Eine Straße beginnt immer in der oberen linken Ecke eines rechteckigen Rasters, das durch -|+Symbole begrenzt ist. Die Straße hat ein Ende, wenn Sie ihr folgen und an eine Grenze stoßen, sonst sind Sie auf einem unendlichen Pfad gefangen.

Um sich auf der Straße zurechtzufinden, müssen Sie den Anweisungen von v>^<und den Spiegeln folgen . Ein Spiegel wird um 90 ° reflektiert, je nachdem, woher Sie kommen. So funktioniert es ( v>^<um eine Wegbeschreibung anzuzeigen):

 ^    ^
>/<  >\<
 v    v
</>  <\>
 ^    ^

Eine Straße könnte so aussehen, wenn sie endet:

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/         ^<     |
+--------------------+

Eine Endlosschleife:

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+

Besonderheiten

Eine Straße besteht nicht unbedingt nur aus Anweisungen. Leerzeichen oder Buchstaben können verwendet werden, um es zu vervollständigen. Dies bedeutet, dass Sie sich in die gleiche Richtung bewegen müssen, es sei denn, Sie kreuzen einen Buchstaben in<v^>-| .

Es wird immer eine v>^<in der oberen linken Ecke sein <oder ^impliziert, dass diese Straße endet.

Sie können eine Funktion einreichen, die einen String als Parameter verwendet, oder ein eigenständiges Programm mit STDIN / was auch immer die nächstliegende Alternative in Ihrer Sprache ist.

Ihre Einreichung muss zurückgegeben oder auf STDOUT Wahrheits- / Falschwerte gedruckt werden, wenn sie abgeschlossen ist. Wahrheitswerte bedeuten, dass die Straße ein Ende hat, während falsch bedeutet, dass sie eine Endlosschleife ist.

Testfälle

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/ ><>     ^<     |
+--------------------+
    True

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+
    False

+--+
|<v|
|^<|
+--+
    True

+--+
|>v|
|^<|
+--+
    False

+----------+
|v Hello \ |
|\\/\/   / |
| \/\\   \ |
|/  // >\  |
|  ^/\>\\/ |
|\  /\/\/  |
+----------+
    False

+-----+
|>\/\\|
|//\\/|
|\/\\\|
|//\//|
|\/\/ |
+-----+
    True

2 test cases added as suggested by @MartinBüttner
+----+
|v   |
|\\  |
|//\ |
|\\v |
| \/ |
+----+
    False

+----+
|v   |
|\\  |
|//\ |
|\\^ |
| \/ |
+----+
    False

Test case inspired by @ETHproductions
+-------------------------+
|><>                      |
|something smells fishy...|
+-------------------------+
    False

Standard-Schlupflöcher sind (wie immer) verboten.

Der Gewinner ist derjenige mit dem kürzesten Code in Bytes. (Es wäre erstaunlich, eine> <> Antwort zu sehen :))

JavaScript, ES6, 177 161 145 Bytes

f=(s,i=1,M=[],D)=>D==5||!~M[O="indexOf"](D+i)&&f(s,i-[M.push(D+i),L=s[O]('|'),-L,1,-1][D=`431255${5-D+'X3412'[D]}`['><^v-|/\\'[O](s[i+L])]||D],M,D)

Wir können einen Zyklus erkennen, indem wir den Pfad durchlaufen und eine Wiederholung des Tupels erkennen

• Ort
• aus Richtung

Das heißt, wenn wir zum zweiten Mal eine Position (x,y)aus einer bestimmten Richtung einnehmen D, wissen wir, dass sich dieser Zyklus für immer wiederholen wird. Daher verfolgt der Code alle besuchten Orte und aus welcher Richtung und vergleicht sie bei jedem Besuch eines neuen Bereichs mit diesem Datensatz.

Die Richtungen nach oben, unten, links und rechts sind die Zahlen zugeordnet 1, 2, 3, und 4. Der Code berücksichtigt das aktuell besuchte Symbol ( s[i+L]) und ändert die aktuelle Richtung ( D). In der neuen Richtung wird die Funktion rekursiv aufgerufen und das nächste Leerzeichen ausgewertet. 5als Richtung bezeichnet eine Wand und atrue Beendigung des Programms.

Hier ist eine Erklärung für weniger Golf-Code:

f=
(s,     // input string
 i=1,   // current location as offset string index
 M=[],  // record of previously visited spaces
 D      // current direction
  )=>(
    L=s[O="indexOf"]('|'), // find arena width `L` by index of first `|`

    // if D is 5, return true, or...
    D==5 ||

    // if direction + position is not new, return false
    !~M[O](D+i) &&

    // otherwise, save this direction + position
    M.push(D+i) &&

    // recursively call `f` with new direction and position
    f(s,
      i-[,L,-L,1,-1][D=            // modify position based on active direction
        `431255${5-D+'X3412'[D]}`  // from these possible directions...
          [                        // chose the one at the index...
            '><^v-|/\\'[O](        // based on the index of the symbol 
                           s[i+L]  // of the current character
                                 )
          ]
        ||D     // or preserve old D if symbol is not directional
      ],
      M,D)

Die Vorlagenzeichenfolge `431255${5-D+'X3412'[D]}`hat einen verschachtelten Ausdruck, der die Spiegel behandelt: Da die Richtungen Zahlen sind, können sie auch als Indizes verwendet werden. Der Ausdruck 'X3412'[D]ergibt das achte Zeichen in der Zeichenfolge für die mögliche Richtung und entspricht somit \dem achten Zeichen in der Zeichenfolge '><^v-|/\\'. Der Ausdruck sagt,

• Wenn Stromrichtung Dist 1( nach oben), dann wird die neue Richtung einen beim Auftreffen auf \Spiegel wird 3( von links)
• Wenn Stromrichtung Dist 2(nach unten), dann wird die neue Richtung auf eine Kollision mit \Spiegel wird 4(rechts)
• etc.

Der andere Spiegel /würde den Ausdruck verwenden 'X4321'[D], aber da dies einfach ein geordneter Countdown von ist 4, können wir ihn einfacher als ausdrücken 5-D.

Nicht konforme> <> Antwort

Sie wollten> <>, ich gebe Ihnen> <>!

Ich glaube, der einzig vernünftige Weg, dies in> <> zu tun, besteht darin, die Eingabe in den Codespace zu kopieren und den Interpreter selbst entscheiden zu lassen, ob die Eingabe irgendwohin führt. Da> <> kein Threading mehr implementiert, haben wir ein großes Problem: Wenn die Eingabe eine Schleife hat, bleiben wir dran.

Unter Berücksichtigung dieser Überlegungen habe ich beschlossen, eine mit dem > <> Online-Interpreter kompatible Lösung zu entwickeln, damit festgestellt werden kann, ob der Interpreter in der Eingabe steckt oder nur einige Zeit benötigt, um alles zu tun. Ich musste dem Code auch nachgestellte Zeilen hinzufügen, damit der Online-Interpreter den hinzugefügten Code anzeigt und beim Schreiben nicht abstürzt.

Oh, und da ich inzwischen eindeutig disqualifiziert bin, habe ich mich nicht darum gekümmert, den Code zu spielen.

Ohne weiteres der Code in seiner ganzen Pracht:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
              ^

Um es zu verwenden, kopieren Sie es in den Online-Interpreter, fügen Sie genügend abschließende Zeilen hinzu, um Ihre Eingabe zu verarbeiten, senden Sie den Code, geben Sie die Eingabe als ;separate Zeilen ein und genießen Sie die Fahrt.

Ein paar Tests:

Mit

+--------------------+
|>\/  this way >\/>  | this one ends here
| v^            \/   |
| v^   ^.^           |
| \/\         >v     |
| /\/         ^<     |
+--------------------+` 

Endgültiger Codespace:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
            ^
 ....................
.>\/           >\/>  .                   
. v^            \/   .
. v^   ^ ^           .
. \/\         >v     .
. /\/         ^<     .
 ....................

Gibt "true" aus und stoppt.

Mit

+--------+
|>>\ This|
|\\   is |
|  \\ a  |
| \ /trap| 
+--------+

Endgültiger Codespace:

50i:0(?v   :"^"=?v:"v"=?v:">"=?v:"<"=?v:"/"=?v:"\"=?v:"|"=?v:"-"=?va=?v1+10.
>.!603f<         v"."~                                     <      <   >~1+010.
>.!01+1p}:$}:}v! <      <      <      <      <      <
  ;oooo"true" <<
            ^
 ........ 
.>>\     .
.\\      .
.  \\    .
. \ /    .
 ........

Schleifen für immer.