양의 정수를 입력으로 포함하는 비어 있지 않은 행렬 / 숫자 배열을 사용하십시오. 이 순서대로 첫 번째 행과 열의 합계를 반환 한 다음 두 번째 행과 열의 합계를 반환하고 더 이상 행이나 열이 없을 때까지 계속합니다.

입력이 다음과 같다고 가정하십시오.

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브로드 캐스트로 최소 요소 단위를 계산하여 행렬을 제공합니다.

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. 이는 첫 번째 입력 값으로 그룹화 된 두 번째 입력의 합계를 계산합니다.

젤리 , 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

자바 스크립트 (ES6), 60 바이트

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

순진한 해결책이 더 나은 방법 일 수 있습니다.

Mathematica, 60 바이트

Luis Mendo의 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@#}&

하스켈, 50 49 바이트

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

온라인으로 사용해보십시오!

하나 이상의 요소가있는 행이 하나 이상있는 경우 결과는 첫 번째 행과 다른 모든 행의 머리의 합과 다른 모든 행의 꼬리가있는 재귀 호출이됩니다. 다른 모든 경우 결과는 빈 목록입니다.

편집 : Ørjan Johansen은 바이트를 저장했습니다. 감사!

옥타브 , 64 52 바이트

1 바이트를 절약 한 @StewieGriffin에게 감사합니다!

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

이것은 익명 함수를 정의합니다.

온라인으로 사용해보십시오!

설명

이 코드는 MATL 답변 과 비슷합니다 (설명 참조).

와 동일한 동작을 이용 하여 1:size(x)대신에 2 바이트를 사용하여 저장 했습니다 . 또한 Stewie 덕분에 대신 1 바이트가 대신 사용되었습니다 .1:size(x,1)1:[a b]1:a1:rows(x')1:size(x,2)

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

전체 행렬을 합한 다음 다음 블록의 합을 빼서 재귀 적으로 작동합니다. 아마도 가장 효과적인 접근 방법은 아니지만 직관적입니다.

자바 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

그리고 코드의 두 번째 부분에서는이 임시 행렬을 반복하고 임시 행렬의 각 고유 숫자에 대한 입력 행렬의 모든 값을 합산합니다.

코드 설명 :

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

펄 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와 두 번째 (행 / 열 쌍) 을 취하는 함수를 사용하여 쌍을 매핑합니다.$^b
• $^b.flatmap(*[$^a..*]).sum$^a각 행 / 열 쌍 의 첫 번째 요소를 제거한 다음 나머지 모든 요소를 ​​합합니다.

어떤 생각 후에 나는 압축하기 전에 조옮김의 첫 번째 열을 벗기는 것이 첫 번째 솔루션에서와 같이 이중 기여 대각선 요소를 빼는 것과 같습니다. 그 빼기를 삭제하고 매핑 함수에 각 인수를 사용하면 한 번만 {...$^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])))]

온라인으로 사용해보십시오

파이썬 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

파이썬 배열의 숫자 배열을 가져와 합의 배열을 반환합니다.

시도 해봐!

설명

.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 바이트

솔루션에는 두 가지 기능이 필요합니다. 하나는 전역 배열을 만들고 두 번째는 호출하여 해당 배열에 합계를 반복적으로 추가합니다.

∇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인수 (기본적으로 2 개 차원 배열)과 같은 테이블을. 로 만들 수 있습니다 X←rows cols ⍴ 1 2 3 4....

R←⍬빈 변수를 전역 변수에 할당합니다 R.

g N 첫 번째와 동일한 인수로 두 번째 함수를 호출합니다.

⍴N차원을 제공합니다 N; 차원 중 하나가 0이면 더 이상 추가 할 행 / 열이 없습니다. 0∈⍴N차원에 0이 있으면 1을 반환합니다. →2+2×0∈⍴N행 번호 2에 2를 더한 ∈함수 반환 값의 2 배 : 0이 없으면 0을 ∈반환하고 함수는 2 행 (다음 행)으로 분기합니다. 0 이 있으면 ∈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);

온라인으로 사용해보십시오!

수학, 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}}] 또는 [{{....}, {....} ... {. ...}}]

클로저, 98 바이트

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

(아주 상세하게) 행과 열 인덱스 입력 반복 해는의 최소 해시 맵을 작성 i하고 j핵심으로, 병합의와 해시 - 매핑 +A가로 정렬 -지도, 반환 값.

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최초의 행과 열은 제외). 불행히도, x=x[-1,-1]정사각 행렬의 경우 단순히 설정 하면 실패합니다. 왜냐하면 x2x2 인 경우 하위 설정은 행렬이 아닌 벡터를 반환하기 때문입니다.

온라인으로 사용해보십시오!

자바 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 답변 에서 영감을 얻음
이 답변은 List를 사용하고 모든 합계가 계산 된 후 List-matrix에서 첫 번째 열과 첫 번째 행을 다음과 같이 제거합니다.

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

파이썬, 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])))]