Escriba un programa o función donde una matriz A (el valor máximo de las dimensiones de la matriz es 100) se transforma en una nueva matriz B. Cada elemento de la nueva matriz B es la suma de los vecinos positivos del elemento correspondiente de la matriz A .

Solo se consideran vecinos en las cuatro direcciones ortogonales, y los bordes no se envuelven.

Entrada de ejemplo:

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

Salida:

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

Reglas:

• Como entrada, use enteros.
• Este es un código de golf , por lo que gana el código más corto en bytes.

MATL , 9 bytes

t0>*1Y6Z+

Pruébalo en línea!

Explicación

La matriz de entrada se multiplica por una máscara apropiada para hacer que los valores negativos sean iguales a 0. Luego se aplica una convolución 2D para calcular la suma de vecinos de cada entrada.

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

Octava, 46 44 40 bytes

Ahorré 2 bytes gracias al núcleo de @flawr
@ LuisMendo fue 4 bytes más corto que el de @flawr.

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

¡Al igual que la respuesta de @ LuisMendo ! Sólo menos ... golf.

Puedes verlo aquí en ideone .

JavaScript (ES6), 99 94 bytes

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

Acepta y devuelve una matriz bidimensional.

Editar: completamente reescrito cuando descubrí que los argumentos predeterminados funcionan cuando pasa un valor explícitamente indefinido, como cuando indexa el final de una matriz.

JavaScript (ES6), 95 93 bytes

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 bytes

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

Esto calcula el resultado usando el método de Luis Mendo .

Pruébalo en línea

Mathcad, bytes

Utiliza convolución 2D estándar de la matriz filtrada con un núcleo 3x3. Las variantes con sumas de elementos negativos y núcleo diagonal también se agregaron como compensación de parte para que el programa no esté en ejecución por el mínimo de bytes.

Aún no se ha determinado el recuento de bytes, ya que la puntuación de Mathcad aún no se ha determinado. Sin embargo, usando la equivalencia del teclado, es la región de 28 bytes asumiendo que la entrada de matriz no cuenta para el total.

Tenga en cuenta que lo que ve en la imagen de arriba es exactamente cómo se ingresa y se muestra la solución en Mathcad.

Jalea, 23 20 18 bytes

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

Pruébalo en línea!

Algoritmo

Digamos que solo hay una fila: [1,2,3,4].

Digamos que A es el resultado de anteponer un cero, es decir, [0,1,2,3,4].

B es el resultado de eliminar el primer elemento, es decir, [2,3,4].

Luego, el resultado final es simplemente A + B vectorizado, luego se elimina el último elemento.

Ahora, el algoritmo es aplicar esto a cada fila, así como a cada columna, luego encontrar su suma vectorizada.

¿A cada columna? Pensé que Jelly no es compatible con esto ...

Tienes razón. Por lo tanto, lo transpuse, apliqué a cada fila, luego lo volví a transponer.

Algoritmo para eliminar números negativos.

Aquí, solo agrega a cada número su absoluto. Elimina efectivamente los números negativos mientras duplica cada número positivo. Luego, simplemente reduzca a la mitad toda la matriz.

Pyth, 36 bytes

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

Pruébalo en línea!

Traducción directa de mi respuesta en gelatina .