Вхідні дані

Ваш вхід - це один рядок, розділений новими рядками на 2n+1рядки довжини 2n+1на деяке ціле число n ≥ 0. Ціле число nне є частиною вводу; вам доведеться обчислити його з рядка. Рядки складаються з "символів напряму" >^<v. Якщо нові лінії створюють проблему, ви можете замінити їх вертикальними трубами |.

Вхід утворює квадратну сітку розміром (2n+1)x(2n+1), і кожна комірка сітки інтерпретується як роторний маршрутизатор , який вказує в одному з чотирьох кардинальних напрямків. Ми продовжуємо опускати маркер на маршрутизатор в центрі сітки, і тоді маршрутизатори переміщатимуть його наступним чином. Коли маркер приземлиться на маршрутизатор, маршрутизатор повертає на 90 градусів у напрямку проти годинникової стрілки і переміщує маркер на один крок у новому напрямку, на який він вказує. Якщо він приземлиться на інший маршрутизатор, процес повторюється, але з часом маркер відвалиться від мережі.

Вихідні дані

Ваш вихід - це остаточна конфігурація маршрутизаторів, у тому ж форматі, що і вхід.

Приклад

Як приклад введення розглянемо 3x3сітку

<^<
^><
>^v

де центральний маршрутизатор був виділений для позначення маркера (це трохи важко помітити). Центральний маршрутизатор обертається обличчям на північ і переміщує маркер до центральної комірки верхнього ряду:

<^<
^^<
>^v

Цей маршрутизатор обертається обличчям на захід і надсилає маркер у верхній лівий кут:

<<<
^^<
>^v

Маршрутизатор у куті надсилає маркер на південь, тож він зараз знаходиться в крайній лівій комірці середнього ряду:

v<<
^^<
>^v

Цей маршрутизатор обертається обличчям на захід і відправляє маркер із мережі.

v<<
<^<
>^v

Це остаточна конфігурація сітки, тому ваша програма повинна виводити її. Зауважте, що у більш складних прикладах маркер може передавати один і той же маршрутизатор кілька разів, перш ніж випадати з мережі.

Правила

Ви можете написати або функцію, або повну програму. Це код-гольф, тому виграє найменший байт. Стандартні лазівки заборонені. Ви можете вирішити, чи є зворотний новий рядок у вході та / або виході.

Випробування

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 байт

Спробуйте в Інтернеті

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

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

Розширено та прокоментовано:

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

Моє рішення працює на вході як плоский рядок, тому існує лише одне значення позиції, яке слід відслідковувати, і практично немає попередньої / післяобробки; є лише 2 байти попередньої обробки для додавання нового рядка до початку сітки та 2 байти післяобробки для видалення його з виводу. Але ці 4 байти добре коштують вартості, оскільки вони дозволяють мені тримати нові рядки і виконувати їх, як маршрутизатори, але вони "обертаються" в інший новий рядок і встановлюють позицію в нуль. І основна петля закінчується, коли позиція стає нульовою.

CJam, 90 69 байт

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

Величезний поки що, Ще можна значно скоротити.

Спробуйте його онлайн тут

JavaScript (ES6) 121 120 127 129

Названа функція, яка отримує рядок як вхідний параметр і повертає результат.
Припускаючи, що вхідний рядок закінчується новим рядком.

Редагувати виправлення помилок, .search () не працює добреundefined

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

Необережений і пояснив

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
}

Тест у консолі Firefox / FireBug

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

Вихідні дані

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