Bạn được cung cấp một ma trận n-by-m các số nguyên, trong đó n, m> 3 . Nhiệm vụ của bạn là tìm ma trận con 3 nhân 3 có giá trị trung bình thấp nhất và xuất giá trị này.

Các quy tắc và làm rõ:

• Các số nguyên sẽ không âm
• Tùy chọn định dạng đầu vào và đầu ra
• Đầu ra phải chính xác tối đa 2 poins thập phân (nếu không phải là số nguyên)
• Các mô hình con phải được tạo thành từ các hàng và cột liên tiếp

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

35    1    6   26   19   24
 3   32    7   21   23   25
31    9    2   22   27   20
 8   28   33   17   10   15
30    5   34   12   14   16
 4   36   29   13   18   11 

Minimum mean: 14

100    65     2    93
  3    11    31    89
 93    15    95    65
 77    96    72    34

Minimum mean: 46.111

1   1   1   1   1   1   1   1
1   1   1   1   1   1   1   1
1   1   1   1   1   1   1   1
1   1   1   1   1   1   1   1

Minimum mean: 1

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

Minimum mean: 2.2222

Đây là môn đánh gôn, vì vậy mã ngắn nhất trong mỗi ngôn ngữ sẽ thắng. Tôi khuyến khích mọi người đăng câu trả lời bằng các ngôn ngữ đã được sử dụng, ngay cả khi nó không ngắn hơn câu đầu tiên.

Octave, 30 byte

@(A)min(mean(im2col(A,[3,3])))

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

Thạch , 11 9 byte

+3\⁺€F÷9Ṃ

Đã lưu 2 byte nhờ @ Dennis .

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

Giải trình

+3\⁺€F÷9Ṃ  Main link. Input: 2d matrix
+3\        Reduce overlapping sublists of size 3 by addition
   ⁺€      Repeat previous except over each row
     F     Flatten
      ÷9   Divide by 9
        Ṃ  Minimum

Octave, 38 byte

@(M)min(conv2(M,ones(3)/9,'valid')(:))

MATL , 13 9 byte

3thYCYmX<

Câu trả lời của cảng @ rahnema1 .

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

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

Xem xét đầu vào

[100 65  2 93;
   3 11 31 89;
  93 15 95 65;
  77 96 72 34]

làm ví dụ

3th   % Push [3 3]
      % STACK: [3 3]
YC    % Input matrix implicitly. Convert 3x3 sliding blocks into columns
      % STACK: [100   3  65  11;
                  3  93  11  15;
                 93  77  15  96;
                 65  11   2  31;
                 11  15  31  95;
                 15  96  95  72;
                  2  31  93  89;
                 31  95  89  65;
                 95  72  65  34]
Ym    % Mean of each column
      % STACK: [46.1111 54.7778 51.7778 56.4444]
X<    % Minimum of vector. Display implicitly
      % STACK: [46.1111]

Toán học, 37 35 byte

Cảm ơn @MartinEnder cho 2 byte!

