Sie erhalten eine n-mal-m- Matrix von ganzen Zahlen, wobei n, m> 3 ist . Ihre Aufgabe ist es, die 3-mal-3 -Submatrix mit dem niedrigsten Mittelwert zu finden und diesen Wert auszugeben.

Regeln und Erläuterungen:

• Die ganzen Zahlen sind nicht negativ
• Optionales Eingabe- und Ausgabeformat
• Die Ausgabe muss bis auf mindestens 2 Dezimalpunkte genau sein (wenn es sich um eine nicht ganzzahlige Zahl handelt)
• Die Submatrizen müssen aus aufeinanderfolgenden Zeilen und Spalten bestehen

Testfälle:

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

Das ist Code-Golf, also gewinnt der kürzeste Code in jeder Sprache. Ich ermutige die Leute, Antworten in Sprachen zu posten, die bereits verwendet werden, auch wenn sie nicht kürzer als die erste sind.

Oktave, 30 Bytes

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

Probieren Sie es online!

Jelly , 11 9 Bytes

+3\⁺€F÷9Ṃ

2 Bytes gespart dank @ Dennis .

Probieren Sie es online!

Erläuterung

+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

Oktave, 38 Bytes

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

MATL , 13 9 Bytes

3thYCYmX<

Port von @ rahnema1's Antwort .

Probieren Sie es online!

Wie es funktioniert

Betrachten Sie die Eingabe

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

als Beispiel.

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]

Mathematica, 37-35 Bytes

Danke @MartinEnder für 2 Bytes!

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

Erläuterung

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 Bytes

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

Probieren Sie es online!

Wie es funktioniert

f ist eine rekursive Funktion, die eine Liste von Tupeln (oder jede andere indizierbare 2D-Iteration, die eine Matrix M darstellt ) verwendet und rekursiv das Minimum des Mittelwerts der 3 × 3- Submatrix in der oberen linken Ecke berechnet und f ohne rekursiv auf M angewendet seine erste Zeile und M ohne seine erste Spalte.

f(M) macht das Folgende.

• Wenn M weniger als drei Zeilen hat, M[2:]ist dies eine leere Liste, die f zurückgibt.

  Beachten Sie, dass die Initiale keine leere Liste zurückgeben kann , da n> 3 in der ersten Ausführung ist.

• Wenn M drei oder mehr Zeilen hat, M[2:]nicht leer und daher wahr ist, wird der Code rechts von andausgeführt und gibt das Minimum der drei folgenden Werte zurück.

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

  M[:3]ergibt die ersten drei Zeilen von M , zip(*...)transponiert Zeilen und Spalten (ergibt eine Liste von Tupeln), sum(...,())verkettet alle Tupel (dies funktioniert, weil +es sich um Verkettung handelt) und sum(...)/9berechnet den Mittelwert der resultierenden Liste von neun ganzen Zahlen.

  f(M[1:])

  wendet rekursiv f auf M an, wobei die erste Zeile entfernt wird.

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

  transponiert Zeilen und Spalten, entfernt die erste Zeile des Ergebnisses (also die erste Spalte von M ) und wendet rekursiv f auf das Ergebnis an.

Beachten Sie, dass die zuvor entfernte Ebene in einem rekursiven Aufruf immer eine Zeile ist. Daher ist es immer ausreichend zu testen, ob M über genügend Zeilen verfügt.

Schließlich ist zu erwarten, dass einige rekursive Aufrufe, die zurückkehren [], ein Problem darstellen. In Python 2 gibt der Vergleich jedoch immer dann, wenn n eine Zahl und A eine iterable Zahl ist, Truen < A zurück. Wenn Sie also mindestens eine Zahl und mindestens eine iterable Zahl berechnen, wird immer die niedrigste Zahl zurückgegeben.

J , 21 Bytes

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

Probieren Sie es online!

Der richtige Weg , auf Subarrays in J zu betreiben ist , um die dritte (um _3) Form geschnitten , ;.wo x (u;._3) yMittel Verb anzuwenden uauf jeder vollen Subarray der Größe xdes Arrays y. Eine Lösung, die dies verwendet, benötigt nur 1 Byte mehr, ist jedoch auf größeren Arrays viel effizienter.

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

Probieren Sie es online!

Erläuterung

[:<./@,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

Gelee , 18 Bytes

Verpasste den von Meilen in ihrer Antwort verwendeten Trick, eine n-weise kumulative Additionsreduktion zu verwenden - die gesamte erste Zeile kann durch +3\11 ersetzt werden.

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

Probieren Sie es online!

Durchläuft alle zusammenhängenden Unterlisten, filtert, um nur diejenigen mit der Länge 3 und Summen (die vektorisieren) beizubehalten, und wiederholt sich dann für jede resultierende Liste, um die Summen aller 3 × 3-Untermatrizen zu erhalten und diese schließlich zu einer Liste zusammenzufassen, nimmt das Minimum und dividiert durch 9 (die Anzahl der Elemente, aus denen diese minimale Summe besteht).

Pyth, 19 Bytes

chSsMsMs.:R3C.:R3Q9

Ein Programm, das eine Liste von Listen eingibt und das Ergebnis druckt.

Testsuite

Wie es funktioniert

[Erklärung kommt später]

Python 3 , 111 103 Bytes

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

Probieren Sie es online!

Python 2, 96 Bytes

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.

Testfälle bei Repl.it

Eine unbenannte Funktion, die eine Liste von Listen erstellt, a - die Zeilen der Matrix.

Die Hilfsfunktion hblättert durch drei benachbarte Slices und ordnet die Summenfunktion der Transponierten zu zip(*s). Dies führt dazu, dass alle Höhen von drei Scheiben einzelner Spalten summiert werden.

Die unbenannte Funktion ruft die Hilfsfunktion auf, transponiert und ruft die Hilfsfunktion erneut für das Ergebnis auf und ermittelt dann das Minimum von jedem und das Minimum des Ergebnisses, durch das sie dann dividiert 9., um den Durchschnitt zu erhalten.

JavaScript (ES6), 107 98 96 Bytes

Eine Funktion, die die Triplettsummen über die Zeilen berechnet und sich dann dazu aufruft, dasselbe über die Spalten zu tun und dabei den Minimalwert zu verfolgen 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 ist ein bisschen wortreich für solche Sachen und es fehlt ein Eingeborener zip() Methode. Ich habe ziemlich viel Zeit gebraucht, um nur ein Dutzend Bytes gegenüber einem naiveren Ansatz zu sparen. (Möglicherweise gibt es jedoch eine kürzere Methode.)

Nicht rekursive Version, 103 Bytes

2 Bytes mit Hilfe von Neil gespeichert

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

Testfälle

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 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online!