Ambil array matriks / numerik yang tidak kosong yang berisi bilangan bulat positif sebagai input. Kembali, dalam urutan ini, jumlah dari baris dan kolom pertama, lalu baris dan kolom kedua dan lanjutkan sampai tidak ada lagi baris atau kolom.

Misalkan inputnya adalah:

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

Maka outputnya harus:

45, 33, 16, 17

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

Kasus uji:

Test case ada dalam format berikut:

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

Sebagai array:

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

Ini adalah kode-golf sehingga solusi terpendek dalam setiap bahasa menang.

MATL , 16 byte

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

Cobalah online! Atau verifikasi semua kasus uji .

Penjelasan

Pertimbangkan, sebagai contoh, input

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

Kode &n:w:!Xlmembangun vektor kolom[1; 2; 3; 4] dan vektor baris [1 2 3 4 5]. Kemudian Xlmenghitung elemen minimum dengan siaran, yang memberikan matriks

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

X:linearkan matriks ini (dalam urutan kolom-utama) ke dalam vektor kolom [1; 1; 1; 1; 1; 2; 2; ... ; 4]. Vektor ini dan matriks input linierisasi, diperoleh sebagai GX:, dilewatkan sebagai input ke accumarray(... @sum)fungsi, atau 1XQ. Ini menghitung jumlah input kedua yang dikelompokkan berdasarkan nilai input pertama.

Jelly , 3 byte

ŒDS

Cobalah online!

Bagaimana itu bekerja

ŒDS

ŒD   diagonals
  S  vectorized sum

CJam , 23 18 byte

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

Blok anonim mengharapkan argumen di stack dan membiarkan hasilnya di stack.

Cobalah online!

Penjelasan

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

[ćOˆøŽ]¯2ôO

Cobalah online!

Penjelasan

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

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

Solusi naif, mungkin cara yang lebih baik.

Mathematica, 60 byte

Terinspirasi oleh jawaban MATL dari Luis Mendo .

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

Penjelasan: Min~Array~Dimensions@#membuat matriks seperti berikut:

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

