Bạn sẽ nhận được một ma trận vuông các số nguyên M và một số nguyên dương n , nhỏ đúng hơn kích thước của M . Nhiệm vụ của bạn là để tạo ra tất cả vuông tiểu ma trận của M kích thước n .

Theo mục đích của thử thách này, một vuông tiểu ma trận là một nhóm các liền kề các hàng và cột chứa trong M .

Định dạng đầu vào / đầu ra

Bạn có thể tự do chọn bất kỳ định dạng hợp lý nào khác, đây chỉ là một số ví dụ.

Đầu vào

• Một ma trận trong loại ma trận gốc (nếu ngôn ngữ của bạn có một)
• Mảng 2D (một mảng gồm các mảng 1D, mỗi mảng tương ứng với một hàng / một cột)
• Mảng 1D (vì ma trận luôn vuông)
• Một chuỗi (bạn đã chọn khoảng cách, nhưng vui lòng không lạm dụng điều này theo bất kỳ cách nào), v.v.

Đầu ra

• Một ma trận ma trận.
• Mảng 4D, trong đó mỗi phần tử (danh sách 3D) đại diện cho các ma trận phụ trên một hàng / cột.
• Một mảng 3D, trong đó mỗi phần tử (danh sách 2D) đại diện cho một ma trận phụ.
• Một đại diện chuỗi của các ma trận con kết quả, v.v.

Thông số kỹ thuật

• Bạn cũng có thể chọn lấy kích thước của M làm đầu vào. Nó được đảm bảo ít nhất là 2 .
• Hướng của đầu ra là tùy ý: bạn có thể chọn xuất các ma trận phụ dưới dạng danh sách các cột hoặc danh sách các hàng, nhưng lựa chọn của bạn phải nhất quán.
• 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.

Thí dụ

Cho n = 3 và M :

 1 2 3 4
 5 6 7 8
 9 10 11 12
13 14 15 16

Các mô hình con 3x3 có thể là:

+ ------- + + -------- + 1 2 3 4 1 2 3 4
| 1 2 3 | 4 1 | 2 3 4 | + -------- + + -------- +
| 5 6 7 | 8 5 | 6 7 8 | | 5 6 7 | 8 5 | 6 7 8 |
| 9 10 11 | 12 9 | 10 11 12 | | 9 10 11 | 12 9 | 10 11 12 |
+ ------- + + -------- + | 13 14 15 | 16 13 | 14 15 16 |
13 14 15 16 13 14 15 16 + -------- + + -------- +

Vì vậy, kết quả sẽ là:

[[[1, 2, 3], [5, 6, 7], [9, 10, 11]], [[2, 3, 4], [6, 7, 8], [10, 11, 12]], [[5, 6, 7], [9, 10, 11], [13, 14, 15]], [[6, 7, 8], [10, 11, 12], [14, 15, 16]]]

Như đã lưu ý ở trên, một đầu ra của:

[[[1, 5, 9], [2, 6, 10], [3, 7, 11]], [[2, 6, 10], [3, 7, 11], [4, 8, 12]], [[5, 9, 13], [6, 10, 14], [7, 11, 15]], [[6, 10, 14], [7, 11, 15], [8, 12, 16]]]

cũng sẽ được chấp nhận, nếu bạn chọn trả về các ma trận phụ dưới dạng danh sách các hàng thay thế.

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

Các đầu vào M, n :

[[1,2,3],[5,6,7],[9,10,11]], 1
[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], 3
[[100,-3,4,6],[12,11,14,8],[0,0,9,3],[34,289,-18,3]], 2
[[100,-3,4,6],[12,11,14,8],[9,10,11,12],[13,14,15,16]], 3

Và các đầu ra tương ứng (ma trận phụ được đưa ra dưới dạng danh sách các hàng):

[[[1]],[[2]],[[3]],[[5]],[[6]],[[7]],[[9]],[[10]],[[11]]]
[[[1,2,3],[5,6,7],[9,10,11]],[[2,3,4],[6,7,8],[10,11,12]],[[5,6,7],[9,10,11],[13,14,15]],[[6,7,8],[10,11,12],[14,15,16]]]
[[[100,-3],[12,11]],[[-3,4],[11,14]],[[4,6],[14,8]],[[12,11],[0,0]],[[11,14],[0,9]],[[14,8],[9,3]],[[0,0],[34,289]],[[0,9],[289,-18]],[[9,3],[-18,3]]]
[[[100,-3,4],[12,11,14],[9,10,11]],[[-3,4,6],[11,14,8],[10,11,12]],[[12,11,14],[9,10,11],[13,14,15]],[[11,14,8],[10,11,12],[14,15,16]]]

Hoặc, như danh sách các cột:

