Ingresso

Il tuo input è una singola stringa, separata da newline in 2n+1righe di lunghezza 2n+1, per un numero intero n ≥ 0. L'intero nnon fa parte dell'input; dovrai calcolarlo dalla stringa. Le linee sono composte dai "caratteri di direzione" >^<v. Se i newline rappresentano un problema, è possibile sostituirli con tubi verticali |.

L'input forma una griglia quadrata di dimensioni (2n+1)x(2n+1)e ogni cella della griglia viene interpretata come un router del rotore , che punta in una delle quattro direzioni cardinali. Procediamo a rilasciare un token sul router al centro della griglia, quindi i router lo sposteranno nel modo seguente. Quando il token atterra su un router, il router ruota di 90 gradi in senso antiorario e sposta il token di un passo nella nuova direzione verso cui punta. Se atterra su un altro router, il processo si ripete, ma alla fine il token cadrà dalla griglia.

Produzione

L'output è la configurazione finale dei router, nello stesso formato dell'input.

Esempio

Come esempio di input, considera la 3x3griglia

<^<
^><
>^v

dove il router centrale è stato evidenziato per indicare il token (è un po 'difficile da vedere). Il router centrale ruota verso nord e sposta il token nella cella centrale della riga superiore:

<^<
^^<
>^v

Questo router ruota verso ovest e invia il token nell'angolo in alto a sinistra:

<<<
^^<
>^v

Il router nell'angolo invia il token a sud, quindi ora è nella cella più a sinistra della riga centrale:

v<<
^^<
>^v

Quel router ruota verso ovest e manda il token fuori dalla griglia.

v<<
<^<
>^v

Questa è la configurazione della griglia finale, quindi il tuo programma dovrebbe emetterla. Si noti che in esempi più complessi, il token può passare lo stesso router più volte prima di cadere dalla griglia.

Regole

È possibile scrivere una funzione o un programma completo. Questo è code-golf, quindi vince il numero di byte più basso. Le scappatoie standard non sono ammesse. Puoi decidere se c'è una nuova riga finale nell'input e / o output.

Casi 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 byte

Provalo online

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

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

Ampliato e commentato:

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

La mia soluzione opera sull'input come una stringa piatta, quindi c'è solo un valore di posizione da tenere traccia e praticamente nessun pre / postprocessing; ci sono solo 2 byte di preelaborazione per aggiungere una nuova riga all'inizio della griglia e 2 byte di postelaborazione per rimuoverlo dall'output. Ma questi 4 byte valgono il costo in quanto mi permettono di mantenere le nuove linee e di "eseguirle" come router, ma "ruotano" in un'altra linea e impostano la posizione su zero. E il loop principale termina quando la posizione diventa zero.

CJam, 90 69 byte

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

Enorme per ora, può ancora essere ridotto molto.

Provalo online qui

JavaScript (ES6) 121 120 127 129

Una funzione con nome che ottiene la stringa come parametro di input e restituisce l'output.
Supponendo che la stringa di input sia terminata con una nuova riga.

Modifica correzione bug, .search () non funziona bene 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('')

Ungolfed e spiegato

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
}

Test nella console Firefox / FireBug

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

Produzione

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