Somme de la première ligne et de la colonne, puis de la deuxième ligne et de la colonne… et ainsi de suite

31

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.

code-golf  math  matrix 
— Stewie Griffin
source
2
@JonathanAllan, imprimer des zéros pour toujours est un peu exagéré, donc je pense que je dois dire non à celui-là.
— Stewie Griffin
1
Programme Retina pour convertir de jolis exemples en tableaux Python.
— mbomb007
1
En regardant les exemples. la description de la tâche est incorrecte. La deuxième colonne du premier exemple est 10,7,7,1, la deuxième ligne est 9,7,7,2,9et la somme est 59. Et ainsi de suite
— edc65
1
@ edc65 En regardant les exemples, il apparaît que les nombres utilisés dans les calculs précédents ne sont pas réutilisés. Ou d'une autre manière, lorsque vous considérez la nième ligne, utilisez uniquement les valeurs de la nième colonne et ignorez celles des colonnes 1 à n-1.
— Brian J
1
@ Arc676 Règles io standard. Les arguments de fonction sont l'une des méthodes d'entrée acceptées.
— Stewie Griffin,

Réponses:

10

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.

— Luis Mendo
source
5

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.
— Chat d'affaires
source
N'est-ce pas un peu "tricher"? Je veux dire, vous ne comptez pas le code d'entrée et de sortie dans le nombre d'octets. Avec l'entrée et la sortie, il ne fait que 1 octet de plus:q~[{(:+\z}h;]2/::+p
— FrodCube
@FrodCube Il est autorisé par un méta consensus .
— Business Cat
2
En fait, techniquement, ce serait la même durée qu'un programme complet, car je pourrais omettre l'ouverture [. Mais en tant que bloc, je pense que j'en ai besoin car il ne doit pas également capturer la pile entière ci-dessous.
— Business Cat
5

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
— Emigna
source
4

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.

— ETHproductions
source
4

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@#}&
— Pas un arbre
source
4

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!

— nimi
source
4

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.

— Luis Mendo
source
3

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
— zgrep
source
3

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
— Riley
source
3

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.

— eush77
source
2

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.

— Julian Wolf
source
2

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
— Kevin Cruijssen
source
2

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

— Sean
source
1

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)
— Jonathan Allan
source
1

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

— mbomb007
source
1

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
— KarlKastor
source
1

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.

— Arc676
source
0

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 [{{....}, {....} ... {. ...}}]

— J42161217
source
0

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.

— NikoNyrh
source
0

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!

— Giuseppe
source
0

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
— Kevin Cruijssen
source
0

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])))]
— PattuX
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.