Eu amo> <>,> <> é a vida! Os idiomas 2D são incríveis! Neste desafio, você terá que dizer se uma estrada "duvidosa" termina, enquanto pratica golfe.

Definição

Uma estrada de peixe é construída com azulejos, incluindo os seguintes:

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

Qualquer outro personagem (exceto -|+) pode ser considerado uma distração, como algumas flores (ou cabeças de peixe) na beira da estrada.

Uma estrada sempre começa no canto superior esquerdo de uma grade retangular, delimitada por -|+símbolos. A estrada tem um fim se, seguindo-a, você acaba em uma borda; caso contrário, você fica preso em um caminho infinito.

Para encontrar o caminho na estrada, siga as instruções dadas por v>^<e espelhos. Um espelho refletirá 90 °, dependendo de onde você veio. Veja como funciona (usando v>^<para mostrar instruções):

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

Uma estrada pode ficar assim se terminar:

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

Um loop infinito:

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

Específicos

Uma estrada não consiste necessariamente apenas em instruções. Espaços ou letras podem ser usados ​​para completá-lo. Isso significa que você deve continuar se movendo na mesma direção, exceto se você cruzar um personagem <v^>-|.

Sempre haverá um v>^<no canto superior esquerdo <ou ^implica que esta estrada termina.

Você pode enviar uma função usando uma string como parâmetro ou um programa independente usando STDIN / qualquer que seja a alternativa mais próxima no seu idioma.

Sua submissão deve retornar ou imprimir valores STDUT verdade / falsidade quando terminar. Valores reais que significam que a estrada tem um fim, enquanto falsidade significa que é um loop infinito.

Casos de teste

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

As brechas padrão são proibidas (como sempre).

O vencedor será aquele com o menor código em bytes. (seria incrível ver uma resposta> <> :))

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)

Podemos detectar um ciclo percorrendo o caminho e detectando uma repetição da tupla

• localização
• direção proveniente

Ou seja, se estamos entrando em alguma posição (x,y)vinda de alguma direção Dpela segunda vez, sabemos que esse ciclo se repetirá para sempre. Portanto, o código controla todos os locais visitados e de que direção e verifica esse registro sempre que um novo espaço é visitado.

As direções para cima, baixo, esquerda e direita são atribuídos os números 1, 2, 3, e 4. O código considera o símbolo atual sendo visitado ( s[i+L]) e altera a direção atual ( D); a nova direção é usada para chamar recursivamente a função e avaliar o próximo espaço. 5como uma direção indica uma parede e um truetérmino do programa.

Aqui está uma explicação do código com menos golfe:

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 sequência do modelo `431255${5-D+'X3412'[D]}`possui uma expressão aninhada que lida com os espelhos: como as direções são números, elas também podem ser usadas como índices. A expressão é 'X3412'[D]avaliada para o 8º caractere na sequência de direção possível e, portanto, corresponde ao \8º caractere na sequência de símbolos '><^v-|/\\'). A expressão diz:

• Se a direção atual Destiver 1(para cima), a nova direção ao bater no \espelho será 3(à esquerda)
• Se a direção atual Dfor 2(para baixo), a nova direção ao bater no \espelho será 4(à direita)
• etc.

O outro espelho /usaria a expressão 'X4321'[D], mas como isso é simplesmente uma contagem regressiva ordenada 4, podemos expressá-la mais simplesmente como 5-D.

Não conformidade> <> resposta

Você queria> <>, eu te dou> <>!

Acredito que a única maneira sensata de fazer isso em> <> é copiando a entrada no espaço de código e deixando o intérprete decidir por si mesmo se a entrada leva a algum lugar. Como> <> não implementa mais a segmentação, isso nos deixa com um grande problema: se a entrada tiver um loop, ficaremos presos a ele.

Como essas considerações foram levadas em consideração, decidi tornar uma solução compatível com o intérprete on-line, para que fosse possível afirmar se o intérprete está preso na entrada ou apenas com idades para fazer tudo. Eu também tive que adicionar linhas finais ao código para que o intérprete online mostre o código adicionado e não falhe ao tentar gravá-lo.

Ah, e como estou claramente desqualificado até agora, não me preocupei em jogar o código no golfe.

Sem mais delongas, o código em toda a sua glória:

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

Para usá-lo, copie-o no intérprete on-line, adicione linhas finais suficientes para manipular sua entrada, envie o código, insira-a como ;linhas separadas e aproveite o passeio.

Alguns testes:

Com

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

Espaço de código final:

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

Emite "true" e para.

Com

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

Espaço de código final:

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

Loops para sempre.