La sfida

Data una griglia di numeri (10 <= N <= 99) Restituisce il numero con la somma più alta dei quattro numeri adiacenti; cioè i numeri sopra, sotto, a destra e a sinistra del numero, ma non se stesso.

1. Il numero stesso non conta, solo i suoi quattro vicini.
2. Un numero sul bordo deve essere trattato come se il numero mancante fosse uno 0.
3. Progetterò il test per evitare legami.
4. I numeri non si ripeteranno.
5. Questo è code-golf .

Esempio

Dato

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

Ritorno

18

Un vero test

Dato

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

Ritorno

13

Dato

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

Ritorno

15

MATL , 20 15 13 12 byte

t1Y6Z+tuX>=)

Salvato 5 byte grazie a Emigna, 2 grazie a Giuseppe e un altro grazie a Luis Mendo.
Provalo online!

Spiegazione

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 byte ^SBCS

-2 grazie al ciarlatano Cows. -1 grazie a ngn.

Funzione prefisso tacito anonimo. Prende una matrice come argomento. Assume ⎕IO( I NDICE O RIGIN) di essere 0, che è di default su molti sistemi.

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

Provalo online!

, ravel (appiattire) l'ingresso

{... }⊃ scegli un elemento da quello in base al risultato della seguente funzione:

 ⊢⍵ cedere l'argomento (separa 3 3da ⍵)

 ... ⌺3 3 applica la seguente funzione a ciascun quartiere 3 per 3:

  ⊢∘, ignorare le informazioni sui bordi a favore del quartiere devastato (appiattito)

  (... ) applica la seguente funzione tacita a quelle

   -/ la somma alternata (lett. riduzione associativa destra meno)

   +/- sottrai quello dalla somma (questo dà la somma di ogni altro elemento)

 , ravel (appiattire) che (il quartiere somma)

 ⍒ produrre gli indici che lo ordinerebbero

 ⊃ scegli il primo (ovvero l'indice della somma più alta)

Gelatina , 22 byte

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

Provalo online!

Non avere incorporazioni di convoluzione come MATL e Dyalog Dimenticare la tua lingua ha degli incorporamenti di convoluzione (grazie @dylnan), ma possiamo fare un po 'di bene senza di loro, in parte grazie a ŒMe œị. Innanzitutto, una funzione di supporto per calcolare i vicini in una sola direzione, che traspone accidentalmente l'input:

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

Visivamente, il calcolo è:

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

Interpretazione: la cella (x, y) di questo risultato è la somma dei vicini orizzontali della cella (y, x). (Ad esempio, qui vediamo che f (A) [2,3] = 16 = 7 + 9 = A [3,1] + A [3,3] .)

Quindi, la funzione principale:

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

Gelatina , 18 byte

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

Provalo online!

La funzione helper trova i vicini di ciascun elemento in ogni riga. La funzione principale fa questo alle righe e alle colonne quindi trova l'elemento che ha la somma massima del vicinato.

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 byte

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

Provalo online!

Python 2 , 127 byte

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

Provalo online!

Stencil , 1 + 10 = 11 byte (non concorrenti)

Opzione da riga di comando:  1 calcolare 1 generazione

y⊃⍨⊃⍒,
+/N

Provalo online!

y dall'ingresso originale appiattito
⊃⍨ selezionare
⊃ il primo
⍒ in ordine decrescente
, dell'appiattito

+/ somme dei
N quartieri di von neumanN senza sé

JavaScript (ES6), 94 byte

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

Provalo online!

Come?

Invece di cercare il massimo della somma dei 4 vicini di casa, si cerca la minima m della somma s della loro one-complementi. Questo ci consente di elaborare valori indefiniti proprio come gli zeri, perché:

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

La mappa interna () è scritta in modo tale da non alterare il contenuto della riga r . Pertanto, possiamo salvare il suo risultato in p per testare i migliori vicini nella prossima iterazione.

Noi usiamo:

• ~r[x-1] per la cella sinistra
• ~r[x+1] per la cella giusta
• ~p[x] per la cella superiore
• ~(a[y+1]||0)[x] per la cella inferiore

K (ngn / k) , 43 40 byte

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

Provalo online!

Java 8, 187 byte

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;}

Provalo online.

Spiegazione:

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 byte

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}