Prenez une matrice d'entiers positifs comme entrée et sortez les sommes individuelles des éléments sur les lignes diagonales à travers la matrice.

Vous ne devez compter que les lignes qui descendent en diagonale et vers la droite. Vous devez commencer par la diagonale qui ne contient que l'élément en bas à gauche, puis la diagonale de longueur deux au-dessus (si elle existe) et ainsi de suite jusqu'à la diagonale qui ne contient que l'élément en haut à droite, comme illustré ci-dessous.

Exemple:

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

Les formats d'entrée et de sortie sont facultatifs comme toujours.

Il s'agit de code-golf , donc la soumission la plus courte dans chaque langue l'emporte.

Haskell , 40 37 octets

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

Essayez-le en ligne! Utilisation: (foldl1$(.(++z)).zipWith(+).(0:)) [[1,2,3],[4,5,6]].

Edit: Merci à Ørjan Johansen pour -3 octets!

Non golfé:

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

zest une liste d'une infinité de zéros. Dans fnous replions la liste des listes men combinant deux listes avec la fonction #. Dans #la première liste scontient les sommes de colonne accumulées jusqu'à présent et la deuxième liste test la nouvelle ligne qui doit être ajoutée. Nous décalons sun élément vers la droite en ajoutant un zéro à l'avant et ajoutons set tavec élément zipWith(+). Parce que cela speut être arbitrairement grand, nous devons ajouter tsuffisamment de zéros en ajoutant z.

Mathematica, 53 54 octets

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

Fonction pure prenant un tableau 2D en entrée et renvoyant une liste. (Les entrées ne doivent pas nécessairement être des nombres entiers ou pairs.) Diagonal[#,k]Renvoie la ke diagonale au-dessus (ou en dessous, si elle kest négative) de la diagonale principale. {k,-l@#,l@#&@@#}calcule la plage de diagonales nécessaire en fonction des dimensions du tableau d'entrée. Et Tradditionne les entrées de chaque diagonale.

MATL , 6 octets

T&XdXs

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

Gelée , 5 octets

0;+µ/

Essayez-le en ligne!

Comment ça fonctionne

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 octets

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

CJam , 22 21 octets

1 octet enregistré grâce à Martin Ender

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

Bloc anonyme attend l'argument sur la pile et laisse le résultat sur la pile.

Essayez-le en ligne!

Comment ça fonctionne

_                   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 octets

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

Essayez-le en ligne!

Explication

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 octets

+//.@|.

Essayez-le en ligne!

C'est assez simple:

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

Les lignes inversées obliques sont les diagonales du tableau, donc cela ne fait que sommer les diagonales.

Python 2 , 62 octets

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

Essayez-le en ligne!

Gelée , 8 octets

ŒDS€ṙZL$

Essayez-le en ligne!

La moitié du code est utilisée pour mettre les résultats dans le bon ordre.

Comment?

Œ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 octets

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

R, 45 octets

Fonction sans nom prenant un objet de classe matricielle en entrée:

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

En utilisant l'idée expliquée dans cette réponse.

Octave, 71 octets

En supposant que A est une matrice, par exemple:

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

Ensuite nous avons:

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

Notez que la transposition de la matrice inverse l'ordre des sommes diagonales, ce qui a économisé globalement deux octets dans la boucle for.

Production:

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

Python, 126 octets

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

fne fonctionne que sur la section triangulaire inférieure, donc je la transpose et j'obtiens la section triangulaire supérieure de cette façon. Je ne sais pas pourquoi la ffonction ne fonctionne pas pour les valeurs négatives (j'ai changé fpour être plus courte car la partie pour obtenir les négatifs n'a pas fonctionné).

C, 148 octets

Essayez en ligne

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 octets

Prendre l'entrée comme tableau 2 D

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

Essayez-le en ligne!

Awk, 67 octets

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

Non golfé:

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

Awk se divise en espace blanc $nest le nchamp e (indexé 1); NFest le nombre de champs sur la ligne, NRest le numéro de la ligne actuelle. Les variables non définies sont 0 et créées lors de la première utilisation.

PHP, 86 octets

une solution respectueuse de la mémoire en deux 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++];

prend l'entrée des paramètres de script, utilise le soulignement comme délimiteur;
utiliser les paramètres par défaut (pas php.ini par défaut) ou les essayer en ligne

Clojure, 81 octets

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

Assez verbeux, car il remplit les listes avec des zéros afin que nous puissions simplement calculer la somme par colonne.

mathématique 73 octets

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

Celui-ci fonctionne pour N'IMPORTE QUEL mxn de tableau 2D (pas seulement nxn)
entrez le tableau à la fin du code comme ceci (le dernier cas de test)

[{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}

saisie sous la forme [{a, b, c, d ...}, {m, n}]