# Sum of first row and column, then second row and column … and so on

Take a non-empty matrix / numeric array containing positive integers as input. Return, in this order, the sums of the first row and column, then the second row and column and continue until there aren't any more rows or columns.

Suppose the input is:

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

Then the output should be:

45, 33, 16, 17

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

## Test cases:

Test cases are on the following format:

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

As arrays:

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

This is so the shortest solution in each language wins.

• @JonathanAllan, printing zeros forever is a bit of a stretch, so I think I must say no to that one. – Stewie Griffin May 18 '17 at 21:01
• Retina program to convert from pretty examples to Python arrays. – mbomb007 May 18 '17 at 21:43
• Looking at the examples. the task desciption is wrong. The second column in first example is 10,7,7,1, the second row is 9,7,7,2,9 and the sum is 59. And so on – edc65 May 19 '17 at 13:22
• @edc65 Looking at the examples, it appears that numbers used in previous calculations aren't reused. Or another way, when considering nth row, only use values from the nth column on, and ignore those in columns 1 through n-1. – Brian J May 19 '17 at 13:28
• @Arc676 Standard io rules. Function arguments are one of the accepted input methods. – Stewie Griffin May 25 '17 at 12:05

# MATL, 16 bytes

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

### Explanation

Consider, as an example, the input

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

The code &n:w:!Xl builds the column vector [1; 2; 3; 4] and the row vector [1 2 3 4 5]. Then Xl computes the minimum element-wise with broadcast, which gives the matrix

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

X: linearizes this matrix (in column-major order) into the column vector [1; 1; 1; 1; 1; 2; 2; ... ; 4]. This vector and the linearized input matrix, obtained as GX:, are passed as inputs to the accumarray(... @sum) function, or 1XQ. This computes the sum of the second input grouped by values of the first input.

# Jelly, 3 bytes

ŒDS

Try it online!

## How it works

ŒDS

ŒD   diagonals
S  vectorized sum

# CJam, 23 18 bytes

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

Anonymous block expecting the argument on the stack and leaving the result on the stack.

Try it online!

### Explanation

[      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.
• Isn't this a bit "cheating"? I mean, you are not counting the input and output code in the byte count. With both input and output it is only 1 byte longer: q~[{(:+\z}h;]2/::+p – FrodCube May 18 '17 at 20:35
• @FrodCube It is allowed by meta consensus. – Business Cat May 18 '17 at 20:36
• Actually, technically, it would be the same length as a full program, since I could omit the opening [. But as a block I think I need it because it needs to not capture the entire stack below as well. – Business Cat May 18 '17 at 20:38

# 05AB1E, 14 11 bytes

[ćOˆøŽ]¯2ôO

Try it online!

Explanation

[   Ž ]       # loop until stack is empty
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

Naive solution, may be a better way.

## Mathematica, 60 bytes

Inspired by Luis Mendo's MATL answer.

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

Explanation: Min~Array~Dimensions@# constructs a matrix like the following:

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

Then Pick[#,...,n]~Total~2 picks out the entries of the input matrix corresponding to the number n in the weird matrix above, and sums them. Finally ...~Table~{n,Min[d=Dimensions@#]} iterates over n.

This is 1 byte shorter than the naïve approach:

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

f(a@(_:_):b)=sum(a++map(!!0)b):f(tail<$>b) f _=[] Try it online! If there's at least one row with at least one element, the result is the sum of the first row and the heads of all other rows followed by a recursive call with the tails of all other rows. In all other cases, the result is the empty list. Edit: Ørjan Johansen saved a byte. Thanks! # Octave, 64 52 bytes Thanks to @StewieGriffin for saving 1 byte! @(x)accumarray(min((1:size(x))',1:rows(x'))(:),x(:)) This defines an anonymous function. Try it online! ### Explanation The code is similar to my MATL answer (see explanation there). Two bytes have been saved using 1:size(x) instead of 1:size(x,1), exploiting the fact that 1:[a b] behaves the same as 1:a. Also, one byte has been saved using 1:rows(x') instead of 1:size(x,2), thanks to Stewie. # k, 19 bytes |1_-':|+//'(1_+1_)\ Try it online! Explanation: (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 [ # 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 bytes @(A)(@(L)sum(triu(A,1)')(L)+sum(tril(A))(L))(1:min(size(A))) Try it online! The answer for this matrix: 2 10 10 2 4 9 7 7 2 9 1 7 6 2 4 7 1 4 8 9 is the vector of row sums of its upper triangular part: 0 10 10 2 4 0 0 7 2 9 0 0 0 2 4 0 0 0 0 9 plus the vector of column sums of its lower triangular part: 2 0 0 0 0 9 7 0 0 0 1 7 6 0 0 7 1 4 8 0 which is precisely what my answer is computing. ## Julia, 62 bytes f=x->1∈size(x)?sum(x):(n=f(x[2:end,2:end]);[sum(x)-sum(n);n]) Works recursively by summing up the whole matrix and then subtracting off the sum of the next block. Probably not the most effective approach, but nicely intuitive. # 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;} Try it here. General explanation: Let's say the input array has dimensions of 4x6. The first part of the code will create a temp matrix and fills it as follows: // 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 And in the second part of the code it will loop over this temp matrix, and sums all values of the input-matrix for each of the distinct numbers in the temp matrix. Explanation of the 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 bytes {($_ Z [Z] $_).kv.map(->\a,\b{b.flatmap(*[a..*]).sum -b[0;a]})} {($_ Z [Z] .skip).kv.map({$^b.flatmap(*[$^a..*]).sum})}
• $_ is the matrix input to the anonymous function • .skip is the input matrix with its first row removed • [Z] .skip is the transpose of the input matrix with its first row removed; that is, the transpose without its first column •$_ Z [Z] .skip zips the input matrix with its transpose-sans-first-column, producing a list ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
• .kv prefixes each pair with its index
• map({...}) maps over the the pairs, using a function which takes its first argument (the index) in $^a and its second (the row/column pair) in$^b

Try it online!

## Mathematica, 116 bytes

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

Input form

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

## Clojure, 98 bytes

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

Iterates over the input with row and column indexes (in a very verbose manner), creates a hash-map with the minimum of i and j as the key, merges hash-maps with + into a sorted-map, returns values.

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

returns an anonymous function; prints the results to the console, with a trailing newline. I probably need a different approach.

Iterates over the minimum of the rows and columns; prints the sum of x[,1] (the first column) and x[1,-1] the first row except for the first entry, then sets x to be a matrix equal to x[-1,-1] (i.e., x excluding its first row and column). Unfortunately, simply setting x=x[-1,-1] causes it to fail in the case of a square matrix, because when x is 2x2, the subsetting returns a vector rather than a matrix.

Try it online!

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

Try it here.

Alternative approach compared to my previous answer with arrays, which is still shorter than this one in the end (so I kinda wasted time trying this alternative approach).

General explanation:

Inspiration from @Riley's amazing 05AB1E answer
This answer uses a List and after every sum is calculated it removes the first column and first row from the List-matrix, like this:

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

Explanation of the 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 bytes

Similar to mbomb007's answer, but without 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])))]