Я люблю> <>,> <> это жизнь! 2D-языки потрясающие! В этом соревновании вы должны будете сказать, есть ли у "рыбной" дороги конец во время игры в гольф.

Определение

Рыбная дорога построена из плиток, в том числе следующих:

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

Любой другой персонаж (кроме -|+ ) может рассматриваться как отвлечение внимания, как некоторые цветы (или рыбьи головы) на границе дороги.

Дорога всегда начинается в верхнем левом углу прямоугольной сетки, ограниченной -|+ символами. Дорога имеет конец, если, следуя по ней, вы окажетесь на границе, иначе вы окажетесь в ловушке бесконечного пути.

Найти дорогу на дороге можно, следуя указаниям v>^<и зеркалам. Зеркало отразится на 90 ° в зависимости от того, откуда вы пришли. Вот как это работает (используя, v>^<чтобы показать направления):

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

Дорога может выглядеть так, если она заканчивается:

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

Бесконечный цикл:

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

конкретика

Дорога не обязательно состоит только из инструкций. Пробелы или буквы могут быть использованы для его завершения. Это означает, что вы должны продолжать двигаться в том же направлении, кроме случаев, когда вы пересекаете персонажа <v^>-|.

Всегда будет один из них v>^<в верхнем левом углу, <или ^подразумевает, что эта дорога заканчивается.

Вы можете отправить функцию, принимающую строку в качестве параметра, или отдельную программу, использующую STDIN / любой другой вариант на вашем языке.

Ваша заявка должна вернуться или напечатать на истинных / ложных значениях STDOUT, когда это будет сделано. Истинные значения означают, что дорога имеет конец, в то время как ложность означает, что это бесконечный цикл.

Контрольные примеры

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

Стандартные лазейки запрещены (как всегда).

Победителем станет тот, у кого самый короткий код в байтах. (было бы удивительно видеть ответ> <> :))

JavaScript, ES6, 177 161 145 байт

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)

Мы можем обнаружить цикл, пройдя путь и обнаружив повторение кортежа

• место расположения
• исходящий из направления

То есть, если мы входим в какую-то позицию (x,y)с какого-то направленияD во второй раз, мы знаем, что этот цикл будет повторяться вечно. Поэтому код отслеживает все посещенные местоположения и в каком направлении и проверяет эту запись каждый раз, когда посещается новое пространство.

Направления вверх, вниз, влево и вправо присваиваются номера 1, 2, 3и 4. Код учитывает текущий символ, который был посещен ( s[i+L]), и изменяет текущее направление ( D), затем новое направление используется для рекурсивного вызова функции и оценки следующего пробела. 5как направление указывает на стену, так и на trueзавершение программы.

Вот объяснение менее гольф-кода:

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)

Строка шаблона `431255${5-D+'X3412'[D]}`имеет вложенное выражение, которое обрабатывает зеркала: поскольку направления являются числами, их также можно использовать в качестве индексов. Выражение 'X3412'[D]оценивается до 8-го символа в строке возможного направления и, соответственно \, соответствует 8-му символу в строке символа '><^v-|/\\'). Выражение говорит:

• Если направление тока Dявляется 1(вверх), то новое направление на удар \зеркала будет 3(слева)
• Если направление тока Dявляется 2(вниз), то новым направлением на удар \зеркала будет 4(справа)
• и т.п.

Другое зеркало /будет использовать выражение 'X4321'[D], но поскольку это просто упорядоченный обратный отсчет 4, мы можем выразить его более просто как 5-D.

Несоответствующий> <> ответ

Вы хотели> <>, я даю вам> <>!

Я считаю, что единственный разумный способ сделать это в> <> - это скопировать ввод в кодовом пространстве и позволить интерпретатору самостоятельно решить, ведет ли ввод куда-либо. Поскольку> <> больше не реализует многопоточность, это ставит нас перед большой проблемой: если на входе есть цикл, мы застрянем в нем.

Эти соображения были приняты во внимание, и я решил сделать решение совместимым с > <> онлайн-переводчиком, чтобы можно было утверждать, что интерпретатор застрял во входных данных или просто сделал целую вечность, чтобы сделать все. Мне также пришлось добавить последние строки в код, чтобы онлайн-интерпретатор отображал добавленный код и не вылетал при попытке записи в него.

Да, и поскольку я уже явно дисквалифицирован, я не стал играть в гольф.

Без лишних слов, код во всей красе:

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

Чтобы использовать его, скопируйте его в онлайн-интерпретатор, добавьте достаточное количество конечных строк для обработки вашего ввода, отправьте код, введите его в виде ;разделенных строк и наслаждайтесь поездкой.

Несколько тестов:

С

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

Окончательное кодовое пространство:

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

Выводит «истина» и останавливается.

С

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

Окончательное кодовое пространство:

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

Петли навсегда.