Hãy tưởng tượng một kẻ chủ mưu đi dạo quanh thị trấn và chọn nạn nhân của nó theo một mô hình rất cụ thể (Hoặc, thay vào đó, hãy tưởng tượng một con ong bay quanh vườn và hái hoa để thụ phấn theo một mô hình rất cụ thể ). Giả sử thị trấn là ma trận N × N , trong đó N là số nguyên cao hơn hoặc bằng 2 . Kẻ chủ mưu bắt đầu từ góc trên bên trái và liên tiếp đặt các điểm M ở phía trước chúng (trong đó M là số nhà mà chúng hiện đang ở), trong khi thay đổi hướng di chuyển sau mỗi đám cháy, theo thứ tự Đông ⟶ Nam ⟶ Tây Bắc Đông ⟶ Nam ... vân vân. Bài hát rucủa kẻ chủ mưu là giá trị của M khiến họ rời khỏi thị trấn (tức là ngôi nhà cuối cùng họ ghé thăm trước khi dừng việc ghê tởm). Đây là cách dễ hiểu hơn với một ví dụ. Lấy ma trận sau đây làm ví dụ:

3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1

• Chúng tôi bắt đầu ở góc trên bên trái, vì vậy M = 3 ( Xđánh dấu các vị trí hiện tại và trước đó của kẻ chủ mưu):

  X 2 3 2 7
  3 1 4 1 6
  2 5 3 1 1
  4 4 3 2 4
  1 1 1 1 1
  

• Theo thứ tự đã biết, đầu tiên nó đi về phía đông điểm M (3) và hạ cánh trên 2 để M thay đổi tương ứng:

  X 2 3 X 7
  3 1 4 1 6
  2 5 3 1 1
  4 4 3 2 4
  1 1 1 1 1
  

• Sau đó, nó đi về phía nam 2 điểm và M là 1 :

  X 2 3 X 7
  3 1 4 1 6
  2 5 3 X 1
  4 4 3 2 4
  1 1 1 1 1
  

• Bây giờ nó di chuyển 1 điểm về phía Tây và M trở thành 3 :

  X 2 3 X 7
  3 1 4 1 6
  2 5 XX 1
  4 4 3 2 4
  1 1 1 1 1
  

• Sau khi nó di chuyển 3 điểm về phía bắc, nó rời khỏi thị trấn! Vì vậy, 3 là bài hát ru của kẻ chủ mưu này:

      X
  X 2 3 X 7
  3 1 4 1 6
  2 5 XX 1
  4 4 3 2 4
  1 1 1 1 1
  

Đưa ra một ma trận N × N (bạn cũng có thể tùy chọn lấy N làm đầu vào), tìm bài hát ru của người chủ mưu. Tôi đã viết một chương trình mà bạn có thể tạo ra nhiều trường hợp thử nghiệm hơn và hình dung đường dẫn của kẻ chủ mưu: Hãy thử trực tuyến!

• Bạn có thể cho rằng kẻ chủ mưu thực sự có một bài hát ru (nghĩa là nó thực sự có thể thoát ra khỏi ma trận).
• Ma trận sẽ chỉ chứa các số nguyên dương nhỏ hơn hoặc bằng 9 (chữ số), vì đơn giản. Các giải pháp xử lý bất kỳ số nguyên dương nào đều được chào đón.
• Lưu ý rằng kẻ chủ mưu có thể hạ cánh tại một điểm mà chúng đã bị đốt cháy, trong trường hợp cảm giác chúng di chuyển khác với lần đầu tiên. Trong kịch bản như vậy, chỉ cần lấy giá trị của phần tử đó và di chuyển lại như bình thường.
• Bạn có thể cạnh tranh trong bất kỳ ngôn ngữ lập trình nào và có thể nhận đầu vào và cung cấp đầu ra thông qua bất kỳ phương thức tiêu chuẩn nào , trong khi lưu ý rằng các lỗ hổng này bị cấm theo mặc định. Đây là môn đánh gôn , vì vậy bài nộp ngắn nhất (tính bằng byte) cho mọi ngôn ngữ sẽ thắng.

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

-------------
9 2 3
1 7 2
8 7 6

Bài hát ru: 9
-------------
2 1 2 1
3 1 1 2
1 2 2 1
1 1 1 3

Bài hát ru: 2
-------------
3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1

Bài hát ru: 3
-------------
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2

Bài hát ru: 2
-------------
3 2 1 2 1 1 1
2 3 2 3 2 1 1
2 1 1 1 3 1 2
3 1 1 1 1 1 1
4 5 2 3 1 1 1
1 2 1 2 1 2 2
1 2 2 3 2 1 2

