Adoro> <>,> <> è vita! Le lingue 2D sono incredibili! In questa sfida, dovrai dire se una strada "sospesa" ha fine, mentre giochi a golf.

Definizione

Una strada sospesa è costruita con piastrelle, comprese le seguenti:

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

Qualsiasi altro personaggio (eccetto -|+) può essere considerato una distrazione, come alcuni fiori (o teste di pesce) sul bordo della strada.

Una strada inizia sempre nell'angolo in alto a sinistra di una griglia rettangolare, delimitata da -|+simboli. La strada finisce se, seguendola, finisci su un confine, altrimenti rimarrai intrappolato in un percorso infinito.

Trovare la strada sulla strada si ottiene seguendo le indicazioni fornite da v>^<e gli specchi. Uno specchio rifletterà di 90 ° a seconda di dove vieni. Ecco come funziona (usando v>^<per mostrare le indicazioni):

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

Una strada potrebbe apparire così se finisce:

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

Un ciclo infinito:

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

specifiche

Una strada non consiste necessariamente solo di istruzioni. Spazi o lettere possono essere usati per completarlo. Questo significa che devi continuare a muoverti nella stessa direzione tranne se attraversi un personaggio <v^>-|.

Ce ne sarà sempre uno v>^<nell'angolo in alto a sinistra, <o ^implica che questa strada termina.

Puoi inviare una funzione prendendo una stringa come parametro o un programma autonomo usando STDIN / qualunque sia l'alternativa più vicina nella tua lingua.

L'invio deve essere restituito o stampato sui valori di verità / falsità di STDOUT al termine. Valori veritieri significano che la strada ha una fine, mentre falsi significa che è un ciclo infinito.

Casi test

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

Le scappatoie standard sono vietate (come sempre).

Il vincitore sarà quello con il codice più breve in byte. (sarebbe fantastico vedere una> <> risposta :))

JavaScript, ES6, 177 161 145 byte

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)

Siamo in grado di rilevare un ciclo attraversando il percorso e rilevando una ripetizione della tupla

• Posizione
• proveniente dalla direzione

Cioè, se stiamo entrando in una posizione (x,y)proveniente da una direzione Dper la seconda volta, sappiamo che questo ciclo si ripeterà per sempre. Pertanto, il codice tiene traccia di tutte le posizioni visitate e da quale direzione e verifica il record ogni volta che viene visitato un nuovo spazio.

Le direzioni su, giù, sinistra, destra e vengono assegnati i numeri 1, 2, 3, e 4. Il codice considera il simbolo corrente visitato ( s[i+L]) e cambia la direzione corrente ( D), quindi la nuova direzione viene utilizzata per chiamare ricorsivamente la funzione e valutare lo spazio successivo. 5come una direzione indica un muro e una truefine del programma.

Ecco una spiegazione del codice meno golfato:

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)

La stringa del modello `431255${5-D+'X3412'[D]}`ha un'espressione nidificata che gestisce i mirror: poiché le direzioni sono numeri, possono anche essere utilizzate come indici. L'espressione 'X3412'[D]restituisce l'ottavo carattere nella stringa della possibile direzione e quindi corrisponde \all'ottavo carattere nella stringa del simbolo '><^v-|/\\'). L'espressione dice:

• Se la direzione corrente Dè 1(su), allora la nuova direzione sul colpire uno \specchio sarà 3(a sinistra)
• Se la direzione corrente Dè 2(verso il basso), la nuova direzione sul colpire uno \specchio sarà 4(a destra)
• eccetera.

L'altro mirror /userebbe l'espressione 'X4321'[D], ma dal momento che è semplicemente un conto alla rovescia ordinato 4, possiamo esprimerlo più semplicemente come 5-D.

Risposta non conforme> <>

Volevi> <>, ti do> <>!

Credo che l'unico modo sano per farlo in> <> sia copiando l'input nello spazio dei codici e lasciando che l'interprete decida da solo se l'input conduce da qualche parte. Poiché> <> non implementa più il threading, questo ci lascia con un grosso problema: se l'input ha un loop, ci bloccheremo.

Tenendo conto di queste considerazioni, ho deciso di rendere compatibile una soluzione con l' interprete online> <> in modo che fosse possibile affermare se l'interprete è bloccato nell'input o impiega solo secoli per fare tutto. Ho anche dovuto aggiungere righe finali al codice in modo che l'interprete online mostri il codice aggiunto e non si blocchi durante il tentativo di scriverlo.

Oh, e dato che ormai sono chiaramente squalificato, non mi sono preoccupato di giocare a golf con il codice.

Senza ulteriori indugi, il codice in tutto il suo splendore:

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

Per usarlo, copiarlo nell'interprete online, aggiungere abbastanza righe finali per gestire il tuo input, inviare il codice, dargli l'input come ;linee separate e goderti il ​​viaggio.

Alcuni test:

Con

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

Spazio dei codici finale:

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

Emette "vero" e si arresta.

Con

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

Spazio dei codici finale:

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

Cicli per sempre.