挑战

给定一个数字网格（10 <= N <= 99）返回的数字具有与其相邻的四个数字中的最高和；就是数字的上方，下方，右侧和左侧，但本身不是。

1. 这个数字本身不算，只有四个邻居。
2. 边缘的数字应被视为丢失的数字为0。
3. 我将设计测试以避免联系。
4. 数字不会重复。
5. 这是代码高尔夫球。

例

给定

56 98 32 96
12 64 45 31
94 18 83 71

返回

18

真实的测试

给定

98 95 67 66 57 16 40 94 84 37
87 14 19 34 83 99 97 78 50 36
18 44 29 47 21 86 24 15 91 61
60 41 51 26 10 58 11 62 55 71
42 85 56 12 46 81 93 65 49 77
89 13 74 39 54 76 92 33 82 90
96 88 70 79 80 28 25 20 75 68
38 63 17 72 53 48 73 30 45 69
64 35 32 31 23 43 22 52 27 59

返回

13

给定

82 43 79 81 94 36 17 64 58
24 52 13 87 70 18 28 61 69
16 99 75 21 50 44 89 90 51
49 80 63 31 54 65 41 55 38
67 91 76 78 23 86 83 14 73
46 68 62 77 34 48 20 74 10
33 35 26 97 59 66 25 37 32
12 92 84 27 85 56 22 40 45
96 15 98 53 39 30 88 71 29
60 42 11 57 95 19 93 72 47

返回

15

MATL，20 15 13 12字节

t1Y6Z+tuX>=)

Emigna节省了5个字节，Giuseppe节省了2个字节，Luis Mendo节省了2个字节。
在线尝试！

说明

t1Y6Z+tuX>=)
t                  Duplicate the (implicit) input.
 1Y6               Push the array [0 1 0; 1 0 1; 0 1 0].
    Z+             Convolve with the input.
       uX>         Get the maximum unique element...
      t   =        ... and compare elementwise.
           )       Index into the input.

APL（Dyalog Unicode），31 27 26 24 23 字节^SBCS

-2多亏了母牛嘎嘎声。-1感谢ngn。

匿名默认前缀功能。以矩阵作为参数。假设⎕IO（I ndex O rigin）为0，这在许多系统上都是默认设置。

{⊃⍒,(+/--/)⊢∘,⌺3 3⊢⍵}⊃,

在线尝试！

, 拉平（平整）输入

{… }⊃ 根据以下功能的结果从中选择一个元素：

 ⊢⍵ 得到的参数（分离3 3自⍵）

 … ⌺3 3 对每个3 x 3邻域应用以下功能：

  ⊢∘, 忽略边缘信息，而支持倾斜的（展平的）邻域

  (…… ) 对那些人应用以下默认功能

   -/ 交替总和（点燃的右联想减减）

   +/- 从总和中减去（得出所有其他元素的总和）

 , （邻域相加）

 ⍒ 产生将排序的索引

 ⊃ 选择第一个（即最高总和的索引）

果冻，22字节

;€0ZṙØ+SṖ
,ZÇ€Z+$/ŒMœị

在线尝试！

没有回旋的内置插件一样MATL和Dyalog 遗忘你的语言有回旋的内置插件（谢谢@dylnan）很痛，但我们可以排序的还好没有他们，这得感谢ŒM和œị。首先，一个辅助函数仅在一个方向上计算邻居，这会顺便转置输入：

;€0Z         Append a zero to each row, then transpose.
    ṙØ+S     Rotate by +1 and −1 (Ø+ = [1,-1]) and sum these.
        Ṗ    Pop the last row.

在视觉上，计算为：

1 2 3   ;€0   1 2 3 0   Z   1 4 7   ṙØ+     2 5 8   0 0 0     S   2  5  8   Ṗ   2  5  8
4 5 6  ————→  4 5 6 0  ——→  2 5 8  ————→  [ 3 6 9 , 1 4 7 ]  ——→  4 10 16  ——→  4 10 16
7 8 9         7 8 9 0       3 6 9           0 0 0   2 5 8         2  5  8       2  5  8
                            0 0 0           1 4 7   3 6 9         4 10 16

解释：该结果的像元（x，y）是像元（y，x）的水平邻居之和。（例如，在这里我们看到f（A）[2,3] = 16 = 7 + 9 = A [3,1] + A [3,3]。）

然后，主要功能：

,ZÇ€            Pair the input with its transpose and apply helper to both.
    Z+$/        Fold by Z+, i.e., turn [X,Y] into transpose(X)+Y.
                Now we've summed the horizontal and vertical neighbors for each cell.
        ŒM      Find the 2D index of the maximal value.
          œị    2D-index (into the original input).

果冻，18字节

5BæcµḊṖ)
ZÇZ+ÇŒMœị

