19

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.

code-golf math matrix

— Stewie Griffin
source

En relation

— Nimi

6

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.

— Laikoni
source

C'est plus court sans le point: foldl1$(.(++z)).zipWith(+).(0:).

— Ørjan Johansen

6

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.

— Greg Martin
source

Alternative au même nombre d'octets, mais peut-être pouvez-vous la jouer plus loin? Ces parenthèses semblent mauvaises. Tr@Diagonal[m,#]&/@Range@@({-1,1}(Dimensions[m=#]-1))&

— Martin Ender

5

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

— Luis Mendo
source

Juste curieux: Pensez-vous qu'il serait préférable dans l'ensemble d'avoir s==sum(x(:)), au lieu de s'en tenir à la convention MATLAB, comme MATL semble le faire?

— Stewie Griffin

@StewieGriffin J'y ai parfois pensé. Mon doute était plus entre sum(x)et sum(x,1). Pour une matrice x, le fait de sum(x)se comporter différemment si la matrice a 1 ligne est parfois gênant. Mais à la fin j'ai décidé d'aller avec Matlab, donc les deux langues sont plus proches; et ajouter quelques fun(x,1)fonctions pour les cas les plus courants

— Luis Mendo

5

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.

— Dennis
source

Seul le premier R à réduire a un élément de moins; il augmente d'un élément de plus à chaque ligne.

— Ørjan Johansen

C'est juste intelligent ... non ŒD?

— Erik the Outgolfer

@EriktheOutgolfer Une fois de plus, ŒDla commande bizarre l'a empêché d'être utile.

— Dennis

@ Dennis Alors je pense que je ferais quelque chose qui n'a pas un ordre si bizarre ... oh, peut-être que 3 monades pourraient arriver.

— Erik the Outgolfer

5

JavaScript (ES6), 65 58 octets

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

— Neil
source

Variante de 63 octets:a=>a.map(r=>r.map(v=>s[i]=~~s[i++]+v,i=--y),s=[],y=a.length)&&s

— Arnauld

@Arnauld Je suis d'accord, inverser était une mauvaise décision. Mais prendre la longueur est trop longue aussi!

— Neil

3

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

— Chat d'affaires
source

2

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)

— Emigna
source

2

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.

— Conor O'Brien
source

2

Python 2 , 62 octets

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

Essayez-le en ligne!

— Dennis
source

1

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

— Jonathan Allan
source

1

Perl 5, 47 octets

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

— faubi
source

1

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.

— Billywob
source

Je crois que les règles de ce défi vous permettent de vous débarrasser de l'appel à unname, mais c'est une solution géniale malgré tout!

— Giuseppe

1

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

— It Guy
source

1

[m,n]=size(A);for i=1:m+n-1,trace([zeros(m-1,m);A'](i:end,:)),endenregistre 6 octets. Octave peut effectuer des indexations directes et des affectations en ligne. Malheureusement, supposer qu'une variable existe dans l'espace de travail avant d'exécuter le code n'est pas autorisé, donc je pense que vous devez utiliser input, comme cela, le ramener à 75 octets. Belle approche cependant, alors +1 de ma part :) Et bienvenue chez PPCG! =)

— Stewie Griffin

Aussi, zeros(m-1,m)peut être écrit ~e(m-1,m), économisant 4 octets :) Neat hein?

— Stewie Griffin

0

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

— HyperNeutrino
source

Je reçois une erreur pour le dernier cas de test. tio.run/nexus/…

— Dennis

0

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

— Khaled.K
source

0

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!

— Jörg Hülsermann
source

0

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.

— Kevin
source

0

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

— Titus
source

0

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.

— NikoNyrh
source

0

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

— J42161217
source

Additionner les diagonales

Haskell , 40 37 octets

Non golfé:

Mathematica, 53 54 octets

MATL , 6 octets

Explication

Gelée , 5 octets

Comment ça fonctionne

JavaScript (ES6), 65 58 octets

CJam , 22 21 octets

05AB1E , 17 octets

J , 7 octets

Python 2 , 62 octets

Gelée , 8 octets

Comment?

Perl 5, 47 octets

R, 45 octets

Octave, 71 octets

Python, 126 octets

C, 148 octets

PHP, 81 octets

Awk, 67 octets

PHP, 86 octets

Clojure, 81 octets

mathématique 73 octets