Prenez en entrée un tableau matriciel / numérique non vide contenant des entiers positifs. Renvoyez, dans cet ordre, les sommes de la première ligne et colonne, puis de la deuxième ligne et colonne et continuez jusqu'à ce qu'il n'y ait plus de lignes ou de colonnes.

Supposons que l'entrée soit:

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

La sortie doit alors être:

45, 33, 16, 17

Parce que: 2+9+1+7+10+10+2+4=45, 7+7+1+7+2+9=33, 6+4+2+4=16, 8+9=17.

Cas de test:

Les cas de test sont au format suivant:

Input
---
Output

5
---
5
..........

1  4
----
5
..........

7
2
---
9
..........

 8    3    7   10    3    7   10    1
10    7    5    8    4    3    3    1
 1    6    4    1    3    6   10    1
 2    3    8    2    8    3    4    1
---
62   40   33   18
..........

30    39    48     1    10    19    28
38    47     7     9    18    27    29
46     6     8    17    26    35    37
 5    14    16    25    34    36    45
13    15    24    33    42    44     4
21    23    32    41    43     3    12
22    31    40    49     2    11    20
---
320  226   235   263   135    26    20
..........

7   10    1
4    4    2
6    3    4
1    4   10
5    7    6
---
34   20   20

En tant que tableaux:

[[5]]
[[1,4]]
[[7],[2]]
[[8,3,7,10,3,7,10,1],[10,7,5,8,4,3,3,1],[1,6,4,1,3,6,10,1],[2,3,8,2,8,3,4,1]]
[[30,39,48,1,10,19,28],[38,47,7,9,18,27,29],[46,6,8,17,26,35,37],[5,14,16,25,34,36,45],[13,15,24,33,42,44,4],[21,23,32,41,43,3,12],[22,31,40,49,2,11,20]]
[[7,10,1],[4,4,2],[6,3,4],[1,4,10],[5,7,6]]

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

MATL , 16 octets

&n:w:!XlX:GX:1XQ

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

Explication

Considérez, par exemple, l'entrée

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

Le code &n:w:!Xlcrée le vecteur de colonne [1; 2; 3; 4]et le vecteur de ligne [1 2 3 4 5]. XlCalcule ensuite le minimum par élément avec diffusion, ce qui donne la matrice

1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4

