Kocham> <>,> <> to życie! Języki 2D są niesamowite! W tym wyzwaniu będziesz musiał powiedzieć, czy „podejrzana” droga ma koniec, podczas gry w golfa.

Definicja

Rybia droga zbudowana jest z płytek, w tym następujących:

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

Każda inna postać (z wyjątkiem -|+) może być uważana za rozrywkę, na przykład niektóre kwiaty (lub głowy ryb) na granicy drogi.

Droga zawsze zaczyna się w lewym górnym rogu prostokątnej siatki oddzielonej -|+symbolami. Droga kończy się, jeśli podążając nią, znajdziesz się na granicy, w przeciwnym razie utkniesz w nieskończonej ścieżce.

Znalezienie drogi na drodze odbywa się zgodnie z instrukcjami podanymi przez v>^<i lusterka. Lustro odbije się o 90 ° w zależności od tego, skąd pochodzisz. Oto jak to działa (używając v>^<do pokazania wskazówek):

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

Droga może wyglądać tak, jeśli kończy się:

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

Nieskończona pętla:

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

Specyfika

Droga niekoniecznie składa się tylko z instrukcji. Do uzupełnienia można użyć spacji lub liter. Oznacza to, że musisz kontynuować ruch w tym samym kierunku, chyba że przejdziesz przez postać <v^>-|.

Zawsze będzie jeden v>^<w lewym górnym rogu, <lub ^sugeruje, że ta droga się kończy.

Możesz przesłać funkcję przyjmującą ciąg jako parametr lub samodzielny program, używając STDIN / cokolwiek, co jest najbliższą alternatywą w twoim języku.

Twoje zgłoszenie musi zostać zwrócone lub wydrukowane na wartościach true / falsy STDOUT po zakończeniu. Prawdziwe wartości oznaczają, że droga ma koniec, podczas gdy fałsz oznacza, że ​​jest to nieskończona pętla.

Przypadki testowe

+--------------------+
|>\/  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

Standardowe luki są zabronione (jak zawsze).

Zwycięzcą zostanie ten z najkrótszym kodem w bajtach. (byłoby wspaniale zobaczyć odpowiedź> <> :))

JavaScript, ES6, 177 161 145 bajtów

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)

Cykl możemy wykryć, przemierzając ścieżkę i wykrywając powtórzenie krotki

• Lokalizacja
• nadchodzi z kierunku

Oznacza to, że jeśli wchodzimy po raz drugi (x,y)z jakiegoś kierunku D, wiemy, że ten cykl będzie się powtarzał na zawsze. Dlatego kod śledzi wszystkie odwiedzone lokalizacje i z jakiego kierunku, i sprawdza ten zapis przy każdej wizycie w nowym miejscu.

Kierunki w górę, w dół, w lewo iw prawo są przypisane numery 1, 2, 3, i 4. Kod uwzględnia bieżący symbol odwiedzany ( s[i+L]) i zmienia aktualny kierunek ( D), a następnie nowy kierunek służy do rekurencyjnego wywoływania funkcji i oceny następnej spacji. 5jako kierunek wskazuje ścianę i truezakończenie programu.

Oto wyjaśnienie kodu mniej golfowego:

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)

Łańcuch szablonu `431255${5-D+'X3412'[D]}`ma zagnieżdżone wyrażenie, które obsługuje kopie lustrzane: ponieważ kierunki są liczbami, mogą być również używane jako indeksy. Wyrażenie 'X3412'[D]zwraca ósmy znak w ciągu możliwego kierunku, a zatem odpowiada \ósmemu znakowi w ciągu symboli '><^v-|/\\'). Wyrażenie mówi:

• Jeśli bieżącym kierunkiem Djest 1(w górę), nowy kierunek po uderzeniu w \lustro będzie 3(w lewo)
• Jeśli bieżącym kierunkiem Djest 2(w dół), nowy kierunek po uderzeniu w \lustro będzie 4(w prawo)
• itp.

Drugie lustro /użyłoby tego wyrażenia 'X4321'[D], ale ponieważ jest to po prostu uporządkowane odliczanie 4, możemy wyrazić je prościej jako 5-D.

Niezgodna> <> odpowiedź

Chciałeś> <>, dam ci> <>!

Uważam, że jedynym rozsądnym sposobem na zrobienie tego w> <> jest skopiowanie danych wejściowych w przestrzeni kodowej i umożliwienie tłumaczowi samodzielnego podjęcia decyzji, czy dane wejściowe gdzieś prowadzą. Ponieważ> <> nie implementuje już wątkowania, pozostaje nam duży problem: jeśli wejście ma pętlę, utkniemy w niej.

Biorąc pod uwagę te względy, postanowiłem uczynić rozwiązanie kompatybilne z >> internetowym tłumaczem, aby można było stwierdzić, czy tłumacz utknął na wejściu, czy po prostu starał się zrobić wszystko. Musiałem także dodać końcowe wiersze do kodu, aby interpreter online wyświetlał dodany kod i nie zawieszał się przy próbie zapisu do niego.

Aha, a ponieważ do tej pory jestem wyraźnie zdyskwalifikowany, nie zawracałem sobie głowy graniem w kod.

Bez zbędnych ceregieli kod w pełnej krasie:

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

Aby go użyć, skopiuj go do interpretera internetowego, dodaj wystarczającą liczbę końcowych linii do obsługi danych wejściowych, prześlij kod, podaj go jako ;oddzielne linie i ciesz się jazdą.

Kilka testów:

Z

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

Ostateczna przestrzeń kodowa:

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     .
. /\/         ^<     .
 ....................

Wyprowadza „prawda” i zatrzymuje się.

Z

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

Ostateczna przestrzeń kodowa:

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

Pętle na zawsze.