Min@BlockMap[Mean@*Mean,#,{3,3},1]&

Giải trình

Min@BlockMap[Mean@*Mean,#,{3,3},1]&
    BlockMap[                    ]&  (* BlockMap function *)
                        #            (* Divide the input *)
                          {3,3}      (* Into 3x3 matrices *)
                                1    (* With offset 1 *)
             Mean@*Mean              (* And apply the Mean function twice to
                                        each submatrix *)
Min                                  (* Find the minimum value *)

Python 2 , 93 81 80 79 byte

f=lambda M:M[2:]and min(sum(sum(zip(*M[:3])[:3],()))/9,f(M[1:]),f(zip(*M)[1:]))

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

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

f là một hàm đệ quy lấy danh sách các bộ dữ liệu (hoặc bất kỳ phép lặp 2D có thể lập chỉ mục nào khác đại diện cho ma trận M ) và tính toán đệ quy mức tối thiểu của trung bình của hàm con 3 × 3 ở góc trên bên trái và f được áp dụng đệ quy cho M mà không hàng đầu tiên của nó và M không có cột đầu tiên.

f(M) làm như sau.

• Nếu M có ít hơn ba hàng, M[2:]là một danh sách trống, mà f trả về.

  Lưu ý rằng, vì n> 3 trong lần chạy đầu tiên, ban đầu không thể trả về một danh sách trống.

• Nếu M có ba hàng trở lên, M[2:]không trống và do đó là trung thực, do đó mã ở bên phải andđược thực thi, trả về mức tối thiểu của ba giá trị sau.

  min(sum(sum(zip(*M[:3])[:3],()))/9

  M[:3]mang lại ba hàng đầu tiên của M , zip(*...)chuyển đổi các hàng và cột (thu được một danh sách các bộ dữ liệu), sum(...,())nối tất cả các bộ dữ liệu (công việc +này là do ghép) và sum(...)/9tính giá trị trung bình của danh sách kết quả gồm chín số nguyên.

  f(M[1:])

  đệ quy áp dụng f cho M với hàng đầu tiên được loại bỏ.

  f(zip(*M)[1:])

  hoán chuyển các hàng và cột, loại bỏ hàng đầu tiên của kết quả (vì vậy cột đầu tiên của M và áp dụng đệ quy f cho kết quả.

Lưu ý rằng lớp bị loại bỏ trước đó trong một cuộc gọi đệ quy sẽ luôn là một hàng, vì vậy kiểm tra nếu M có đủ hàng sẽ luôn luôn đủ ..

Cuối cùng, người ta có thể mong đợi rằng một số cuộc gọi đệ quy trở lại []sẽ là một vấn đề. Tuy nhiên, trong Python 2 , bất cứ khi nào n là số và A là số lặp, phép so sánh n < Atrả về True , do đó, tính toán tối thiểu một hoặc nhiều số và một hoặc nhiều số lần lặp sẽ luôn trả về số thấp nhất.

J , 21 byte

[:<./@,9%~3+/\3+/\"1]

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

Cách thích hợp để vận hành trên các phân đoạn trong J là sử dụng _3hình thức cắt thứ ba ( ) trong ;.đó x (u;._3) ycó nghĩa là áp dụng động từ utrên mỗi phân đoạn đầy đủ về kích thước xcủa mảng y. Một giải pháp sử dụng chỉ cần thêm 1 byte nhưng sẽ hiệu quả hơn nhiều trên các mảng lớn hơn.

[:<./@,9%~3 3+/@,;._3]

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

Giải trình

[:<./@,9%~3+/\3+/\"1]  Input: 2d array M
                    ]  Identity. Get M
                  "1   For each row
              3  \       For each overlapping sublist of size 3
               +/          Reduce by addition
          3  \         For each overlapping 2d array of height 3
           +/            Reduce by addition
       9%~             Divide by 9
[:    ,                Flatten it
  <./@                 Reduce by minimum

Thạch , 18 byte

Bỏ lỡ lừa, như được sử dụng bởi dặm trong họ câu trả lời , của việc sử dụng một n-khôn ngoan tích lũy giảm bổ sung - toàn bộ dòng đầu tiên có thể được thay thế bằng +3\11.

ẆµL=3µÐfS€
ÇÇ€FṂ÷9

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

Di chuyển tất cả các danh sách con liền kề, các bộ lọc để chỉ giữ các độ dài 3 và tổng (vectơ) sau đó lặp lại cho mỗi danh sách kết quả, để lấy tổng của cả 3 ma trận phụ và cuối cùng làm phẳng chúng thành một danh sách, lấy tối thiểu và chia cho 9 (số phần tử tạo ra tổng tối thiểu này).

Bình thường, 19 byte

chSsMsMs.:R3C.:R3Q9

Một chương trình lấy đầu vào của danh sách các danh sách và in kết quả.

Bộ kiểm tra

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

[Giải thích đến sau]

Python 3 , 111 103 byte

lambda m,r=range:min(sum(sum(m[y+i][x:x+3])for i in r(3))/9for x in r(len(m[0])-3)for y in r(len(m)-3))

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

Python 2, 96 byte

h=lambda a:[map(sum,zip(*s))for s in zip(a,a[1:],a[2:])]
lambda a:min(map(min,h(zip(*h(a)))))/9.

Các trường hợp thử nghiệm tại Altern.it

Một hàm không tên lấy danh sách các danh sách, a- các hàng của ma trận.

Hàm trợ giúp hkéo qua ba lát liền kề và ánh xạ hàm tổng qua chuyển vị zip(*s), của từng lát . Điều này dẫn đến việc tổng hợp tất cả ba chiều cao của các cột đơn.

Hàm không tên gọi hàm helper, hoán vị và gọi lại hàm helper trên kết quả, sau đó tìm mức tối thiểu của mỗi và mức tối thiểu của kết quả, sau đó nó sẽ chia 9.cho mức trung bình.

JavaScript (ES6), 107 98 96 byte

Một hàm tính tổng các bộ ba trên các hàng và sau đó tự gọi nó để làm điều tương tự trên các cột, theo dõi giá trị tối thiểu M.

f=m=>m.map((r,y)=>r.map((v,x)=>M=(z[x<<9|y]=v+=r[x+1]+r[x+2])<M?v:M),z=[M=1/0])&&m[1]?f([z]):M/9

JS là một chút dài dòng cho loại công cụ đó và thiếu một zip()phương thức riêng. Tôi đã mất khá nhiều thời gian để tiết kiệm chỉ một tá byte theo cách tiếp cận ngây thơ hơn. (Tuy nhiên, một phương pháp ngắn hơn có thể tồn tại.)

Phiên bản không đệ quy, 103 byte

Đã lưu 2 byte với sự trợ giúp của Neil

m=>m.map((r,y)=>y>1?r.map((v,x)=>[..."12345678"].map(i=>v+=m[y-i%3][x+i/3|0])&&(M=v<M?v:M)):M=1/0)&&M/9

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

f=m=>m.map((r,y)=>r.map((v,x)=>M=(z[x<<9|y]=v+=r[x+1]+r[x+2])<M?v:M),z=[M=1/0])&&m[1]?f([z]):M/9

console.log(f([
  [ 35,  1,  6, 26, 19, 24 ],
  [  3, 32,  7, 21, 23, 25 ],
  [ 31,  9,  2, 22, 27, 20 ],
  [  8, 28, 33, 17, 10, 15 ],
  [ 30,  5, 34, 12, 14, 16 ],
  [  4, 36, 29, 13, 18, 11 ]
]));

console.log(f([
  [ 100, 65,  2, 93 ],
  [   3, 11, 31, 89 ],
  [  93, 15, 95, 65 ],
  [  77, 96, 72, 34 ]
]));

console.log(f([
  [ 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 1, 1, 1, 1, 1, 1, 1, 1 ],
  [ 1, 1, 1, 1, 1, 1, 1, 1 ]
]));

console.log(f([
  [ 4, 0, 0, 5, 4 ],
  [ 4, 5, 8, 4, 1 ],
  [ 1, 4, 9, 3, 1 ],
  [ 0, 0, 1, 3, 9 ],
  [ 0, 3, 2, 4, 8 ],
  [ 4, 9, 5, 9, 6 ],
  [ 1, 8, 7, 2, 7 ],
  [ 2, 1, 3, 7, 9 ]
]));

05AB1E , 21 16 byte

2FvyŒ3ùO})ø}˜9/W

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

Giải trình

2F         }       # 2 times do:
  v     }          # for each row in the matrix
   yŒ3ù            # get all sublists of size 3
       O           # reduce by addition
         )ø        # transpose matrix
            ˜      # flatten the matrix to a list
             9/    # divide each by 9
               W   # get the minimum

Haskell , 87 byte

import Data.List
t(a:b:c:d)=a+b+c:t(b:c:d);t _=[]
s=(/9).minimum.(t=<<).transpose.map t

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