Tome una matriz de enteros positivos como entrada y envíe las sumas individuales de los elementos en las líneas diagonales a través de la matriz.

Solo contarás las líneas que van diagonalmente hacia abajo y hacia la derecha. Debe comenzar con la diagonal que contiene solo el elemento inferior izquierdo, luego la diagonal de longitud dos por encima de eso (si existe) y así sucesivamente hasta la diagonal que contiene solo el elemento superior derecho, como se ilustra a continuación.

Ejemplo:

Input:
 8   14    5    1
10    5    5    8
 6    6    8   10
15   15    4   11

Output:
15, 21, 20, 32, 29, 13, 1
(Diagonals: {{15},{6,15},{10,6,4},{8,5,8,11},{14,5,10},{5,8},{1}})

Input:
1
Output:
1

Input: 
1 5
Output:
1, 5

Input:
4
1

Output: 
1, 4

Input:
17    4    5
24   16    5
 9   24   10
 1   14   22
 1   21   24
 4    4   17
24   25   17

Output:
24, 29, 22, 39, 47, 70, 43, 9, 5

Los formatos de entrada y salida son opcionales como siempre.

Este es el código de golf , por lo que gana la presentación más corta en cada idioma.

Haskell , 40 37 bytes

z=0:z
foldl1$(.(++z)).zipWith(+).(0:)

Pruébalo en línea! Uso: (foldl1$(.(++z)).zipWith(+).(0:)) [[1,2,3],[4,5,6]].

Editar: ¡ Gracias a Ørjan Johansen por -3 bytes!

Sin golf:

z = 0:z
s#t = zipWith(+)(0:s)(t++z)
f m = foldl1 (#) m

zes una lista de infinitos ceros. En fplegamos la lista de listas mcombinando dos listas con la función #. En #la primera lista scontiene las sumas de columnas acumuladas hasta ahora y la segunda lista tes la nueva fila que debe agregarse. Cambiamos sun elemento a la derecha agregando un cero al frente y sumando sy tcon elementos zipWith(+). Debido a que spuede ser arbitrariamente grande, tenemos que rellenar tcon ceros suficientes agregando z.

Mathematica, 53 54 bytes

l=Length@#-1&;Tr@Diagonal[#,k]~Table~{k,-l@#,l@#&@@#}&

Función pura que toma una matriz 2D como entrada y devuelve una lista. (Las entradas no tienen que ser números enteros o pares). Diagonal[#,k]Devuelve la kdiagonal th arriba (o abajo, si kes negativa) la diagonal principal. {k,-l@#,l@#&@@#}calcula el rango de diagonales necesarias según las dimensiones de la matriz de entrada. Y Trsuma las entradas de cada diagonal.

MATL , 6 bytes

T&XdXs

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

T&Xd   % All diagonals of implicit input arranged as zero-padded columns
Xs     % Sum of each column. Implicitly display

Jalea , 5 bytes

0;+µ/

Pruébalo en línea!

Cómo funciona

0;+µ/  Main link. Argument: M (matrix / array of rows)

   µ   Combine all links to the left into a chain (arity unknown at parse time) and
       begin a new monadic chain.
    /  Reduce M by that chain. This makes the chain dyadic.
       Let's call the arguments of the chain L and R (both flat arrays).
0;         Prepend a 0 to L.
  +        Perform element-wise addition of the result and R.
           When the chain is called for the n-th time, R has n less elements, so
           the last n elements of L won't have matching elements in R and will be
           left unaltered.

JavaScript (ES6), 65 58 bytes

a=>a.map(b=>b.map((c,i)=>r[i]=~~r[i]+c,r=[,...r]),r=[])&&r

CJam , 22 21 bytes

Guardado 1 byte gracias a Martin Ender

{_,({0\f+}*ee::m<:.+}

Bloque anónimo que espera el argumento en la pila y deja el resultado en la pila.

Pruébalo en línea!

Cómo funciona

_                   e# Duplicate the matrix
 ,(                 e# Get its length (# of rows) minus 1
   {0\f+}*          e# Prepend that many 0s to each row
          ee        e# Enumerate; map each row to [index, row]
            ::m<    e# Rotate each row left a number of spaces equal to its index
                :.+ e# Sum each column

05AB1E , 17 bytes

Rvy¹gÅ0«NFÁ}})øO¨

Pruébalo en línea!

Explicación

R                  # reverse input
 v                 # for each N,y (index, item)
  y¹gÅ0«           # pad y with as many zeroes as the number of rows in the input
        NFÁ}       # rotate each row N times right
            })     # wrap the result in a list
              øO   # sum the columns
                ¨  # remove the last element of the resulting list (the padded zeroes)

J , 7 bytes

+//.@|.

Pruébalo en línea!

Esto es bastante simple:

