Scrivi un programma o una funzione in cui una matrice A (il valore massimo delle dimensioni della matrice è 100) viene trasformata in una nuova matrice B. Ogni elemento della nuova matrice B è la somma dei vicini positivi dell'elemento corrispondente della matrice A .

Vengono considerati solo i vicini nelle quattro direzioni ortogonali e i bordi non si avvolgono.

Esempio di input:

 1  2  3
 4 -1 -2
-3 -4 10
 1  2 10

Produzione:

 6  4  2
 1  6 13
 5 12 10
 2 11 12

Regole:

• Come input utilizzare numeri interi.
• Questo è un codice-golf , quindi vince il codice più breve in byte.

MATL , 9 byte

t0>*1Y6Z+

Provalo online!

Spiegazione

La matrice di input viene moltiplicata da una maschera appropriata per rendere i valori negativi pari a 0. Quindi viene applicata una convoluzione 2D per calcolare la somma dei vicini di ciascuna voce.

t     % Take input implicitly: 2D array. Duplicate
0>    % Is each entry positive? This gives a mask of positive values
*     % Multiply: set negative values of input array to zero
1Y6   % Predefined literal: [0 1 0; 1 0 1; 0 1 0]
Z+    % 2D convolution preserving size. Implicitly display

Ottava, 46 44 40 byte

Salvato 2 byte grazie al kernel di @flawr
@ LuisMendo era 4 byte più corto di quello di @ flawr.

@(M)conv2(M.*(M>0),(x='aba')~=x','same')

Proprio come la risposta di @ LuisMendo ! Solo meno ... golfy.

Puoi vederlo qui su ideone .

JavaScript (ES6), 99 94 byte

a=>a.map((b,i)=>b.map((_,j)=>(g=(c=j,k=j)=>c[k]>0&&c[k])(a[i-1])+g(a[i+1])+g(b,j-1)+g(b,j+1)))

Accetta e restituisce un array bidimensionale.

Modifica: completamente riscritto quando ho scoperto che gli argomenti predefiniti funzionano quando si passa un valore esplicitamente indefinito, come quando si indicizza la fine di un array.

JavaScript (ES6), 95 93 byte

document.write("<pre>"+(

m=>m.map((a,r)=>a.map((_,c)=>(s=(x,y=0)=>(n=(m[r+y]||0)[c+x])>0&&n)(1)+s(-1)+s(0,1)+s(0,-1)))

)([[  1,  2,  3 ],
   [  4, -1, -2 ],
   [ -3, -4, 10 ],
   [  1,  2, 10 ]])

.join`\n`)

Python con SciPy, 127 byte

from scipy.signal import*
lambda A,r=range(3):convolve2d([[x*(x>0)for x in y]for y in A],[[0,1,0],[1,0,1],[0,1,0]],mode='same')

Questo calcola il risultato usando il metodo di Luis Mendo .

Provalo online

Mathcad, byte

Utilizza la convoluzione 2D standard dell'array filtrato con un kernel 3x3. Sono state anche aggiunte varianti con somme di elementi negativi e kernel diagonale come compensazione parziale per il programma che non è in esecuzione per almeno byte.

Nessun conteggio dei byte inserito come punteggio Mathcad non è ancora stato determinato. Tuttavia, usando l'equivalenza da tastiera, è la regione di 28 byte supponendo che l'input della matrice non conti per il totale.

Nota che quello che vedi nell'immagine sopra è esattamente come la soluzione viene inserita e visualizzata in Mathcad.

Gelatina, 23 20 18 byte

0;+ḊṖ
ZÇ€Z+Ç€
+AHÇ

Provalo online!

Algoritmo

Diciamo che c'è solo una riga: [1,2,3,4].

Diciamo che A è il risultato di anteporre uno zero, cioè [0,1,2,3,4].

B è il risultato della rimozione del primo oggetto, ovvero [2,3,4].

Quindi il risultato finale è semplicemente A + B vettorializzato, quindi rimuove l'ultimo elemento.

Ora, l'algoritmo consiste nell'applicare questo su ogni riga e ogni colonna, quindi trovare la loro somma vettoriale.

Per ogni colonna ?! Pensavo che Jelly non supportasse questo ...

Hai ragione. Pertanto, l'ho trasposto, applicato ad ogni riga, quindi l'ho trasposto di nuovo.

Algoritmo per la rimozione di numeri negativi

Qui, aggiungi ad ogni numero il loro assoluto. Elimina efficacemente i numeri negativi mentre raddoppia ogni numero positivo. Quindi, dimezza l'intera matrice.

Pyth, 36 byte

Lm+Vt+d0+0dbJmm/+.akk2dQ.b+VNYyJCyCJ

Provalo online!

Traduzione diretta della mia risposta in gelatina .