Tome una matriz / matriz numérica no vacía que contenga enteros positivos como entrada. Devuelva, en este orden, las sumas de la primera fila y columna, luego la segunda fila y columna y continúe hasta que no haya más filas o columnas.

Supongamos que la entrada es:

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

Entonces la salida debería ser:

45, 33, 16, 17

Debido a 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.

Casos de prueba:

Los casos de prueba están en el siguiente formato:

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

Como matrices:

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

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

MATL , 16 bytes

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

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

Explicación

Considere, como ejemplo, la entrada

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

El código &n:w:!Xlconstruye el vector de columna [1; 2; 3; 4]y el vector de fila [1 2 3 4 5]. Luego Xlcalcula el elemento mínimo sabio con broadcast, que da la matriz

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

X:linealiza esta matriz (en orden de columna principal) en el vector de columna [1; 1; 1; 1; 1; 2; 2; ... ; 4]. Este vector y la matriz de entrada linealizada, obtenida como GX:, se pasan como entradas a la accumarray(... @sum)función, o 1XQ. Esto calcula la suma de la segunda entrada agrupada por los valores de la primera entrada.

Jalea , 3 bytes

ŒDS

Pruébalo en línea!

Cómo funciona

ŒDS

ŒD   diagonals
  S  vectorized sum

CJam , 23 18 bytes

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

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

Pruébalo en línea!

Explicación

