Entrada

Sua entrada é uma única sequência, separada por novas 2n+1linhas em linhas de comprimento 2n+1, para alguns números inteiros n ≥ 0. O número inteiro nnão faz parte da entrada; você terá que calculá-lo a partir da string. As linhas são compostas pelos "caracteres de direção" >^<v. Se as novas linhas apresentarem um problema, você poderá substituí-las por tubos verticais |.

A entrada forma uma grade quadrada de tamanho (2n+1)x(2n+1)e cada célula da grade é interpretada como um roteador de rotor , que aponta em uma das quatro direções principais. Passamos a soltar um token no roteador no centro da grade e os roteadores o moverão da seguinte maneira. Quando o token chega ao roteador, ele gira 90 graus no sentido anti-horário e move o token um passo na nova direção para a qual aponta. Se ele pousar em outro roteador, o processo será repetido, mas, eventualmente, o token cairá da grade.

Resultado

Sua saída é a configuração final dos roteadores, no mesmo formato da entrada.

Exemplo

Como exemplo de entrada, considere a 3x3grade

<^<
^><
>^v

onde o roteador central foi destacado para indicar o token (é um pouco difícil de ver). O roteador central gira para o norte e move o token para a célula central da linha superior:

<^<
^^<
>^v

Este roteador gira para o oeste e envia o token para o canto superior esquerdo:

<<<
^^<
>^v

O roteador no canto envia o token para o sul, agora está na célula mais à esquerda da linha do meio:

v<<
^^<
>^v

Esse roteador gira para o oeste e envia o token da rede.

v<<
<^<
>^v

Esta é a configuração final da grade, portanto, seu programa deve produzi-la. Observe que, em exemplos mais complexos, o token pode passar pelo mesmo roteador várias vezes antes de cair da grade.

Regras

Você pode escrever uma função ou um programa completo. Isso é código-golfe, então a menor contagem de bytes vence. As brechas padrão não são permitidas. Você pode decidir se há uma nova linha à direita na entrada e / ou saída.

Casos de teste

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

Experimente online

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

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

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

Minha solução opera na entrada como uma sequência simples, portanto, há apenas um valor de posição para acompanhar e praticamente nenhum pré / pós-processamento; existem apenas 2 bytes de pré-processamento para adicionar nova linha ao início da grade e 2 bytes de pós-processamento para removê-la da saída. Mas esses 4 bytes valem bem o custo, pois me permitem manter as novas linhas e "executá-las" como roteadores, mas elas "rotacionam" para outra nova linha e definem a posição como zero. E o loop principal termina quando a posição se torna zero.

CJam, 90 69 bytes

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

Enorme por enquanto, ainda pode ser reduzido bastante.

Experimente online aqui

JavaScript (ES6) 121 120 127 129

Uma função nomeada que obtém a string como um parâmetro de entrada e retorna a saída.
Supondo que a sequência de entrada seja finalizada com uma nova linha.

Editar correção de bug, .search () não funciona bem comundefined

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

Ungolfed e explicou

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
}

Teste no console Firefox / FireBug

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

Resultado

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