Entrada

Su entrada es una sola cadena, separada por nuevas 2n+1líneas en líneas de longitud 2n+1, para algún número entero n ≥ 0. El entero nno es parte de la entrada; Tendrás que calcularlo a partir de la cadena. Las líneas están compuestas por los "caracteres de dirección" >^<v. Si las nuevas líneas plantean un problema, puede reemplazarlas por tuberías verticales |.

La entrada forma una cuadrícula cuadrada de tamaño (2n+1)x(2n+1), y cada celda de la cuadrícula se interpreta como un enrutador de rotor , que apunta en una de las cuatro direcciones cardinales. Procedemos a colocar un token en el enrutador en el centro de la cuadrícula, y luego los enrutadores lo moverán de la siguiente manera. Cuando el token aterriza en un enrutador, el enrutador gira 90 grados en el sentido contrario a las agujas del reloj y mueve el token un paso en la nueva dirección a la que apunta. Si aterriza en otro enrutador, el proceso se repite, pero eventualmente, el token se caerá de la red.

Salida

Su salida es la configuración final de los enrutadores, en el mismo formato que la entrada.

Ejemplo

Como ejemplo de entrada, considere la 3x3cuadrícula

<^<
^><
>^v

donde el enrutador central se ha resaltado para indicar el token (es un poco difícil de ver). El enrutador central gira para mirar hacia el norte y mueve el token a la celda central de la fila superior:

<^<
^^<
>^v

Este enrutador gira para mirar hacia el oeste y envía el token a la esquina superior izquierda:

<<<
^^<
>^v

El enrutador en la esquina envía el token al sur, por lo que ahora está en la celda más a la izquierda de la fila central:

v<<
^^<
>^v

Ese enrutador gira para mirar hacia el oeste y envía el token fuera de la red.

v<<
<^<
>^v

Esta es la configuración final de la cuadrícula, por lo que su programa debería generarla. Tenga en cuenta que en ejemplos más complejos, el token puede pasar el mismo enrutador varias veces antes de caerse de la red.

Reglas

Puede escribir una función o un programa completo. Este es el código de golf, por lo que gana el conteo de bytes más bajo. Las lagunas estándar no están permitidas. Puede decidir si hay una nueva línea final en la entrada y / o salida.

Casos de prueba

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 bytes

Pruébalo en línea

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

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

Ampliado y comentado:

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";

Mi solución funciona en la entrada como una cadena plana, por lo que solo hay un valor de posición para realizar un seguimiento y prácticamente no hay procesamiento previo / posterior; solo hay 2 bytes de preprocesamiento para agregar nueva línea al comienzo de la cuadrícula y 2 bytes de posprocesamiento para eliminarlo de la salida. Pero estos 4 bytes valen la pena ya que me permiten mantener nuevas líneas y "ejecutarlas" como enrutadores, pero "rotan" en otra nueva línea y establecen la posición en cero. Y el bucle principal termina cuando la posición se vuelve cero.

CJam, 90 69 bytes

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

Enorme por ahora, todavía se puede reducir mucho.

Pruébalo en línea aquí

JavaScript (ES6) 121 120 127 129

Una función con nombre que obtiene la cadena como parámetro de entrada y devuelve la salida.
Suponiendo que la cadena de entrada se termina con una nueva línea.

Editar corrección de errores, .search () no funciona bien conundefined

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('')

Desengañado y explicado

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
}

Prueba en la consola Firefox / FireBug

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

Salida

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