入力として正の整数を含む空でない行列/数値配列を受け取ります。この順序で、最初の行と列の合計、次に2番目の行と列の合計を返し、行または列がなくなるまで続けます。

入力が次のとおりであると仮定します。

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

次に、出力は次のようになります。

45, 33, 16, 17

理由：2+9+1+7+10+10+2+4=45, 7+7+1+7+2+9=33, 6+4+2+4=16, 8+9=17。

テストケース：

テストケースの形式は次のとおりです。

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

配列として：

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

これはコードゴルフであるため、各言語で最も短いソリューションが優先されます。

MATL、16バイト

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

オンラインでお試しください！または、すべてのテストケースを確認します。

説明

例として、入力を考えます

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

このコード&n:w:!Xlは、列ベクトル[1; 2; 3; 4]と行ベクトルを作成します[1 2 3 4 5]。次にXl、broadcastを使用して要素ごとに最小値を計算します。

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

X:この行列を（列優先の順序で）列ベクトルに線形化します[1; 1; 1; 1; 1; 2; 2; ... ; 4]。このベクトルととして取得された線形化された入力行列はGX:、accumarray(... @sum)関数またはへの入力として渡され1XQます。これは、最初の入力の値でグループ化された2番目の入力の合計を計算します。

ゼリー、3バイト

ŒDS

オンラインでお試しください！

使い方

ŒDS

ŒD   diagonals
  S  vectorized sum

CJam、23 18バイト

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

スタック上の引数を予期し、結果をスタックに残す匿名ブロック。

オンラインでお試しください！

説明