Kemudian Pick[#,...,n]~Total~2mengambil entri dari matriks input yang sesuai dengan nomor ndalam matriks aneh di atas, dan menjumlahkannya. Akhirnya...~Table~{n,Min[d=Dimensions@#]} iterates over n.

Ini 1 byte lebih pendek dari pendekatan naif:

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

Haskell, 50 49 byte

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

Cobalah online!

Jika setidaknya ada satu baris dengan setidaknya satu elemen, hasilnya adalah jumlah dari baris pertama dan kepala dari semua baris lainnya diikuti oleh panggilan rekursif dengan ekor semua baris lainnya. Dalam semua kasus lain, hasilnya adalah daftar kosong.

Sunting: Ørjan Johansen menyimpan satu byte. Terima kasih!

Oktaf , 64 52 byte

Terima kasih kepada @StewieGriffin karena telah menghemat 1 byte!

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

Ini mendefinisikan fungsi anonim.

Cobalah online!

Penjelasan

Kode ini mirip dengan jawaban MATL saya (lihat penjelasan di sana).

Dua byte telah disimpan menggunakan 1:size(x)alih-alih 1:size(x,1), mengeksploitasi fakta yang 1:[a b]berperilaku sama dengan 1:a. Juga, satu byte telah disimpan menggunakan 1:rows(x')bukan 1:size(x,2), terima kasih kepada Stewie.

k, 19 byte

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

Cobalah online!

Penjelasan:

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

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

Cobalah online! atau Coba semua tes

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

Oktaf , 63 60 byte

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

Cobalah online!

Jawaban untuk matriks ini:

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

adalah vektor jumlah baris dari bagian segitiga atasnya:

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

ditambah vektor jumlah kolom bagian segitiga bawahnya:

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

yang tepatnya jawaban saya adalah komputasi.

Julia , 62 byte

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

Bekerja secara rekursif dengan menjumlahkan seluruh matriks dan kemudian mengurangi jumlah blok berikutnya. Mungkin bukan pendekatan yang paling efektif, tetapi intuitif baik.

Java 7, 248 byte

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

Coba di sini.

Penjelasan umum:

Katakanlah array input memiliki dimensi 4x6. Bagian pertama dari kode akan membuat matriks temp dan mengisinya sebagai berikut:

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

Dan di bagian kedua kode itu akan mengulangi matriks temp ini, dan menjumlahkan semua nilai input-matriks untuk masing-masing angka yang berbeda dalam matriks temp.

Penjelasan kode:

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 byte

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

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

• $_ adalah input matriks ke fungsi anonim
• .skip adalah matriks input dengan baris pertama dihapus
• [Z] .skipadalah transpos dari matriks input dengan baris pertama dihapus; yaitu, transpos tanpa kolom pertama
• $_ Z [Z] .skip zip matriks input dengan kolom transpose-sans-first-nya, menghasilkan daftar ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
• .kv awalan setiap pasangan dengan indeksnya
• map({...})memetakan pasangan, menggunakan fungsi yang mengambil argumen pertama (indeks) $^adan yang kedua (pasangan baris / kolom) di$^b
• $^b.flatmap(*[$^a..*]).summenghapus $^aelemen pertama dari setiap pasangan baris / kolom, lalu menjumlahkan semua elemen yang tersisa

Setelah beberapa pemikiran saya menyadari bahwa melepaskan kolom pertama dari transpos sebelum zipping sama dengan mengurangi elemen diagonal yang berkontribusi ganda, seperti dalam solusi pertama saya. Itu membuat saya menghapus pengurangan itu, dan menggunakan setiap argumen untuk fungsi pemetaan hanya sekali membuat {...$^a...$^b...}metode meneruskan argumen ke fungsi anonim lebih efisien daripada yang asli -> \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>

Try it online!

The wrong tool for the job...

Jelly, 10 bytes

Ḣ;Ḣ€SṄȧßS¿

A full program that prints the values

Try it online!

How?

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

Input is a 2D numpy array.

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

Try it online

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

Try it online!

Pyth, 16 15 bytes

.es+>b+1k>@CQkk

Takes a python-style array of arrays of numbers, returns an array of sums.

Try it!

Explanation

.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

Solution requires two functions: one creates a global array and the calls the second, which recursively appends the sums to that array.

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

∇ begins and ends the function. Both f and g take tables as arguments (essentially 2D arrays). These can be created with X←rows cols ⍴ 1 2 3 4....

R←⍬ assigns an empty vector to global variable R.

g N calls the second function with the same argument given to the first.

⍴N gives the dimensions of N; when one of the dimensions is zero, there are no more rows/columns to add up. 0∈⍴N returns 1 if there is a zero in the dimensions. →2+2×0∈⍴N branches to line number 2 plus 2 times the return value of the ∈ function: if there is no zero, ∈ returns 0 and the function branches to line 2 (the next line). If there is a zero, ∈ returns 1 and the function branches to line 4 (the end of the function, so return essentially).

/ is the reduce operator. It applies the left argument, which is an operator (+) to every element in the list given as the right argument. N[1;] gives the entire first row of the table and N[;1] gives the first column. (+/N[1;])+(+/N[;1])-N[1;1] sums the first row and column and subtracts the value in the upper left corner because it gets added both in the column sum and the row sum. R←R,... appends the newly calculated value to the global vector R.

The function then calls itself (recurse until no more rows or columns). The ⊃ pick operator obtains the specified element from the list. 1⊃⍴N gives the number of rows, 2⊃⍴N the number of columns. ⍳ gives all numbers from 1 to the specified number. The ↓ drop operator removes elements from the beginning of the list. If you give multiple indices when accessing elements from a table or vector (e.g. N[1 2 3]), APL accesses each one. Therefore, 1↓⍳1⊃⍴N gives the indices of each row excluding the first one (2, 3, 4, ..., N) and 1↓⍳2⊃⍴N gives a similar vector but for the columns. g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N] calls the function again but without the first row or column.

PHP, 76 Bytes

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

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