在线尝试！

helper函数在每一行中查找每个元素的邻居。main函数对行和列执行此操作，然后找到具有最大邻域和的元素。

5BæcµḊṖ)
5B           bin(5): 1,0,1
  æc         Convolve with [[1,2,9],[other rows]] (for example): [[1,2,10,2,9],...]
    µ        New chain.
       )     Apply this to each element:
     Ḋ       Remove the first element.
      Ṗ      Remove the last element.
             Gives [[2,10,2],...]

ZÇZ+ÇŒMœị   
Z            Zip the matrix
 Ç           Apply helper function
  Z          Zip again. Yields the sum of the vertical neighbors of each element.
   +         Add:
    Ç        The sum of each element's horizontal neighbors.
     ŒM      Find the multidimensional index of the maximal element.
       œị    Index back into the original matrix.

Wolfram语言（Mathematica），58个字节

Im@Last[Union@@ListConvolve[{a={0,1,0},{1,I,1},a},#,2,0]]&

$\left( \begin{smallmatrix} 0 & 1 & 0 \\ 1 & i & 1 \\ 0 & 1 & 0 \end{smallmatrix} \right)$

在线尝试！

Python 2，127个字节

def f(a):n=len(a[0]);b=sum(a,[])+[0]*n;print b[max(range(len(b)-n),key=lambda i:b[i-1]*(i%n>0)+b[i+1]*(i%n<n-1)+b[i-n]+b[i+n])]

在线尝试！

模具，1 + 10 = 11字节（非竞争）

命令行选项：  1 计算1代

y⊃⍨⊃⍒,
+/N

在线尝试！

y 从拼合的原始输入 中，按 拼合的降序
⊃⍨ 选择
⊃ 第一个
⍒
,

+/ 之和
N 冯·诺伊曼的街区没有自我

JavaScript（ES6），94个字节

a=>a.map(p=m=(r,y)=>p=r.map((v,x)=>(s=~r[x-1]+~p[x]+~(a[y+1]||0)[x]+~r[x+1])>m?v:(m=s,o=v)))|o

在线尝试！

怎么样？

我们没有寻找4个邻居之和的最大值，而是寻找了它们的一补数之和的最小值m。这使我们能够像处理零一样处理未定义的值，因为：

~undefined === -1
~0 === -1

内部map（）的编写方式不会改变行r的内容。因此，我们可以将其结果保存在p中，以便在下一次迭代中测试顶部邻居。

我们用：

• ~r[x-1] 对于左单元格
• ~r[x+1] 对于正确的单元格
• ~p[x] 对于顶部的单元格
• ~(a[y+1]||0)[x] 对于底部单元格

K（ngn / k），43 40字节

{(,/x)@*>,/(+g@+x)+(g:{(+':x)-|-':|x})x}

在线尝试！

Java 8，187字节

m->{int r=0,l=m.length,i=l,L,j,S=0,s;for(;i-->0;)for(L=j=m[i].length;j-->0;)if((s=(i<1?0:m[i-1][j])+(i<l-1?m[i+1][j]:0)+(j<1?0:m[i][j-1])+(j<L-1?m[i][j+1]:0))>S){S=s;r=m[i][j];}return r;}

在线尝试。

说明：

m->{                           // Method with integer-matrix parameter and integer return
  int r=0,                     //  Result-integer, starting at 0
      l=m.length,              //  Amount of rows
      i=l,                     //  Rows index integer
      L,                       //  Amount of columns
      j,                       //  Column index integer
      S=0,                     //  Largest sum of four cells
      s;                       //  Current sum of four cells
  for(;i-->0;)                 //  Loop over the rows
    for(L=j=m[i].length;j-->0;)//   Inner loop over the columns
      if((s=                   //    Set the current sum to: the sum of:
           (i<1?0:m[i-1][j])   //     Value of the cell to the left, or 0 if out of bounds
          +(i<l-1?m[i+1][j]:0) //     Value of the cell to the right, or 0 if out of bounds
          +(j<1?0:m[i][j-1])   //     Value of the cell down, or 0 if out of bounds
          +(j<L-1?m[i][j+1]:0))//     Value of the cell up, or 0 if out of bounds
         >S){                  //    If this current sum is larger than the largest sum:
        S=s;                   //     Replace the largest sum with this current sum
        r=m[i][j];}            //     And set the result to the current cell
  return r;}                   //  Return the result

Javascript ES6，170个字节

c=g=>{s=0;n=0;f=m=>m||[];for(i=0;i<g.length;i++)for(j=0;j<g[i].length;j++){s=~~f(g[i-1])[j]+~~f(g[i+1])[j]+~~f(g[i])[j-1]+~~f(g[i])[j+1];b=s>n?g[i][j]+!(n=s):b;}return b}