[      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バイト

[ćOˆøŽ]¯2ôO

オンラインでお試しください！

説明

[   Ž ]       # 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バイト

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

素朴な解決策は、より良い方法かもしれません。

Mathematica、60バイト

ルイスメンドーのMATL回答に触発されました。

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

説明：Min~Array~Dimensions@#次のようなマトリックスを作成します。

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

次に、上記の奇妙な行列のPick[#,...,n]~Total~2番号nに対応する入力行列のエントリを取り出し、それらを合計します。最後に...~Table~{n,Min[d=Dimensions@#]}繰り返しnます。

これは、単純なアプローチよりも1バイト短くなります。

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

Haskell、50 49バイト

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

オンラインでお試しください！

少なくとも1つの要素を含む行が少なくとも1つある場合、結果は最初の行と他のすべての行の先頭の合計で、その後に他のすべての行の末尾を含む再帰呼び出しが続きます。他のすべての場合、結果は空のリストです。

編集：ØrjanJohansenがバイトを保存しました。ありがとう！

オクターブ、64 52バイト

1バイトを節約してくれた@StewieGriffinに感謝します！

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

これは、匿名関数を定義します。

オンラインでお試しください！

説明

コードは、MATLの回答に似ています（説明を参照）。

の1:size(x)代わりにを使用して2バイトが保存され、と同じ動作1:size(x,1)をするという事実を利用して1:[a b]い1:aます。また、Stewieのおかげ1:rows(x')で1:size(x,2)、の代わりにを使用して1バイトが保存されました。

k、19バイト

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

オンラインでお試しください！

説明：

           (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バイト

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

オクターブ、63 60バイト

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

オンラインでお試しください！

このマトリックスの答え：

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

上三角部分の行和のベクトルです：

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

プラスその下三角部分の列合計のベクトル：

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

私の答えはまさにコンピューティングです。

ジュリア、62バイト

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

行列全体を合計し、次のブロックの合計を減算することにより、再帰的に機能します。おそらく最も効果的なアプローチではありませんが、非常に直感的です。

Java 7、248バイト

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

ここで試してみてください。

一般的な説明：

入力配列の次元が4x6であるとします。コードの最初の部分では、一時行列を作成し、次のように入力します。

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

コードの2番目の部分では、この一時行列をループ処理し、一時行列内の個別の数値ごとに入力行列のすべての値を合計します。

コードの説明：

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バイト

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

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

• $_ 無名関数への行列入力です
• .skip 最初の行が削除された入力行列です
• [Z] .skip最初の行が削除された入力行列の転置です。つまり、最初の列のない転置
• $_ Z [Z] .skip 入力行列をtranspose-sans-first-columnで圧縮し、リストを作成します ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
• .kv 各ペアにインデックスをプレフィックスします
• map({...})最初の引数（インデックス）を取り$^a、2番目（行/列のペア）を受け取る関数を使用して、ペアをマッピングします。$^b
• $^b.flatmap(*[$^a..*]).sum$^a各行/列ペアの最初の要素を取り除き、残りのすべての要素を合計します

いくつかのことを考えた後、最初のソリューションのように、ジッピングの前に転置の最初の列を取り除くことは、二重に寄与する対角要素を引くことと同等であることに気付きました。これにより、その減算を削除し、マッピング関数への各引数を1回使用するだけで、{...$^a...$^b...}引数を匿名関数に渡す方法が元の関数よりも効率的になりました-> \a, \b {...a...b...}。

VIM、66、52のバイト

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>

オンラインでお試しください！

仕事のための間違ったツール...

ゼリー、10 バイト

Ḣ;Ḣ€SṄȧßS¿

値を出力する完全なプログラム

オンラインでお試しください！

どうやって？

Ḣ;Ḣ€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バイト

入力は2D numpy配列です。

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

オンラインで試す

Python 2、97バイト

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

オンラインでお試しください！

Pyth、16 15バイト

.es+>b+1k>@CQkk

数字の配列のPythonスタイルの配列を取り、合計の配列を返します。

それを試してみてください！

説明

.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バイト

ソリューションには2つの関数が必要です。1つはグローバル配列を作成し、もう1つはその配列に合計を再帰的に追加する関数を呼び出します。

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

∇関数を開始および終了します。両方fとgテーブルを引数として取ります（基本的に2D配列）。これらはで作成できますX←rows cols ⍴ 1 2 3 4...。

R←⍬空のベクトルをグローバル変数に割り当てますR。

g N 最初に与えられた同じ引数で2番目の関数を呼び出します。

⍴Nの次元を与えるN; ディメンションの1つがゼロの場合、追加する行/列はありません。0∈⍴N次元にゼロがある場合、1を返します。→2+2×0∈⍴N行番号2 + ∈関数の戻り値の2倍に∈分岐します。ゼロがない場合は0を返し、関数は行2（次の行）に分岐します。存在した場合であるゼロ、∈リターン1及びライン4に機能分岐（関数の終わり、そうreturn本質的に）。

/縮小演算子です。+右側の引数として指定されたリスト内のすべての要素に演算子（）である左側の引数を適用します。N[1;]テーブルの最初の行全体と最初の列をN[;1]提供します。(+/N[1;])+(+/N[;1])-N[1;1]最初の行と列を合計し、列合計と行合計の両方に加算されるため、左上隅の値を減算します。R←R,...新しく計算された値をグローバルベクトルに追加しRます。

次に、関数はそれ自体を呼び出します（行または列がなくなるまで再帰します）。⊃ピック演算子はリストから指定された要素を取得します。1⊃⍴N行2⊃⍴N数、列数を提供します。⍳1から指定された数値までのすべての数値を与えます。↓ドロップ演算子は、リストの先頭から要素を削除します。テーブルまたはベクターの要素にアクセスするときに複数のインデックスを指定すると（例N[1 2 3]：）、APLはそれぞれにアクセスします。そのため、1↓⍳1⊃⍴N最初の行（2, 3, 4, ..., N）を除く各行のインデックスを1↓⍳2⊃⍴N提供し、同様のベクトルを列に提供します。g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]最初の行または列なしで関数を再度呼び出します。

PHP、76バイト

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

オンラインでお試しください！

Mathematica、116バイト

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

入力フォーム

[{{5}}]、[{{1}、{4}}]、[{{7,2}}]または[{{....}、{....} ... {。 ...}}]

Clojure、98バイト

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

（非常に冗長な方法で）行と列のインデックスを持つ入力を反復処理は、最小とハッシュマップ作成iとj、キーなどを用いてハッシュマップをマージ+ソートマップに、戻り値。

R、102バイト

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

無名関数を返します。結果をコンソールに出力し、末尾に改行を付けます。おそらく別のアプローチが必要です。

最小の行と列を反復処理します。x[,1]（最初の列）とx[1,-1]最初のエントリを除く最初の行の合計を出力し、x等しい行列x[-1,-1]（つまり、x最初の行と列を除く）に設定します。残念ながら、2x2の場合、サブセット化はマトリックスではなくベクトルを返すx=x[-1,-1]ため、単純に設定すると正方マトリックスの場合は失敗しxます。

オンラインでお試しください！

Java 7、280 276バイト

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

ここで試してみてください。

アレイを使用した以前の回答と比較した代替アプローチは、最終的にはこれよりもまだ短いため、この代替アプローチを試すのに少し時間を費やしました。

一般的な説明：

@Rileyの驚くべき05AB1E回答からのインスピレーション
この回答はリストを使用し、すべての合計が計算された後、次のようにリストマトリックスから最初の列と最初の行を削除します。

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

コードの説明：

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バイト

mbomb007の答えに似ていますが、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])))]