Đầu vào

Đầu vào của bạn là một chuỗi đơn, được phân tách bằng các dòng mới thành 2n+1các dòng có độ dài 2n+1, đối với một số nguyên n ≥ 0. Số nguyên nkhông phải là một phần của đầu vào; bạn sẽ phải tính toán nó từ chuỗi. Các dòng được tạo thành từ "ký tự hướng" >^<v. Nếu dòng mới gây ra vấn đề, bạn có thể thay thế chúng bằng ống đứng |.

Đầu vào tạo thành một lưới hình vuông có kích thước (2n+1)x(2n+1)và mỗi ô của lưới được hiểu là một bộ định tuyến rôto , chỉ ra một trong bốn hướng chính. Chúng tôi tiến hành thả mã thông báo trên bộ định tuyến ở trung tâm của lưới và sau đó các bộ định tuyến sẽ di chuyển nó theo cách sau. Khi mã thông báo hạ cánh trên bộ định tuyến, bộ định tuyến quay 90 độ theo hướng ngược chiều kim đồng hồ và di chuyển mã thông báo một bước theo hướng mới mà nó trỏ tới. Nếu nó hạ cánh trên một bộ định tuyến khác, quá trình được lặp lại, nhưng cuối cùng, mã thông báo sẽ rơi ra khỏi lưới.

Đầu ra

Đầu ra của bạn là cấu hình cuối cùng của các bộ định tuyến, có cùng định dạng với đầu vào.

Thí dụ

Như một ví dụ đầu vào, hãy xem xét 3x3lưới

<^<
^><
>^v

trong đó bộ định tuyến trung tâm đã được tô sáng để chỉ ra mã thông báo (hơi khó nhìn). Bộ định tuyến trung tâm quay về hướng bắc và di chuyển mã thông báo đến ô trung tâm của hàng trên cùng:

<^<
^^<
>^v

Bộ định tuyến này quay về hướng tây và gửi mã thông báo đến góc trên cùng bên trái:

<<<
^^<
>^v

Bộ định tuyến ở góc gửi mã thông báo về phía nam, vì vậy giờ đây nó nằm ở ô ngoài cùng bên trái của hàng giữa:

v<<
^^<
>^v

Bộ định tuyến đó quay về hướng tây và gửi mã thông báo ra khỏi lưới.

v<<
<^<
>^v

Đây là cấu hình lưới cuối cùng, vì vậy chương trình của bạn sẽ xuất nó. Lưu ý rằng trong các ví dụ phức tạp hơn, mã thông báo có thể vượt qua cùng một bộ định tuyến nhiều lần trước khi rơi khỏi lưới.

Quy tắc

Bạn có thể viết một hàm hoặc một chương trình đầy đủ. Đây là môn đánh gôn, vì vậy số byte thấp nhất sẽ thắng. Sơ hở tiêu chuẩn là không được phép. Bạn có thể quyết định xem có một dòng mới trong đầu vào và / hoặc đầu ra.

Các trường hợp thử nghiệm

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

Dùng thử trực tuyến

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

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

Mở rộng và bình luận:

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

Giải pháp của tôi hoạt động trên đầu vào dưới dạng một chuỗi phẳng, do đó chỉ có một giá trị vị trí để theo dõi và hầu như không có tiền xử lý / hậu xử lý; chỉ có 2 byte tiền xử lý để thêm dòng mới vào đầu lưới và 2 byte tiền xử lý để loại bỏ nó khỏi đầu ra. Nhưng 4 byte này rất đáng giá vì chúng cho phép tôi giữ các dòng mới và "thực thi" chúng như các bộ định tuyến, nhưng chúng "xoay" sang một dòng mới khác và đặt vị trí về 0. Và vòng lặp chính kết thúc khi vị trí trở thành số không.

CJam, 90 69 byte

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

Rất lớn cho đến bây giờ, vẫn có thể được giảm rất nhiều.

Dùng thử trực tuyến tại đây

JavaScript (ES6) 121 120 127 129

Hàm được đặt tên lấy chuỗi làm tham số đầu vào và trả về đầu ra.
Giả sử chuỗi đầu vào được kết thúc bằng một dòng mới.

Chỉnh sửa sửa lỗi, .search () không hoạt động tốt vớiundefined

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

Ung dung và giải thích

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
}

Kiểm tra trong bảng điều khiển Firefox / FireBug

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

Đầu ra

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