Wejście

Dane wejściowe to pojedynczy ciąg znaków, oddzielony znakami nowej linii w 2n+1wierszach długości 2n+1, dla niektórych liczb całkowitych n ≥ 0. Liczba całkowita nnie jest częścią danych wejściowych; będziesz musiał obliczyć to na podstawie ciągu. Linie składają się z „znaków kierunkowych” >^<v. Jeśli nowe linie stanowią problem, możesz je zastąpić pionowymi rurami |.

Dane wejściowe tworzą kwadratową siatkę wielkości (2n+1)x(2n+1), a każda komórka siatki jest interpretowana jako router wirnika , który wskazuje w jednym z czterech głównych kierunków. Kontynuujemy upuszczanie tokena na routerze pośrodku sieci, a następnie routery będą go przesuwać w następujący sposób. Gdy token wyląduje na routerze, router obraca się o 90 stopni w kierunku przeciwnym do ruchu wskazówek zegara i przesuwa token o jeden krok w nowym kierunku, na który wskazuje. Jeśli wyląduje na innym routerze, proces się powtarza, ale ostatecznie token spadnie z siatki.

Wynik

Twoje dane wyjściowe to końcowa konfiguracja routerów, w tym samym formacie co dane wejściowe.

Przykład

Jako przykładowy przykład rozważ 3x3siatkę

<^<
^><
>^v

gdzie centralny router został podświetlony, aby wskazać token (jest trochę trudny do zobaczenia). Centralny router obraca się w kierunku północnym i przesuwa żeton do centralnej komórki górnego rzędu:

<^<
^^<
>^v

Router obraca się w kierunku zachodnim i wysyła token do lewego górnego rogu:

<<<
^^<
>^v

Router w rogu wysyła token na południe, więc znajduje się teraz w lewej komórce środkowego rzędu:

v<<
^^<
>^v

Router obraca się twarzą na zachód i wysyła token z siatki.

v<<
<^<
>^v

To jest końcowa konfiguracja siatki, więc twój program powinien ją wypisać. Zauważ, że w bardziej złożonych przykładach token może wielokrotnie przejść przez ten sam router, zanim spadnie z sieci.

Zasady

Możesz napisać funkcję lub pełny program. To jest golf golfowy, więc wygrywa najmniejsza liczba bajtów. Standardowe luki są niedozwolone. Możesz zdecydować, czy końcowy znak nowej linii znajduje się na wejściu i / lub wyjściu.

Przypadki testowe

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 bajtów

Wypróbuj online

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

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

Rozszerzony i skomentowany:

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

Moje rozwiązanie działa na danych wejściowych jako płaski ciąg, więc jest tylko jedna wartość pozycji do śledzenia i praktycznie nie ma wstępnego / końcowego przetwarzania; są tylko 2 bajty przetwarzania wstępnego, aby dodać nowy wiersz na początku siatki i 2 bajty przetwarzania końcowego, aby usunąć go z wyjścia. Ale te 4 bajty są warte kosztu, ponieważ pozwalają mi utrzymywać nowe linie i „wykonywać” je jak routery, ale „obracają się” do innej nowej linii i ustawiają pozycję na zero. A główna pętla kończy się, gdy pozycja staje się zerowa.

CJam, 90 69 bajtów

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

Na razie ogromny, wciąż można go znacznie zmniejszyć.

Wypróbuj online tutaj

JavaScript (ES6) 121 120 127 129

Nazwana funkcja, która pobiera ciąg jako parametr wejściowy i zwraca dane wyjściowe.
Zakładając, że ciąg wejściowy jest zakończony znakiem nowej linii.

Edytuj poprawkę, .search () nie działa dobrzeundefined

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

Nie golfił i wyjaśnił

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
}

Przetestuj w konsoli Firefox / FireBug

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

Wynik

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