[[[1]],[[2]],[[3]],[[5]],[[6]],[[7]],[[9]],[[10]],[[11]]]
[[[1,5,9],[2,6,10],[3,7,11]],[[2,6,10],[3,7,11],[4,8,12]],[[5,9,13],[6,10,14],[7,11,15]],[[6,10,14],[7,11,15],[8,12,16]]]
[[[100,12],[-3,11]],[[-3,11],[4,14]],[[4,14],[6,8]],[[12,0],[11,0]],[[11,0],[14,9]],[[14,9],[8,3]],[[0,34],[0,289]],[[0,289],[9,-18]],[[9,-18],[3,3]]]
[[[100,12,9],[-3,11,10],[4,14,11]],[[-3,11,10],[4,14,11],[6,8,12]],[[12,9,13],[11,10,14],[14,11,15]],[[11,10,14],[14,11,15],[8,12,16]]]]

05AB1E , 8 byte

2FεŒsù}ø

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

Giải trình

2F            # 2 times do:
  ε    }      # apply to each element in the input matrix (initially rows)
   Œsù        # get a list of sublists of size input_2
        ø     # transpose (handling columns on the second pass of the loop)

MATL , 4 byte

thYC

Đầu vào là n, sau đó M.

Đầu ra là một ma trận, trong đó mỗi cột chứa tất cả các cột của một hàm con.

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

Giải trình

thY    % Address the compiler with a formal, slightly old-fashioned determiner
C      % Convert input to ouput

Nghiêm trọng hơn, tlấy đầu vào n một cách giả định và sao chép nó trên ngăn xếp. hnối cả hai bản sao của n , tạo ra mảng [n, n] . YClấy đầu vào M một cách ngầm định, trích xuất tất cả các khối có kích thước [n, n] của nó và sắp xếp chúng thành các cột theo thứ tự chính của cột. Điều này có nghĩa là các cột của mỗi khối được xếp theo chiều dọc để tạo thành một cột duy nhất.

APL (Dyalog Unicode) , 26 byte ^SBCS

Vô danh lambda lấy n làm đối số trái và M làm đối số phải.

{s↓(-s←2⍴⌈¯1+⍺÷2)↓⊢⌺⍺ ⍺⊢⍵}

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

{... } lambda anonymous nơi ⍺là lập luận trái và ⍵là lập luận đúng:

 ⊢⍵ mang lại đối số đúng ( ⊢tách ⍺ ⍺từ ⍵)

 ⊢⌺⍺ ⍺ tất cả các ⍺mô hình ⍺con bao gồm cả các cạnh chồng lên nhau (chúng được đệm bằng số không)

 (... )↓ thả các yếu tố số sau dọc theo hai chiều đầu tiên:

  ⍺÷2 một nửa ⍺

  ¯1+ tiêu cực một cộng với đó

  ⌈ làm tròn lên

  2⍴ tuần hoàn r eshape vào danh sách hai yếu tố

  s← lưu trữ trong s(cho s cứng )

  - phủ định (tức là thả từ phía sau)

 s↓thả scác yếu tố dọc theo kích thước thứ nhất và thứ hai (từ phía trước)

APL (Dyalog Unicode) , 31 byte

{(1↓2 1 3 4⍉⊖)⍣(4×⌊⍺÷2)⊢⌺⍺ ⍺⊢⍵}

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

Một cách tiếp cận khác với Adám.

R , 75 byte

function(M,N,S,W=1:N,g=N:S-N)for(i in g)for(j in g)print(M[i+W,j+W,drop=F])

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

Mất M, Nvà Size của ma trận.

In các ma trận kết quả đến thiết bị xuất chuẩn; drop=Flà cần thiết để trong N=1trường hợp lập chỉ mục không bỏ dimthuộc tính và mang lại một matrixthay vì a vector.

J , 11 8 byte

-3 byte nhờ dặm

<;._3~,~

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

Haskell , 67 byte

m#n|r<-[0..length m-n]=[take n.drop x<$>take n(drop y m)|x<-r,y<-r]

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

Thạch , 5 byte

Z⁹Ƥ⁺€

Sử dụng định dạng đầu ra 4D. Đối với 3D, nối thêm một Ẏcho 6 byte .

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

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

Z⁹Ƥ⁺€  Main link. Left argument: M (matrix). Right argument: n (integer)

 ⁹Ƥ    Apply the link to the left to all infixes of length n.
Z        Zip the rows of the infix, transposing rows and columns.
   ⁺€  Map Z⁹Ƥ over all results.

Brachylog , 13 byte

{tN&s₎\;Ns₎}ᶠ

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

Điều này trả về danh sách các cột.

