Соревнование

Учитывая сетку чисел (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>=)

Сэкономили 5 байтов благодаря Emigna, 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 благодаря нгн.

Функция анонимного молчаливого префикса. Принимает матрицу в качестве аргумента. Предполагается ⎕IO( я ndex O rigin) 0, что по умолчанию на многих системах.

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

Попробуйте онлайн!

, выровнять вход

{... }⊃ выбрать элемент из этого согласно результату следующей функции:

 ⊢⍵ привести аргумент (отделяется 3 3от ⍵)

 … ⌺3 3 Примените следующую функцию к каждому соседству 3 на 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œị

Попробуйте онлайн!

Вспомогательная функция находит соседей каждого элемента в каждой строке. Основная функция делает это со строками, а затем столбцы находят элемент с максимальной суммой окрестности.

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 Language (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 окрестностей фон Неймана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

Попробуйте онлайн!

Как?

Вместо того, чтобы искать максимум суммы четырех соседей, мы ищем минимум m суммы s их одного дополнения. Это позволяет нам обрабатывать неопределенные значения как нули, потому что:

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

Внутренняя карта () написана таким образом, что она не изменяет содержимое строки r . Следовательно, мы можем сохранить его результат в p , чтобы проверить соседей в следующей итерации.

Мы используем:

• ~r[x-1] для левой клетки
• ~r[x+1] для правой клетки
• ~p[x] для верхней ячейки
• ~(a[y+1]||0)[x] для нижней клетки

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}