Bài hát ru: 3
-------------

Các ma trận trong một định dạng khác nhau:

[[9, 2, 3], [1, 7, 2], [8, 7, 6]
[[2, 1, 2, 1], [3, 1, 1, 2], [1, 2, 2, 1], [1, 1, 1, 3]]
[[3, 2, 3, 2, 7], [3, 1, 4, 1, 6], [2, 5, 3, 1, 1], [4, 4, 3, 2, 4], [ 1, 1, 1, 1, 1]]
[[1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2]]
[[3, 2, 1, 2, 1, 1, 1], [2, 3, 2, 3, 2, 1, 1], [2, 1, 1, 1, 3, 1, 2], [ 3, 1, 1, 1, 1, 1, 1], [4, 5, 2, 3, 1, 1, 1], [1, 2, 1, 2, 1, 2, 2], [1, 2, 2, 3, 2, 1, 2]]

Trường hợp thử nghiệm thứ năm là rất thú vị để hình dung .

MATL , 32 byte

JQ6*`G5thYay&Zj3$)wyJ2@-^*+8M]b&

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Ma trận đầu vào được đệm với một khung gồm năm số không, ví dụ như vậy

3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1

trở thành

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 3 2 3 2 7 0 0 0 0 0
0 0 0 0 0 3 1 4 1 6 0 0 0 0 0
0 0 0 0 0 2 5 3 1 1 0 0 0 0 0
0 0 0 0 0 4 4 3 2 4 0 0 0 0 0
0 0 0 0 0 1 1 1 1 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Khung số không được sử dụng để phát hiện khi ong đốt đã thoát khỏi ma trận. Phần mở rộng với năm số không đảm bảo rằng sự dịch chuyển mô-đun có độ dài lên đến 9bất kỳ hướng nào từ bất kỳ mục nhập khác nào sẽ hạ cánh chính xác trong một số 0 mà không bao quanh một số mục nhập khác không.

Trong tọa độ ma trận, con ong bắt đầu khi vào (6,6)ma trận mở rộng. Nó đọc mục đó và cập nhật tọa độ theo yêu cầu, áp dụng chuyển vị (mô-đun) của độ dài đọc theo hướng tương ứng. Điều này được lặp lại trong một vòng lặp cho đến khi giá trị đọc là 0. Mục nhập đã được đọc trước đó (tức là mục nhập khác không cuối cùng) là đầu ra.

Các tọa độ thực sự được lưu trữ dưới dạng một số phức, vì vậy, ví dụ (6,6)trở thành 6+6j. Bằng cách này, bốn hướng tuần hoàn có thể được nhận ra là sức mạnh của đơn vị tưởng tượng. Sức mạnh tương ứng ( j, 1, -jhoặc -1) được nhân với mục đọc để có được sự dịch chuyển phức tạp được sử dụng để cập nhật các tọa độ.

Các giá trị đọc liên tiếp được giữ trên ngăn xếp. Khi vòng lặp được thoát, ngăn xếp chứa tất cả các giá trị đọc khác không theo thứ tự, sau đó là giá trị đọc cuối cùng 0, sau đó là tọa độ phức tạp mới nhất. Vì vậy, yếu tố hàng đầu thứ ba là đầu ra cần thiết.

JavaScript (ES6), 70 68 byte

m=>(g=d=>(n=(m[y]||0)[x])?g(--d&3,x-=d%2*(y+=--d%2*n,L=n)):L)(x=y=0)

Hãy thử trực tuyến!

Đã bình luận

m => (                        // given m = input matrix
  g = d =>                    // g = recursive function taking the direction d
    (n = (m[y] || 0)[x]) ?    // let n be the content of the current cell; if it's defined:
      g(                      //   do a recursive call:
        --d & 3,              //     with the next direction (0 = E, 3 = S, 2 = W, 1 = N)
        x -=                  //     update x by subtracting ...
          d % 2 * (           //       ... ((d - 1) % 2) * n
            y += --d % 2 * n, //       and update y by adding ((d - 2) % 2) * n
            L = n             //       save n into L
          )                   //     end of x update
      )                       //   end of recursive call
    :                         // else:
      L                       //   stop recursion and return L
)(x = y = 0)                  // initial call to g() with x = y = d = 0

Cho rằng dấu hiệu của modulo trong JS là của cổ tức, hướng được cập nhật theo cách này:

 d | d' = --d&3 | dx = -(d%2)  | dy = --d%2 | direction
---+------------+--------------+------------+------------------
 0 |     3      | -(-1%2) = +1 | -2%2 =  0  | (+1,  0) = East
 3 |     2      | -( 2%2) =  0 |  1%2 = +1  | ( 0, +1) = South
 2 |     1      | -( 1%2) = -1 |  0%2 =  0  | (-1,  0) = West
 1 |     0      | -( 0%2) =  0 | -1%2 = -1  | ( 0, -1) = North

Than , 25 18 byte

ＰＳ↶ＷＫＫ«≔ιθ×Ｉι¶↷»⎚θ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＰＳ

In chuỗi đầu vào, nhưng không di chuyển vị trí in.

↶

Xoay trục trái, để hướng in hiện lên.

ＷＫＫ«

Lặp lại trong khi có một ký tự dưới vị trí in.

≔ιθ

Lưu ký tự trong một biến.

×Ｉι¶

Truyền ký tự cho một số và in nhiều dòng mới. Khi hướng in hiện lên, kết thúc in theo chiều ngang. Kết quả cuối cùng là chúng tôi đã di chuyển vị trí in theo hướng mong muốn theo số lượng được cung cấp bởi số dưới vị trí in.

↷»

Xoay trục để các dòng mới tiếp theo di chuyển vị trí in theo hướng tiếp theo theo chiều kim đồng hồ cho lần tiếp theo của vòng lặp.

Ｆ⟦ωθ⟧¿ιι⎚

Thật không may, chúng tôi vẫn có đầu vào làm lộn xộn khung vẽ của chúng tôi, và thậm chí không may hơn, nếu chúng tôi xóa khung vẽ, chúng tôi cũng xóa biến của chúng tôi. Vì vậy, đây là một mẹo nhỏ: một danh sách các chuỗi rỗng và biến được lặp lại. Trên đường chuyền đầu tiên của vòng lặp, biến vòng lặp trống, vì vậy biến canvas và biến vòng lặp và biến kết quả đều bị xóa. Nhưng vòng lặp chưa kết thúc! Trên đường chuyền thứ hai của vòng lặp, chúng ta vẫn có thể truy cập vào biến được bảo quản cẩn thận trong danh sách vòng lặp của chúng ta. Nó chỉ đơn giản là vẫn còn để in nó.

⎚θ

Xóa khung vẽ và in biến đã lưu. (Cảm ơn @ ASCII - chỉ sửa lỗi cho Than.)

Python 2 , 85 84 byte

a=input();x=y=e=0;d=1
while-1<y<len(a)>x>=0:v=a[y][x];x+=v*d;y+=e*v;d,e=-e,d
print v

Hãy thử trực tuyến!

Mẹo mũ cho ông Xcoder trong 1 byte.

Than , 50 49 46 34 33 26 byte

ＮθＥθＳＭθ↑ＷＫＫ«ＭＩι✳⊗Ｌυ⊞υι»⎚⊟υ

Dùng thử trực tuyến

Liên kết là phiên bản dài dòng của mã

Đầu vào phải là N trên dòng riêng của nó, sau đó các dòng của mảng trên các dòng riêng biệt sau đó.

Bất kỳ cách nào để loại bỏ byte đều được chào đón và mong muốn, vì tôi không phải là người chơi golf giỏi trong Than!

-12 byte nhờ @Neil! -1 byte chỉ nhờ @ ASCII! -7 byte chỉ nhờ @ ASCII (đã thay đổi lỗi tạo Clearcác biến đặt lại)

Màu đỏ , 145 byte

func[b][h:[0 1 0 -1 0]x: y: 1 i: 0
until[y: h/(i: i % 4 + 1) *(t: b/(y)/(x)) + y x: h/(i + 1) * t + x none = b/(y) or(x < 1 or(x > length? b))]t]

Hãy thử trực tuyến!

Dễ đọc hơn:

f: func[b][
    h: [0 1 0 -1 0]                                ; step lengths (combined for x and y) 
    x: y: 1                                        ; starting coords (1,1)
    i: 0                                           ; step counter 
    until[
        y: h/(i: i % 4 + 1) * (t: b/(y)/(x)) + y   ; next y; t stores the lullaby
        x: h/(i + 1) * t + x                       ; next x
        none = b/(y) or (x < 1 or (x > length? b)) ; until x or y are not valid indices
    ]
    t                                              ; return the lullaby
]

Perl 6 , 62 byte

{$^w;$^m[0,{$_+$m[$_]*(1,$w,-1,-$w)[$++%4]}...{!$m[$_]}][*-2]}

Hãy thử trực tuyến!

Lấy ma trận dưới dạng danh sách phẳng và chiều rộng.

Sạch , 141 byte

import StdEnv
d=[0,1,1,0,0,-1,-1,0:d]
$m[x,y]n[a,b:l]#r=size m
#u=x+a*n
#v=y+b*n
|0>u||0>v||u>=r||v>=r=n= $m[u,v]m.[u,v]l
?m= $m[0,0]m.[0,0]d

Hãy thử trực tuyến!

Xác định hàm ? :: {#{#Int}} -> Int, lấy một mảng các hộp số nguyên không có hộp và trả về kết quả.

Java 8, 121 byte

m->{int l=m.length,x=0,y=0,f=0,r=0;for(;x*y>=0&x<l&y<l;x+=f<1?r:f==2?-r:0,y+=f==1?r:f>2?-r:0,f=++f%4)r=m[y][x];return r;}

Hãy thử trực tuyến.

Thay thế với cùng số lượng byte 121 byte :

m->{int l=m.length,x=0,y=0,f=0,r=0;try{for(;;x+=f<1?r:f==2?-r:0,y+=f==1?r:f>2?-r:0,f=++f%4)r=m[y][x];}finally{return r;}}

Sử dụng thử - cuối cùng thay vì kiểm tra xem x,y-coordine có còn trong giới hạn không.

Hãy thử trực tuyến.

Giải trình:

m->{                   // Method with integer-matrix parameter and integer return-type
  int l=m.length,      //  Dimensions of the matrix
      x=0,y=0,         //  x,y coordinate, starting at [0,0]
      f=0,             //  Direction-flag, starting at 0 (east)
      r=0;             //  Result-integer
  for(;x*y>=0&x<l&y<l  //  Loop as long as the x,y coordinates are still within bounds
      ;                //    After every iteration:
       x+=f<1?         //     If the direction is east:
           r           //      Increase the `x` coordinate by `r`
          :f==2?       //     Else-if the direction is west:
           -r          //      Decrease the `x` coordinate by `r`
          :            //     Else (it's north/south):
           0,          //      Leave the `x` coordinate the same
       y+=f==1?        //     If the direction is south:
           r           //      Increase the `y` coordinate by `r`
          :f>2?        //     Else-if the direction is north:
           -r          //      Decrease the `y` coordinate by `r`
          :            //     Else:
           0,          //      Leave the `y` coordinate the same
       f=++f%4)        //     Go to the next direction (0→1→2→3→0)
    r=m[y][x];         //   Set `r` to the value of the current cell
  return r;}           //  Return the last `r` before we went out of bounds

Perl 5 , 92 byte

sub b{1while eval join'&&',map{/./;map"(\$$_$&=".'$n=$_[$y][$x])'.$',x,'y'}'+<@_','->=0';$n}

Hãy thử trực tuyến!

Làm sao?

Tập hợp các bản đồ lồng nhau và tham gia tạo ra điều này:

($x+=$n=$_[$y][$x])<@_&&($y+=$n=$_[$y][$x])<@_&&($x-=$n=$_[$y][$x])>=0&&($y-=$n=$_[$y][$x])>=0

mà sau đó được ước tính để xác định nếu vòng lặp kết thúc. Vì Boolean được đánh giá từ trái sang phải, giá trị $nthực sự thay đổi (tối đa) bốn lần trong quá trình đánh giá. Vì logic ngắn Boolean trong Perl, giá trị của $nlà bài hát ru khi vòng lặp được thoát.

Python 3 , 85 84 byte

xcoder: -1 (Tôi không bao giờ nhớ mẹo + ~)

def f(x):
 r=c=0
 while-1<r:d=x[r][c];r,c=len(x)-c+~d,r;x=[*zip(*x)][::-1]
 return d

Hãy thử trực tuyến!

Thay vì di chuyển theo các hướng khác nhau (E, S, W, N), giải pháp này luôn di chuyển về phía đông và xoay lưới ngược chiều kim đồng hồ sau mỗi lần di chuyển. Sau khi xoay, cột cuối cùng bây giờ là hàng đầu tiên, vì vậy nếu chỉ số hàng nhỏ hơn 0, điều đó có nghĩa là chúng tôi đã chạy khỏi bảng.

Võng mạc , 161 byte

.
 $.%`*_#$&*
(?<=(.+¶)+|^)
A ¶A$#1*
~(K`{`^X\1YZ¶1S$4¶1XYZ¶2$4$2$4$3¶2XYZ¶3S¶3XY\1Z¶S
X
(_$*)(A_$*)
Y
( _$*)
Z
(?=\n\D$*\2\b.$*\3#(_+))
)`S
$$4$$2$$3
L$0`_+
$.0

Hãy thử trực tuyến!