Về mặt kỹ thuật, tN&s₎\;Ns₎là một vị từ tạo ra hợp nhất đầu ra của nó với bất kỳ mô hình con nào. Chúng tôi {…}ᶠchỉ sử dụng để phơi bày tất cả các khả năng.

Giải trình

 tN&              Call the second argument of the input N
{          }ᶠ     Find all:
    s₎              A substring of the matrix of size N
      \             Transpose that substring
       ;Ns₎         A substring of that transposed substring of size N

Stax , 10 byte

│Æ☼♂Mqß E╖

Chạy nó

Đại diện ascii của cùng một chương trình là

YBFMyBF|PMmJ

Nó hoạt động như thế này.

Y               Store the number in the y register
 B              Batch the grid into y rows each
  F             Foreach batch, run the rest of the program
   M            Transpose about the diagonal
    yB          Batch the transposed slices into y rows each
      F         Foreach batch, run the rest of the progoram
       |P       Print a blank line
         M      Transpose inner slice - restoring its original orientation
          mJ    For each row in the inner grid, output joined by spaces

JavaScript (ES6), 91 byte

Đưa đầu vào theo cú pháp currying (a)(n). Trả về kết quả dưới dạng danh sách các hàng.

a=>n=>(g=x=>a[y+n-1]?[a.slice(y,y+n).map(r=>r.slice(x,x+n)),...g(a[x+n]?x+1:!++y)]:[])(y=0)

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

let f =

a=>n=>(g=x=>a[y+n-1]?[a.slice(y,y+n).map(r=>r.slice(x,x+n)),...g(a[x+n]?x+1:!++y)]:[])(y=0)

;[
  [ [[1,2,3],[5,6,7],[9,10,11]], 1 ],
  [ [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]], 3 ],
  [ [[100,-3,4,6],[12,11,14,8],[0,0,9,3],[34,289,-18,3]], 2 ],
  [ [[100,-3,4,6],[12,11,14,8],[9,10,11,12],[13,14,15,16]], 3]
]
.forEach(([m, a]) => console.log(JSON.stringify(f(m)(a))))

APL (Dyalog Classic) , 24 23 byte

t∘↑¨(¯1-t←-2⍴⎕)↓,⍀⍪\⍪¨⎕

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

kết quả là một ma trận ma trận, mặc dù định dạng đầu ra của Dyalog không làm cho điều đó trở nên rất rõ ràng

nhập ma trận ( ⎕), biến mỗi phần tử thành ma trận lồng nhau của chính nó ( ⍪¨), lấy các tiền tố nối theo hàng ( ,\) và theo cột ( ⍪⍀), đầu vào n (⎕ ), thả các hàng n-1 đầu tiên và các cột của ma trận lồng nhau ( (¯1-t←-2⍴⎕)↓), lấy góc n-by-n dưới cùng bên phải từ mỗi ma trận ( t∘↑¨)

                                        ┌─┬──┬───┐
                                        │a│ab│abc│      ┼──┼───┤        ┼──┼───┤
 n=2       ┌─┬─┬─┐      ┌─┬──┬───┐      ├─┼──┼───┤      │ab│abc│        │ab│ bc│
┌───┐      │a│b│c│      │a│ab│bac│      │a│ab│abc│      │de│def│        │de│ ef│
│abc│  ⍪¨  ├─┼─┼─┤  ,\  ├─┼──┼───┤  ⍪⍀  │d│de│def│ 1 1↓ ┼──┼───┤¯2 ¯2∘↑¨┼──┼───┤
│def│ ---> │d│e│f│ ---> │d│de│edf│ ---> ├─┼──┼───┤ ---> │ab│abc│  --->  │  │   │
│ghi│      ├─┼─┼─┤      ├─┼──┼───┤      │a│ab│abc│      │de│def│        │de│ ef│
└───┘      │g│h│i│      │g│gh│hgi│      │d│de│def│      │gh│ghi│        │gh│ hi│
           └─┴─┴─┘      └─┴──┴───┘      │g│gh│ghi│      ┴──┴───┘        ┴──┴───┘
                                        └─┴──┴───┘

Hồng ngọc , 63 byte

->c,g{n=c.size-g+1
(0...n*n).map{|i|c[i/n,g].map{|z|z[i%n,g]}}}

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

Đây là một lambda lấy một mảng 2D và int, trả về một mảng 3D.

Ung dung:

->m,n{
  a = m.size - n + 1     # The count of rows in m that can be a first row in a submatrix
  (0...a*a).map{ |b|     # There will be a*a submatrices
    m[b/a,n].map{ |r|    # Take each possible set of n rows
      r[b%a,n]           # And each possible set of n columns
    }
  }
}

Python 2 , 91 byte

lambda a,n:(lambda R:[[r[i:i+n]for r in a[j:j+n]]for i in R for j in R])(range(len(a)+1-n))

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