X:linéarise cette matrice (dans l'ordre des colonnes principales) dans le vecteur de colonne [1; 1; 1; 1; 1; 2; 2; ... ; 4]. Ce vecteur et la matrice d'entrée linéarisée, obtenue en tant que GX:, sont passés en entrée à la accumarray(... @sum)fonction, ou 1XQ. Ceci calcule la somme de la deuxième entrée groupée par les valeurs de la première entrée.

Gelée , 3 octets

ŒDS

Essayez-le en ligne!

Comment ça marche

ŒDS

ŒD   diagonals
  S  vectorized sum

CJam , 23 18 octets

{[{(:+\z}h;]2/::+}

Bloc anonyme attendant l'argument sur la pile et laissant le résultat sur la pile.

Essayez-le en ligne!

Explication

[      e# Begin working in an array.
 {     e#  Do:
  (:+  e#   Remove the first row of the matrix and sum it.
  \z   e#   Bring the matrix back to the top and transpose it.
 }h    e#  While the matrix is non-empty.
 ;     e#  Discard the remaining empty matrix.
]      e# Close the array.
2/     e# Split it into consecutive pairs of elements (possibly with a singleton on the end).
::+    e# Sum each pair.

05AB1E , 14 11 octets

[ćOˆøŽ]¯2ôO

Essayez-le en ligne!

Explication

[   Ž ]       # loop until stack is empty
 ć            # extract the head
  Oˆ          # sum and add to global list
     ø        # transpose
       ¯      # push global list
        2ô    # split into pairs
          O   # sum each pair

JavaScript (ES6), 60 octets

a=>a.map((b,y)=>b.map((c,x)=>r[x=x<y?x:y]=~~r[x]+c),r=[])&&r

Une solution naïve peut être une meilleure solution.

Mathematica, 60 octets

Inspiré par la réponse MATL de Luis Mendo .

Pick[#,Min~Array~d,n]~Total~2~Table~{n,Min[d=Dimensions@#]}&

Explication: Min~Array~Dimensions@#construit une matrice comme celle-ci:

1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4

Puis Pick[#,...,n]~Total~2sélectionne les entrées de la matrice d'entrée correspondant au nombre ndans la matrice étrange ci-dessus, et les additionne. Enfin, ...~Table~{n,Min[d=Dimensions@#]}itère plus n.

C'est 1 octet de moins que l'approche naïve:

{#[[n,n;;]],#[[n+1;;,n]]}~Total~2~Table~{n,Min@Dimensions@#}&

Haskell, 50 49 octets

f(a@(_:_):b)=sum(a++map(!!0)b):f(tail<$>b)
f _=[]

Essayez-le en ligne!

S'il y a au moins une ligne avec au moins un élément, le résultat est la somme de la première ligne et des têtes de toutes les autres lignes suivie d'un appel récursif avec la queue de toutes les autres lignes. Dans tous les autres cas, le résultat est la liste vide.

Edit: Ørjan Johansen a enregistré un octet. Merci!

Octave , 64 52 octets

Merci à @StewieGriffin d'avoir économisé 1 octet!

@(x)accumarray(min((1:size(x))',1:rows(x'))(:),x(:))

Cela définit une fonction anonyme.

Essayez-le en ligne!

Explication

Le code est similaire à ma réponse MATL (voir explication ici).

Deux octets ont été enregistrés en utilisant 1:size(x)au lieu de 1:size(x,1), exploitant le fait que 1:[a b]se comporte de la même manière que 1:a. De plus, un octet a été enregistré en utilisant 1:rows(x')au lieu de 1:size(x,2), grâce à Stewie.

k, 19 octets

|1_-':|+//'(1_+1_)\

Essayez-le en ligne!

Explication:

           (1_+1_)   /a function that strips the top and leftmost rows of a matrix
                  \  /apply this function as many times as possible,
                     /    saving each result as one element of a list
       +//'          /for each result, get the sum of all numbers
|  -':|              /subtract every right value from every left value
 1_                  /remove the extra 0

05AB1E , 16 octets

[ćOsø.g<NQ#])2ôO

Essayez-le en ligne! ou essayez tous les tests

[                # Start loop
 ć               # Extract first element
  O              # Sum
   sø            # Transpose the input array (without the first N rows and columns)
     .g<NQ       # Push if (stack height - 1 == loop count)
          #]     # If they were equal break
            )2ô  # Break stack into chunks of 2
               O # Sum the chunks

Octave , 63 60 octets

@(A)(@(L)sum(triu(A,1)')(L)+sum(tril(A))(L))(1:min(size(A)))

Essayez-le en ligne!

La réponse pour cette matrice:

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

est le vecteur des sommes de ligne de sa partie triangulaire supérieure:

0   10   10    2    4
0    0    7    2    9
0    0    0    2    4
0    0    0    0    9

plus le vecteur des sommes des colonnes de sa partie triangulaire inférieure:

2    0    0    0    0
9    7    0    0    0
1    7    6    0    0
7    1    4    8    0

c'est précisément ce que ma réponse est le calcul.

Julia , 62 octets

f=x->1∈size(x)?sum(x):(n=f(x[2:end,2:end]);[sum(x)-sum(n);n])

Fonctionne de manière récursive en résumant la matrice entière, puis en soustrayant la somme du bloc suivant. Probablement pas l'approche la plus efficace, mais bien intuitive.

Java 7, 248 octets

String c(int[][]a){int l=a.length,L=a[0].length,b[][]=new int[l][L],i,j,x=1,s;for(;x<(l>L?l:L);x++)for(i=l;i-->x;)for(j=L;j-->x;b[i][j]=x);String r="";for(;x-->0;r=s>0?s+" "+r:r)for(s=0,i=0;i<l;i++)for(j=0;j<L;j++)s+=b[i][j]==x?a[i][j]:0;return r;}

Essayez ici.

Explication générale:

Disons que le tableau d'entrée a des dimensions de 4x6. La première partie du code créera une matrice temporaire et la remplira comme suit:

// 1. Fill the entire array with 0:
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

// 2. Overwrite the inner part with 1 (excluding the first row & column):
0 0 0 0 0 0
0 1 1 1 1 1
0 1 1 1 1 1
0 1 1 1 1 1

// #. Etc. until we are left with this:
0 0 0 0 0 0
0 1 1 1 1 1
0 1 2 2 2 2
0 1 2 3 3 3

Et dans la deuxième partie du code, il bouclera sur cette matrice temporaire et additionnera toutes les valeurs de la matrice d'entrée pour chacun des nombres distincts de la matrice temporaire.

Explication du code:

String c(int[][]a){               // Method with int-matrix parameter and String return-type
  int l=a.length,                 //  Amount of rows
      L=a[0].length,              //  Amount of columns
      b[][]=new int[l][L],        //  New temp matrix to fill as explained above
      i,j,x=1,s;                  //  Some temp integers

                                  //This is the first part of the code mentioned above:
  for(;x<(l>L?l:L);x++)           //  Loop (1) over the rows or columns (whichever is highest)
    for(i=l;i-->x;)               //   Inner loop (2) over the rows
      for(j=L;j-->x;              //    Inner loop (3) over the columns
        b[i][j]=x);               //     Set the current `x`-number
                                  //    End of loop (3) (implicit / no body)
                                  //   End of loop (2) (implicit / single-line body)
                                  //  End of loop (1) (implicit / single-line body)

                                  //This is the second part of the code mentioned above:
  String r="";                    //  Result-String
  for(;x-->0;                     //  Loop (4) over the unique numbers in the temp matrix
             r=s>0?s+" "+r:r)     //   After every iteration, append the sum to the result (if it's larger than 0)
    for(s=0,i=0;i<l;i++)          //   Inner loop (5) over the rows (and reset the sum to 0)
      for(j=0;j<L;j++)            //    Inner loop (6) over the columns
        s+=b[i][j]==x?a[i][j]:0;  //     Add to the sum if its position equals the current `x` in the temp matrix
                                  //    End of loop (6) (implicit / single-line body)
                                  //   End of loop (5) (implicit / single-line body)
                                  //  End of loop (4) (implicit / single-line body)
  return r;                       //  Return the result-String
}                                 // End of method

Perl 6 , 63 55 octets

{($_ Z [Z] $_).kv.map(->\a,\b{b.flatmap(*[a..*]).sum -b[0;a]})}

{($_ Z [Z] .skip).kv.map({$^b.flatmap(*[$^a..*]).sum})}

• $_ est l'entrée matricielle de la fonction anonyme
• .skip est la matrice d'entrée dont la première ligne a été supprimée
• [Z] .skipest la transposition de la matrice d'entrée dont la première ligne a été supprimée; c'est-à-dire la transposition sans sa première colonne
• $_ Z [Z] .skip zippe la matrice d'entrée avec sa transpose-sans-première colonne, produisant une liste ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
• .kv préfixe chaque paire avec son index
• map({...})mappe sur les paires, en utilisant une fonction qui prend son premier argument (l'index) dans $^aet sa seconde (la paire ligne / colonne) dans$^b
• $^b.flatmap(*[$^a..*]).sumsupprime les premiers $^aéléments de chaque paire de lignes / colonnes, puis additionne tous les éléments restants

Après réflexion, j'ai réalisé que retirer la première colonne de la transposition avant de zipper équivalait à soustraire les éléments diagonaux à double contribution, comme dans ma première solution. Cela m'a permis de supprimer cette soustraction, et d'utiliser chaque argument de la fonction de mappage une seule fois a rendu la {...$^a...$^b...}méthode de passage des arguments à une fonction anonyme plus efficace que l'original -> \a, \b {...a...b...}.

Vim, 66 , 52 octets

qq^f j<C-v>}dkV}Jo<esc>p@qq@q:%s/\v> +</+/g|%norm C<C-v><C-r>=<C-v><C-r>"<C-v><cr><cr>

Essayez-le en ligne!

Le mauvais outil pour le travail ...

Gelée , 10 octets

Ḣ;Ḣ€SṄȧßS¿

Un programme complet qui imprime les valeurs

Essayez-le en ligne!

Comment?

Ḣ;Ḣ€SṄȧßF¿ - Main link: list of lists a
Ḣ          - head a (pop the first row and yield it, modifying a)
  Ḣ€       - head €ach (do the same for each of the remaining rows)
 ;         - concatenate
    S      - sum (adds up the list that contains the top row and left column)
     Ṅ     - print that plus a linefeed and yield the result
         ¿ - while:
           - ... condition:
        F  -   flatten (a list of empty lists flattens to an empty list which is falsey) 
           - ... body:
       ß   -   call this link with the same arity (as a monad) i.e. Main(modified a)
      ȧ    - logical and (when the sum is non-zero gets the modified a to feed back in)

Python + NumPy, 75 octets

L'entrée est un tableau numpy 2D.

lambda L:[sum(L[i,i:])+sum(L[i+1:,i])for i in range(min(len(L),len(L[0])))]

Essayez-le en ligne

Python 2 , 97 octets

f=lambda m:[reduce(lambda x,y:x+y[i],m[i:],sum(m[i][i+1:]))for i in range(min(len(m),len(m[0])))]

Essayez-le en ligne!

Pyth, 16 15 octets

.es+>b+1k>@CQkk

Prend un tableau de tableaux de nombres de style python, renvoie un tableau de sommes.

Essayez le!

Explication

.es+>b+1k>@CQkk 
.e             Q  # Enumerated map over the implicit input (Q); indices k, rows b
           CQ     # Take the transpose
          @  k    # The kth column
         >    k   # cut off the first k elements
    >b+1k         # cut off the first k+1 elements of the rows, so (k,k) isn't counted twice
  s+              # add the row and column together and sum

GNU APL 1.7, 123 octets

La solution nécessite deux fonctions: l'une crée un tableau global et les appels la seconde, qui ajoute récursivement les sommes à ce tableau.

∇f N
R←⍬
g N
R
∇
∇g N
→2+2×0∈⍴N
R←R,(+/N[1;])+(+/N[;1])-N[1;1]
g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]
∇

∇commence et termine la fonction. Les deux fet gprennent des tables comme arguments (essentiellement des tableaux 2D). Ceux-ci peuvent être créés avec X←rows cols ⍴ 1 2 3 4....

R←⍬assigne un vecteur vide à la variable globale R.

g N appelle la deuxième fonction avec le même argument donné à la première.

⍴Ndonne les dimensions de N; lorsque l'une des dimensions est nulle, il n'y a plus de lignes / colonnes à additionner. 0∈⍴Nrenvoie 1 s'il y a un zéro dans les dimensions. →2+2×0∈⍴Nbranche à la ligne numéro 2 plus 2 fois la valeur de retour de la ∈fonction: s'il n'y a pas de zéro, ∈renvoie 0 et la fonction se branche à la ligne 2 (la ligne suivante). S'il est un zéro,∈ renvoie 1 et les branches de la fonction à la ligne 4 (la fin de la fonction, de manière returnessentiellement).

/est l'opérateur de réduction. Il applique l'argument de gauche, qui est un opérateur ( +) à chaque élément de la liste donné comme argument de droite. N[1;]donne la première ligne entière du tableau et N[;1]donne la première colonne. (+/N[1;])+(+/N[;1])-N[1;1]additionne la première ligne et la première colonne et soustrait la valeur dans le coin supérieur gauche car elle est ajoutée à la fois dans la somme des colonnes et la somme des lignes.R←R,...ajoute la nouvelle valeur calculée au vecteur globalR .

La fonction s'appelle ensuite (recurse jusqu'à ce qu'il n'y ait plus de lignes ou de colonnes). L' ⊃opérateur de sélection obtient l'élément spécifié de la liste. 1⊃⍴Ndonne le nombre de lignes, 2⊃⍴Nle nombre de colonnes. ⍳donne tous les nombres de 1 au nombre spécifié. L' ↓opérateur de suppression supprime les éléments du début de la liste. Si vous donnez plusieurs indices lors de l'accès à des éléments à partir d'une table ou d'un vecteur (par exemple N[1 2 3]), APL accède à chacun d'eux. Par conséquent, 1↓⍳1⊃⍴Ndonne les indices de chaque ligne à l'exclusion de la première ( 2, 3, 4, ..., N) et 1↓⍳2⊃⍴Ndonne un vecteur similaire mais pour les colonnes. g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]appelle à nouveau la fonction mais sans la première ligne ou colonne.

PHP, 76 octets

<?foreach($_GET as$k=>$v)foreach($v as$n=>$i)$r[min($k,$n)]+=$i;print_r($r);

Essayez-le en ligne!

Mathematica, 116 octets

l=Length;If[l@#==1||l@#[[1]]==1,Total@Flatten@#,Total/@Flatten/@Table[{#[[i]][[i;;]],#[[All,i]][[i+1;;]]},{i,l@#}]]&

Formulaire de saisie

[{{5}}], [{{1}, {4}}], [{{7,2}}] ou [{{....}, {....} ... {. ...}}]

Clojure, 98 octets

#(vals(apply merge-with +(sorted-map)(mapcat(fn[i r](map(fn[j v]{(min i j)v})(range)r))(range)%)))

Itère sur l'entrée avec des index de ligne et de colonne (de manière très détaillée), crée une carte de hachage avec le minimum de iet jcomme clé, fusionne les cartes de hachage avec +en une carte triée, renvoie des valeurs.

R, 102 octets

function(x)`for`(i,1:min(r<-nrow(x),k<-ncol(x)),{dput(sum(x[,1],x[1,-1]));x=matrix(x[-1,-1],r-i,k-i)})

renvoie une fonction anonyme; imprime les résultats sur la console, avec une nouvelle ligne de fin. J'ai probablement besoin d'une approche différente.

Itère sur le minimum des lignes et des colonnes; imprime la somme de x[,1](la première colonne) et de x[1,-1]la première ligne à l'exception de la première entrée, puis définit xcomme une matrice égale à x[-1,-1](c'est- à -dire en xexcluant sa première ligne et sa colonne). Malheureusement, un simple réglage x=x[-1,-1]entraîne son échec dans le cas d'une matrice carrée, car lorsqu'il xvaut 2x2, le sous-ensemble renvoie un vecteur plutôt qu'une matrice.

Essayez-le en ligne!

Java 7, 280 276 octets

import java.util.*;String d(ArrayList l){String r="";for(;l.size()>0&&((List)l.get(0)).size()>0;l.remove(0))r+=s(l)+" ";return r;}int s(List<ArrayList<Integer>>l){int s=0,L=l.size(),i=1;for(;l.get(0).size()>0;s+=l.get(0).remove(0));for(;i<L;s+=l.get(i++).remove(0));return s;}

Essayez ici.

Approche alternative par rapport à ma réponse précédente avec les tableaux, qui est toujours plus courte que celle-ci à la fin (donc j'ai perdu un peu de temps à essayer cette approche alternative).

Explication générale:

Inspiration de @Riley réponse 05AB1E étonnante de
cette réponse utilise une liste et après chaque somme est calculée , il enlève la première colonne et la première ligne de la liste-matrice, comme ceci:

// Starting matrix:
7 10 1
4 4  2
6 3  4
1 4  10
5 7  6

// After first iteration (result so far: "34 "):
4  2
3  4
4  10
7  6

// After second iteration (result so far: "34 20 "):
4
10
6

// After last iteration, result: "34 20 20 "

Explication du code:

import java.util.*;                // Required import for List and ArrayList

String d(ArrayList l){             //  Method with ArrayList parameter and String return-type
  String r="";                     //  Return-String
  for(;l.size()>0&&((List)l.get(0)).size()>0; 
                                   //  Loop as long as the list still contains anything
       l.remove(0))                //  And remove the first row after every iteration
    r+=s(l)+" ";                   //   Append the sum to the result-String
                                   //  End of loop (implicit / single-line body)
  return r;                        //  Return result-String
}                                  // End of method

int s(List<ArrayList<Integer>>l){  // Separate method with List-matrix parameter and integer return-type
  int s=0,                         //  The sum
      L=l.size(),                  //  The size of the input list
      i=1;                         //  Temp integer
  for(;l.get(0).size()>0;          //  Loop (1) over the items of the first row
    s+=l.get(0).                   //   Add the number to the sum
                remove(0)          //   And remove it from the list afterwards
  );                               //  End of loop (1)
  for(;i<L;                        //  Loop (2) over the rows
    s+=l.get(i++).                 //   Add the first number of the row to the sum
                  remove(0)        //   And remove it from the list afterwards
  );                               //  End of loop (2)
  return s;                        //  Return sum
}                                  // End of separate method

Python, 93 octets

Similaire à la réponse de mbomb007, mais sans NumPy

f=lambda m:[sum(m[k][k:])+sum(list(zip(*m))[k][k+1:])for k in range(min(len(m),len(m[0])))]