+//.@|.
+/        sum
  /.      on oblique lines
    @|.   on the reversed array

Las líneas oblicuas invertidas son las diagonales de la matriz, por lo que esto es solo sumar las diagonales.

Python 2 , 62 bytes

lambda M:reduce(lambda x,y:map(sum,zip([0]+x,y+[0]*len(x))),M)

Pruébalo en línea!

Jalea , 8 bytes

ŒDS€ṙZL$

Pruébalo en línea!

La mitad del código se usa para poner los resultados en el orden correcto.

¿Cómo?

ŒDS€ṙZL$ - Main link: list of lists of numbers
ŒD       - diagonals (starts with the diagonal containing the top left element,
         -            then the next diagonal to the right, and so on wrapping around)
  S€     - sum €each
       $ - last two links as a monad
     Z   - transpose the matrix
      L  - length (width of the matrix)
    ṙ    - rotate the results left by that amount

Perl 5, 47 bytes

map{$j=--$.;map{@a[$j++]+=$_}split}<>
print"@a"

R, 45 bytes

Función sin nombre que toma un objeto de clase matriz como entrada:

function(x)sapply(split(x,col(x)-row(x)),sum)

Usando la idea explicada en esta respuesta.

Octava, 71 bytes

Suponiendo que A es una matriz, por ejemplo:

A = [17 4 5;24 16 5; 9 24 10; 1 14 22; 1 21 24; 4 4 17;24 25 17];

Entonces tenemos:

[m,n]=size(A);
a=[zeros(m,m-1),A]';
for i=1:m+n-1
trace(a(i:end,:))
end

Observe que la transposición de la matriz invierte el orden de las sumas diagonales, lo que ahorró un total de dos bytes en el bucle for.

Salida:

ans =  24
ans =  29
ans =  22
ans =  39
ans =  47
ans =  70
ans =  43
ans =  9
ans =  5

Python, 126 bytes

x=input()
f=lambda k:[x[i+k][i]for i in range(len(x)-k)]
a=map(f,range(4)[::-1])
x=zip(*x)
print(map(sum,a+map(f,range(1,4))))

fsolo funciona en la sección triangular inferior, así que la transpongo y obtengo la sección triangular superior de esa manera. No sé por qué la ffunción no funciona para valores negativos (cambié fpara que sea más corta porque la parte para obtener los negativos no funcionó).

C, 148 bytes

Probar en línea

s;g(int i,int j,int**m,int x){for(s=0;x;x--)s+=m[i++][j++];printf(" %d",s);}
k;f(int n,int**m){for(k=n;--k;)g(k,0,m,n-k);for(;k<n;k++)g(0,k,m,n-k);}

PHP, 81 bytes

Tomar entrada como matriz 2 D

<?foreach($_GET as$k=>$v)foreach($v as$x=>$y)$r[$x-$k]+=$y;ksort($r);print_r($r);

Pruébalo en línea!

Awk, 67 Bytes

{for(f=0;f++<NF;)s[NF-NR+f]+=$f}END{i=0;while(i++<NR*2)print s[i]}

Sin golf:

{
    for (f = 0; f++ < NF;)
        s[NF-NR+f] += $f
}
END {
    i = 0
    while (i++ < NR*2)
        print s[i]
}

Awk se divide en espacios en blanco $nes el ncampo th (1 indexado); NFes el número de campos en la línea, NRes el número de la fila actual. Las variables no definidas son 0 y se crean en el primer uso.

PHP, 86 bytes

Una solución amigable con la memoria en dos variantes:

<?for($i=$c=count($a=$_GET);--$i>-$c;print$s._)for($s=0,$d=$c;$d--;)$s+=$a[$i+$d][$d];
<?for($i=$c=count($a=$_GET);--$i>-$c;print$s._)for($s=$d=0;$d<$c;)$s+=$a[$i+$d][$d++];

toma datos de los parámetros del script, usa guiones bajos como delimitador;
use la configuración predeterminada (no predeterminada php.ini) o pruébela en línea

Clojure, 81 bytes

#(apply map +(map(fn[i c](concat(repeat(-(count %)i 1)0)c(repeat i 0)))(range)%))

Muy detallado, ya que rellena las listas con ceros para que podamos calcular la suma de columnas.

Mathica 73 bytes

Plus@@@Table[Diagonal[Partition[#1,#2[[1]]],k],{k,-#2[[2]]+1,#2[[1]]-1}]&

Este funciona para CUALQUIER matriz 2D mxn (no solo nxn)
ingrese la matriz al final del código de esta manera (el último caso de prueba)

[{17,4,5,24,16,5,9,24,10,1,14,22,1,21,24,4,4,17,24,25,17},{3,7}]

{24, 29, 22, 39, 47, 70, 43, 9, 5}

entrada en forma [{a, b, c, d ...}, {m, n}]