[      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 bytes

[ćOˆøŽ]¯2ôO

Pruébalo en línea!

Explicación

[   Ž ]       # 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 bytes

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

Solución ingenua, puede ser una mejor manera.

Mathematica, 60 bytes

Inspirado por la respuesta MATL de Luis Mendo .

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

Explicación: Min~Array~Dimensions@#construye una matriz como la siguiente:

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

Luego Pick[#,...,n]~Total~2selecciona las entradas de la matriz de entrada correspondiente al número nen la matriz extraña de arriba, y las suma. Finalmente se ...~Table~{n,Min[d=Dimensions@#]}repite n.

Este es 1 byte más corto que el enfoque ingenuo:

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

Haskell, 50 49 bytes

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

Pruébalo en línea!

Si hay al menos una fila con al menos un elemento, el resultado es la suma de la primera fila y los encabezados de todas las demás filas, seguido de una llamada recursiva con las colas de todas las demás filas. En todos los demás casos, el resultado es la lista vacía.

Editar: Ørjan Johansen guardó un byte. ¡Gracias!

Octava , 64 52 bytes

¡Gracias a @StewieGriffin por guardar 1 byte!

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

Esto define una función anónima.

Pruébalo en línea!

Explicación

El código es similar a mi respuesta MATL (vea la explicación allí).

Se han guardado dos bytes utilizando en 1:size(x)lugar de 1:size(x,1), explotando el hecho de que se 1:[a b]comporta igual que 1:a. Además, un byte se ha guardado usando en 1:rows(x')lugar de 1:size(x,2), gracias a Stewie.

k, 19 bytes

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

Pruébalo en línea!

Explicación:

           (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 bytes

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

Pruébalo en línea! o prueba todas las pruebas

[                # 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

Octava , 63 60 bytes

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

Pruébalo en línea!

La respuesta para esta matriz:

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

es el vector de sumas de fila de su parte triangular superior:

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

más el vector de sumas de columnas de su parte triangular inferior:

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

que es precisamente lo que mi respuesta es informática.

Julia , 62 bytes

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

Funciona de forma recursiva sumando toda la matriz y luego restando la suma del siguiente bloque. Probablemente no sea el enfoque más efectivo, pero muy intuitivo.

Java 7, 248 bytes

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

Pruébalo aquí.

Explicación general:

Digamos que la matriz de entrada tiene dimensiones de 4x6. La primera parte del código creará una matriz temporal y la completará de la siguiente manera:

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

Y en la segunda parte del código, recorrerá esta matriz temporal y sumará todos los valores de la matriz de entrada para cada uno de los números distintos en la matriz temporal.

Explicación del código:

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 bytes

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

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

• $_ es la entrada de matriz a la función anónima
• .skip es la matriz de entrada con su primera fila eliminada
• [Z] .skipes la transposición de la matriz de entrada con su primera fila eliminada; es decir, la transposición sin su primera columna
• $_ Z [Z] .skip comprime la matriz de entrada con su transposición-sin-primera-columna, produciendo una lista ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
• .kv prefija cada par con su índice
• map({...})asigna sobre los pares, usando una función que toma su primer argumento (el índice) $^ay su segundo (el par fila / columna) en$^b
• $^b.flatmap(*[$^a..*]).sumquita los primeros $^aelementos de cada par de fila / columna, luego suma todos los elementos restantes

Después de pensarlo un poco, me di cuenta de que quitar la primera columna de la transposición antes de comprimir era equivalente a restar los elementos diagonales que contribuyen doblemente, como en mi primera solución. Eso me permitió eliminar esa resta, y usar cada argumento de la función de mapeo solo una vez hizo que el {...$^a...$^b...}método de pasar argumentos a una función anónima fuera más eficiente que el original -> \a, \b {...a...b...}.

Vim, 66 , 52 bytes

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>

Pruébalo en línea!

La herramienta incorrecta para el trabajo ...

Jalea , 10 bytes

Ḣ;Ḣ€SṄȧßS¿

Un programa completo que imprime los valores.

Pruébalo en línea!

¿Cómo?

Ḣ;Ḣ€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 bytes

La entrada es una matriz numpy 2D.

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

Pruébalo en línea

Python 2 , 97 bytes

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

Pruébalo en línea!

Pyth, 16 15 bytes

.es+>b+1k>@CQkk

Toma una matriz de matrices de números estilo python, devuelve una matriz de sumas.

¡Intentalo!

Explicación

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

La solución requiere dos funciones: una crea una matriz global y llama a la segunda, que agrega recursivamente las sumas a esa matriz.

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

∇comienza y termina la función. Ambos fy gtoman tablas como argumentos (esencialmente matrices 2D). Estos se pueden crear conX←rows cols ⍴ 1 2 3 4... .

R←⍬asigna un vector vacío a la variable global R.

g N llama a la segunda función con el mismo argumento dado a la primera.

⍴Nda las dimensiones de N; cuando una de las dimensiones es cero, no hay más filas / columnas para sumar. 0∈⍴Ndevuelve 1 si hay un cero en las dimensiones. →2+2×0∈⍴Nse bifurca a la línea número 2 más 2 veces el valor de retorno de la ∈función: si no hay cero, ∈devuelve 0 y la función se bifurca a la línea 2 (la siguiente línea). Si no es a, cero ∈devuelve 1 y las ramas de la función a la línea 4 (el final de la función, de modo returnesencialmente).

/es el operador de reducción. Aplica el argumento izquierdo, que es un operador ( +) a cada elemento de la lista dado como el argumento correcto. N[1;]da la primera fila completa de la tabla y N[;1]da la primera columna. (+/N[1;])+(+/N[;1])-N[1;1]suma la primera fila y columna y resta el valor en la esquina superior izquierda porque se agrega tanto en la suma de columnas como en la suma de filas. R←R,...agrega el valor recién calculado al vector globalR .

La función se llama a sí misma (recurse hasta que no haya más filas o columnas). El ⊃operador de selección obtiene el elemento especificado de la lista. 1⊃⍴Nda el número de filas, 2⊃⍴Nel número de columnas. ⍳da todos los números del 1 al número especificado. El ↓operador de eliminación elimina elementos del principio de la lista. Si proporciona múltiples índices al acceder a elementos de una tabla o vector (por ejemplo N[1 2 3]), APL accede a cada uno. Por lo tanto, 1↓⍳1⊃⍴Nda los índices de cada fila excluyendo el primero ( 2, 3, 4, ..., N) y 1↓⍳2⊃⍴Nda un vector similar pero para las columnas. g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]llama a la función nuevamente pero sin la primera fila o columna.

PHP, 76 bytes

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

Pruébalo en línea!

Mathematica, 116 bytes

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

Formulario de entrada

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

Clojure, 98 bytes

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

Itera sobre la entrada con índices de fila y columna (de una manera muy detallada), crea un mapa hash con el mínimo de iy jcomo clave, combina los mapas hash con +un mapa ordenado, devuelve valores.

R, 102 bytes

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

devuelve una función anónima; imprime los resultados en la consola, con una nueva línea final. Probablemente necesito un enfoque diferente.

Itera sobre el mínimo de las filas y columnas; imprime la suma de x[,1](la primera columna) y x[1,-1]la primera fila, excepto la primera entrada, luego se establece xcomo una matriz igual a x[-1,-1](es decir, xexcluyendo su primera fila y columna) Desafortunadamente, la configuración simple x=x[-1,-1]hace que falle en el caso de una matriz cuadrada, porque cuandox es 2x2, el subconjunto devuelve un vector en lugar de una matriz.

Pruébalo en línea!

Java 7, 280 276 bytes

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

Pruébalo aquí.

Enfoque alternativo en comparación con mi respuesta anterior con matrices, que aún es más corta que esta al final (por lo que perdí un poco de tiempo probando este enfoque alternativo).

Explicación general:

La inspiración de @Riley increíble respuesta 05AB1E 's
Esta respuesta utiliza una lista y después se calcula cada suma se elimina la primera columna y la primera fila de la lista de matriz, como este:

// 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 "

Explicación del código:

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 bytes

Similar a la respuesta de mbomb007, pero sin 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])))]