Contribution

Votre entrée est une chaîne unique, séparée par des sauts de ligne en 2n+1lignes de longueur 2n+1, pour un entier n ≥ 0. L'entier nne fait pas partie de l'entrée; vous devrez le calculer à partir de la chaîne. Les lignes sont composées des "caractères de direction" >^<v. Si les sauts de ligne posent un problème, vous pouvez les remplacer par des tuyaux verticaux |.

L'entrée forme une grille carrée de taille (2n+1)x(2n+1), et chaque cellule de la grille est interprétée comme un routeur à rotor , qui pointe dans l'une des quatre directions cardinales. Nous procédons à déposer un jeton sur le routeur au centre de la grille, puis les routeurs le déplaceront de la manière suivante. Lorsque le jeton atterrit sur un routeur, le routeur tourne de 90 degrés dans le sens antihoraire et déplace le jeton d'un pas dans la nouvelle direction vers laquelle il pointe. S'il atterrit sur un autre routeur, le processus est répété, mais finalement, le jeton tombera du réseau.

Production

Votre sortie est la configuration finale des routeurs, au même format que l'entrée.

Exemple

Comme exemple d'entrée, considérons la 3x3grille

<^<
^><
>^v

où le routeur central a été mis en surbrillance pour indiquer le jeton (c'est un peu difficile à voir). Le routeur central pivote pour faire face au nord et déplace le jeton vers la cellule centrale de la rangée supérieure:

<^<
^^<
>^v

Ce routeur pivote pour faire face à l'ouest et envoie le jeton dans le coin supérieur gauche:

<<<
^^<
>^v

Le routeur dans le coin envoie le jeton au sud, il est donc maintenant dans la cellule la plus à gauche de la rangée du milieu:

v<<
^^<
>^v

Ce routeur tourne pour faire face à l'ouest et envoie le jeton hors de la grille.

v<<
<^<
>^v

Ceci est la configuration finale de la grille, donc votre programme devrait la sortir. Notez que dans des exemples plus complexes, le jeton peut passer plusieurs fois par le même routeur avant de tomber du réseau.

Règles

Vous pouvez écrire soit une fonction soit un programme complet. C'est le code-golf, donc le nombre d'octets le plus bas l'emporte. Les failles standard ne sont pas autorisées. Vous pouvez décider s'il y a une nouvelle ligne de fin dans l'entrée et / ou la sortie.

Cas de test

Input:
v
Output:
>

Input:
<^<
^><
>^v
Output:
v<<
<^<
>^v

Input:
>>^>>
v<vv<
>^>^<
^<>>^
vvv>>
Output:
>>^>>
>v>>v
^>>vv
^^>>>
v^<<^

Input:
<^^^^^^^^
<<^^^^^^>
<<<^^^^>>
<<<<^^>>>
<<<<^>>>>
<<<vv>>>>
<<vvvv>>>
<vvvvvv>>
vvvvvvvv>
Output:
>>>>>>>>v
^>>>>>>vv
^^>>>>vvv
^^^>>vvvv
<<<<<vvvv
^^^^<<vvv
^^^<<<<vv
^^<<<<<<v
^<<<<<<<<

CJam, 62 61 63 octets

Essayez-le en ligne

Nq_N#):D;+_,2/{:P"^<v>^

"_P4$=#:X)=t_,0PX[1DW*WDSP]=-e>e<}h;1>

Développé et commenté:

Nq              "Read the input grid";
_N#):D;         "Calculate the vertical delta (line length + 1)";
+               "Prepend a newline to the grid";
_,2/            "Calculate the initial position as the length of the grid
                 string divided by 2";
{               "Do...";
  :P"^<v>^

"
  _P4$=           "Get the character indexed by the position in the grid";
  #:X             "Map the character to an operation number:
                   '^'=>0, '<'=>1, 'v'=>2, '>'=>3, '^'=>4, '\n'=>5, '\n'=>6
                   (the unreachable duplicate mappings are important below)";
  )=t             "Set the character indexed by the position in the grid to
                   the result of mapping the operation number + 1 backwards";
  _,0PX[1DW*WDSP]="Map the operation number to a negated delta (this occurs
                   after rotating routers, which means that operation n should
                   act like the character corresponding to operation n + 1):
                   0=>1, 1=>-delta, 2=>-1, 3=>delta, 5=>position";
  -e>e<           "Subtract the negated delta from the position and clamp it to
                   [0, length of the grid string] (array indices are circular,
                   so the length of the grid string will act like the index 0
                   and point to the initial newline next iteration, which will
                   *really* set the position to 0)";
}h              "... while the position is not 0 (i.e. not at the initial
                 newline)";
;1>             "Clean up and remove the initial newline";

Ma solution fonctionne sur l'entrée comme une chaîne plate, il n'y a donc qu'une seule valeur de position à suivre et pratiquement aucun pré / post-traitement; il n'y a que 2 octets de prétraitement pour ajouter un retour à la ligne au début de la grille et 2 octets de post-traitement pour le supprimer de la sortie. Mais ces 4 octets valent bien le coût car ils me permettent de conserver les sauts de ligne et de les "exécuter" comme des routeurs, mais ils "tournent" dans un autre saut de ligne et mettent la position à zéro. Et la boucle principale se termine lorsque la position devient nulle.

CJam, 90 69 octets

q_,mqi):L_*Lm2/(:X;{_X_@="^<v>"_@#_[WL1LW*]=X+:X;)=tX)L%XW>XLL(*<**}g

Énorme pour l'instant, peut encore être beaucoup réduit.

Essayez-le en ligne ici

JavaScript (ES6) 121 120 127 129

Une fonction nommée qui obtient la chaîne en tant que paramètre d'entrée et renvoie la sortie.
En supposant que la chaîne d'entrée se termine par une nouvelle ligne.

Modifier la correction de bogue, .search () ne fonctionne pas bien avecundefined

F=s=>(o=~s.search('\n'),s=[...s],
R=p=>~(u='^<v>'.indexOf(s[p]))?R(p+[-1,-o,1,o][u],s[p]='<v>^'[u]):s)(-~o*o/2-1)
.join('')

Non golfé et expliqué

F=s=>{
  o = s.search('\n')+1; // offset to next row
  s = [...s]; // string to array
  R=p=>{ // recursive search functiom, parameter p is current position in grid
    u = '^<v>'.indexOf(s[p]); // find direction
    if (u<0) return s; // if no direction found, out of grid -> stop recursion
    s[p] = '<v>^'[u] // set new direction into the array cell 
    return R(p+[-1,o,1,-o][u]) // call recursive function with new position
  }
  return R((o-1)*o/2-1) // start recursive search with initial position at grid center
  .join('') // array to string
}

Tester dans la console Firefox / FireBug

s='<^^^^^^^^\n\
<<^^^^^^>\n\
<<<^^^^>>\n\
<<<<^^>>>\n\
<<<<^>>>>\n\
<<<vv>>>>\n\
<<vvvv>>>\n\
<vvvvvv>>\n\
vvvvvvvv>\n'
console.log(F(s))

Production

>>>>>>>>v
^>>>>>>vv
^^>>>>vvv
^^^>>vvvv
<<<<<vvvv
^^^^<<vvv
^^^<<<<vv
^^<<<<<<v
^<<<<<<<<