J'aime> <>,> <> c'est la vie! Les langages 2D sont incroyables! Dans ce défi, vous devrez dire si une route «louche» a une fin, tout en jouant au golf.

Définition

Une route de poisson est construite avec des tuiles, y compris les suivantes:

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

Tout autre personnage (sauf -|+) peut être considéré comme une distraction, comme certaines fleurs (ou têtes de poisson) au bord de la route.

Une route démarre toujours dans le coin supérieur gauche d'une grille rectangulaire, délimitée par des -|+symboles. La route a une fin si, en la suivant, vous vous retrouvez sur une frontière, sinon, vous serez pris au piège dans un chemin infini.

Trouver votre chemin sur la route est accompli en suivant les instructions données par v>^<et les miroirs. Un miroir réfléchira de 90 ° selon d'où vous venez. Voici comment cela fonctionne (en utilisant v>^<pour afficher les directions):

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

Une route pourrait ressembler à ceci si elle se termine:

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

Une boucle infinie:

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

Détails

Une route n'est pas nécessairement constituée uniquement d'instructions. Des espaces ou des lettres peuvent être utilisés pour le compléter. Cela signifie que vous devez continuer à vous déplacer dans la même direction, sauf si vous croisez un personnage <v^>-|.

Il y en aura toujours un v>^<dans le coin supérieur gauche, <ou ^implique que cette route se termine.

Vous pouvez soumettre une fonction prenant une chaîne comme paramètre, ou un programme autonome utilisant STDIN / quelle que soit l'alternative la plus proche dans votre langue.

Votre soumission doit retourner ou imprimer sur les valeurs STDOUT de vérité / fausse quand elle est terminée. Les valeurs véridiques signifient que la route a une fin, tandis que la fausseté signifie que c'est une boucle infinie.

Cas de 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

Les failles standard sont interdites (comme toujours).

Le gagnant sera celui avec le code le plus court en octets. (il serait étonnant de voir une réponse> <> :))

JavaScript, ES6, 177 161 145 octets

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)

On peut détecter un cycle en parcourant le chemin et en détectant une répétition du tuple

• emplacement
• venant de direction

Autrement dit, si nous entrons dans une position (x,y)venant d'une certaine directionD pour la deuxième fois, nous savons que ce cycle se répétera pour toujours. Par conséquent, le code conserve la trace de tous les emplacements visités et de quelle direction, et vérifie par rapport à cet enregistrement chaque fois qu'un nouvel espace est visité.

Les directions haut, bas, gauche et droite sont attribués les numéros 1, 2, 3et 4. Le code considère le symbole actuel visité ( s[i+L]) et change la direction actuelle ( D), puis la nouvelle direction est utilisée pour appeler récursivement la fonction et évaluer l'espace suivant. 5comme une direction indique un mur, et une truefin du programme.

Voici une explication du code moins golfé:

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 chaîne de modèle `431255${5-D+'X3412'[D]}`possède une expression imbriquée qui gère les miroirs: comme les directions sont des nombres, elles peuvent également être utilisées comme index. L'expression est 'X3412'[D]évaluée au 8ème caractère de la chaîne de direction possible et correspond donc au \8ème caractère de la chaîne de symboles '><^v-|/\\'). L'expression dit:

• Si la direction actuelle Dest 1(haut), alors la nouvelle direction en frappant un \miroir sera 3(gauche)
• Si la direction actuelle Dest 2(en bas), la nouvelle direction en frappant un \miroir sera 4(à droite)
• etc.

L'autre miroir /utiliserait l'expression 'X4321'[D], mais comme il s'agit simplement d'un décompte ordonné 4, nous pouvons l'exprimer plus simplement sous la forme 5-D.

Non conforme> <> réponse

Vous vouliez> <>, je vous donne> <>!

Je crois que la seule façon sensée de le faire dans> <> est de copier l'entrée dans l'espace de code et de laisser l'interprète décider par lui-même si l'entrée mène quelque part. Puisque> <> n'implémente plus le threading, cela nous pose un gros problème: si l'entrée a une boucle, nous y resterons coincés.

Ces considérations prises en compte, j'ai décidé de rendre une solution compatible avec > <> l'interprète en ligne afin qu'il soit possible d'affirmer si l'interprète est bloqué dans l'entrée ou s'il prend juste des âges pour tout faire. J'ai également dû ajouter des lignes de fin au code afin que l'interpréteur en ligne affiche le code ajouté et ne se bloque pas lors de la tentative d'écriture.

Oh et puisque je suis clairement disqualifié maintenant, je n'ai pas pris la peine de jouer au code.

Sans plus tarder, le code dans toute sa splendeur:

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

Pour l'utiliser, copiez-le dans l'interpréteur en ligne, ajoutez suffisamment de lignes de fin pour gérer votre entrée, soumettez le code, donnez-lui l'entrée en tant ;que lignes séparées et profitez de la balade.

Quelques tests:

Avec

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

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

Sort "vrai" et s'arrête.

Avec

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

Espace de code final:

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

Boucles pour toujours.