Eingang

Ihre Eingabe ist ein Einzelsaite, die durch Zeilenumbrüche in getrennte 2n+1Leitungen mit einer Länge 2n+1, für eine ganze Zahl n ≥ 0. Die Ganzzahl nist nicht Teil der Eingabe. Sie müssen es aus der Zeichenfolge berechnen. Die Zeilen bestehen aus den "Richtungszeichen" >^<v. Wenn Zeilenumbrüche ein Problem darstellen, können Sie sie durch vertikale Rohre ersetzen |.

Die Eingabe bildet ein quadratisches Gitter mit einer Größe (2n+1)x(2n+1), und jede Zelle des Gitters wird als Rotorfräser interpretiert , der in eine der vier Hauptrichtungen zeigt. Wir legen ein Token auf dem Router in der Mitte des Rasters ab, und die Router verschieben es dann auf folgende Weise. Wenn der Token auf einem Router landet, dreht sich der Router um 90 Grad gegen den Uhrzeigersinn und bewegt den Token einen Schritt in die neue Richtung, in die er zeigt. Wenn es auf einem anderen Router landet, wird der Vorgang wiederholt, aber schließlich fällt das Token vom Netz.

Ausgabe

Ihre Ausgabe ist die endgültige Konfiguration der Router im gleichen Format wie die Eingabe.

Beispiel

Betrachten Sie als Beispieleingabe das 3x3Raster

<^<
^><
>^v

wo der zentrale Router markiert wurde, um das Token anzuzeigen (es ist ein bisschen schwer zu sehen). Der zentrale Router dreht sich nach Norden und verschiebt den Token in die zentrale Zelle der oberen Reihe:

<^<
^^<
>^v

Dieser Router dreht sich nach Westen und sendet den Token an die obere linke Ecke:

<<<
^^<
>^v

Der Router in der Ecke sendet den Token nach Süden, sodass er sich jetzt ganz links in der mittleren Reihe befindet:

v<<
^^<
>^v

Dieser Router dreht sich nach Westen und sendet den Token vom Netz.

v<<
<^<
>^v

Dies ist die endgültige Grid-Konfiguration, daher sollte Ihr Programm sie ausgeben. Beachten Sie, dass in komplexeren Beispielen das Token denselben Router mehrmals passieren kann, bevor es vom Netz fällt.

Regeln

Sie können entweder eine Funktion oder ein vollständiges Programm schreiben. Dies ist Code-Golf, also gewinnt die niedrigste Byteanzahl. Standardlücken sind nicht zulässig. Sie können entscheiden, ob die Eingabe und / oder die Ausgabe einen nachgestellten Zeilenumbruch enthält.

Testfälle

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

Probieren Sie es online aus

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

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

Erweitert und kommentiert:

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

Meine Lösung arbeitet mit der Eingabe als flache Zeichenfolge, sodass nur ein Positionswert verfolgt werden muss und praktisch keine Vor- / Nachbearbeitung erfolgt. Es gibt nur 2 Bytes Vorverarbeitung, um am Anfang des Rasters eine neue Zeile hinzuzufügen, und 2 Bytes Nachverarbeitung, um sie aus der Ausgabe zu entfernen. Aber diese 4 Bytes sind die Kosten wert, da sie es mir ermöglichen, Zeilenumbrüche beizubehalten und sie wie Router "auszuführen", aber sie "drehen" sich in eine andere Zeilenumbruch und setzen die Position auf Null. Und die Hauptschleife endet, wenn die Position Null wird.

CJam, 90 69 Bytes

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

Riesig für jetzt, kann noch viel reduziert werden.

Probieren Sie es hier online aus

JavaScript (ES6) 121 120 127 129

Eine benannte Funktion, die die Zeichenfolge als Eingabeparameter abruft und die Ausgabe zurückgibt.
Angenommen, die Eingabezeichenfolge wird mit einem Zeilenumbruch abgeschlossen.

Fehlerbehebung bearbeiten , .search () funktioniert nicht gut mitundefined

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 und erklärt

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 In Firefox / Firebug - Konsole

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

Ausgabe

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