Tổng của hàng và cột đầu tiên, sau đó là hàng thứ hai và cột, v.v.

31

Lấy một ma trận / mảng số không trống chứa các số nguyên dương làm đầu vào. Trả về, theo thứ tự này, tổng của hàng và cột đầu tiên, sau đó là hàng và cột thứ hai và tiếp tục cho đến khi không còn hàng hoặc cột nào nữa.

Giả sử đầu vào là:

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

Sau đó, đầu ra phải là:

45, 33, 16, 17

Bởi vì : 2+9+1+7+10+10+2+4=45, 7+7+1+7+2+9=33, 6+4+2+4=16, 8+9=17.

Các trường hợp thử nghiệm:

Các trường hợp thử nghiệm có định dạng sau:

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

Như mảng:

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

Đây là môn đánh gôn , giải pháp ngắn nhất trong mỗi ngôn ngữ sẽ thắng.

code-golf  math  matrix 
— Stewie Griffin
nguồn
2
@Jonathan ALLan, in số không mãi mãi là một chút khó khăn, vì vậy tôi nghĩ rằng tôi phải nói không với cái đó.
— Stewie Griffin
1
Chương trình Retina để chuyển đổi từ các ví dụ đẹp sang mảng Python.
— mbomb007
1
Nhìn vào các ví dụ. nhiệm vụ giải thích là sai. Cột thứ hai trong ví dụ đầu tiên là 10,7,7,1, hàng thứ hai là 9,7,7,2,9và tổng là 59. Và như vậy
— edc65
1
@ edc65 Nhìn vào các ví dụ, có vẻ như các số được sử dụng trong các tính toán trước đó không được sử dụng lại. Hoặc một cách khác, khi xem xét hàng thứ n, chỉ sử dụng các giá trị từ cột thứ n trở đi và bỏ qua các giá trị trong các cột từ 1 đến n-1.
— Brian J
1
@ Arc676 Quy tắc io tiêu chuẩn. Đối số chức năng là một trong những phương thức nhập được chấp nhận.
— Stewie Griffin

Câu trả lời:

10

MATL , 16 byte

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Hãy xem xét, như một ví dụ, đầu vào 

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

Mã &n:w:!Xlxây dựng vectơ cột [1; 2; 3; 4]và vectơ hàng [1 2 3 4 5]. Sau đó, Xltính toán phần tử tối thiểu với phát sóng, đưa ra ma trận

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

X:tuyến tính hóa ma trận này (theo thứ tự chính cột) vào vector cột [1; 1; 1; 1; 1; 2; 2; ... ; 4]. Vectơ này và ma trận đầu vào tuyến tính, thu được dưới dạng GX:, được truyền dưới dạng đầu vào cho accumarray(... @sum)hàm, hoặc 1XQ. Điều này sẽ tính tổng của đầu vào thứ hai được nhóm theo các giá trị của đầu vào đầu tiên.

— Luis Mendo
nguồn
5

CJam , 23 18 byte

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

Khối ẩn danh mong đợi đối số trên ngăn xếp và để lại kết quả trên ngăn xếp.

Hãy thử trực tuyến!

Giải trình

[      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.
— Mèo kinh doanh
nguồn
Đây không phải là một chút "gian lận" sao? Ý tôi là, bạn không đếm mã đầu vào và đầu ra trong số byte. Với cả đầu vào và đầu ra, nó chỉ dài hơn 1 byte:q~[{(:+\z}h;]2/::+p
— FrodCube
@FrodCube Nó được cho phép bởi sự đồng thuận meta .
— Mèo kinh doanh
2
Trên thực tế, về mặt kỹ thuật, nó sẽ có cùng độ dài với một chương trình đầy đủ, vì tôi có thể bỏ qua phần mở đầu [. Nhưng là một khối tôi nghĩ rằng tôi cần nó bởi vì nó cũng không cần phải nắm bắt toàn bộ ngăn xếp bên dưới.
— Mèo kinh doanh
4

JavaScript (ES6), 60 byte

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

Giải pháp ngây thơ, có thể là một cách tốt hơn.

— Sản phẩm sinh học
nguồn
4

Toán học, 60 byte

Lấy cảm hứng từ câu trả lời MATL của Luis Mendo .

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

Giải trình: Min~Array~Dimensions@# xây dựng một ma trận như sau:

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

Sau đó Pick[#,...,n]~Total~2chọn ra các mục của ma trận đầu vào tương ứng với sốn trong ma trận kỳ lạ ở trên và tính tổng chúng. Cuối cùng ...~Table~{n,Min[d=Dimensions@#]}lặp đi lặp lại n.

Đây là 1 byte ngắn hơn so với cách tiếp cận ngây thơ:

{#[[n,n;;]],#[[n+1;;,n]]}~Total~2~Table~{n,Min@Dimensions@#}&
— Không phải là một cái cây
nguồn
4

Haskell, 50 49 byte

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

Hãy thử trực tuyến!

Nếu có ít nhất một hàng có ít nhất một phần tử, kết quả là tổng của hàng đầu tiên và các đầu của tất cả các hàng khác theo sau là một cuộc gọi đệ quy với đuôi của tất cả các hàng khác. Trong tất cả các trường hợp khác, kết quả là danh sách trống.

Chỉnh sửa: Ørjan Johansen đã lưu một byte. Cảm ơn!

— nimi
nguồn
4

Octave , 64 52 byte

Cảm ơn @StewieGriffin vì đã tiết kiệm 1 byte!

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

Điều này xác định một chức năng ẩn danh.

Hãy thử trực tuyến!

Giải trình

Mã này tương tự như câu trả lời MATL của tôi (xem giải thích ở đó).

Hai byte đã được lưu bằng cách sử dụng 1:size(x)thay vì 1:size(x,1), khai thác thực tế 1:[a b]hoạt động giống như 1:a. Ngoài ra, một byte đã được lưu bằng cách sử dụng 1:rows(x')thay vì 1:size(x,2), nhờ Stewie.

— Luis Mendo
nguồn
3

k, 19 byte

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

Hãy thử trực tuyến!

Giải trình:

           (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
— zgrep
nguồn
3

Octave , 63 60 byte

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

Hãy thử trực tuyến!

Câu trả lời cho ma trận này:

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

là vectơ của tổng hàng của phần tam giác trên của nó:

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

cộng với vectơ của tổng cột của phần tam giác dưới của nó:

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

đó chính xác là những gì câu trả lời của tôi là điện toán.

— eush77
nguồn
2

Julia , 62 byte

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

Hoạt động đệ quy bằng cách tổng hợp toàn bộ ma trận và sau đó trừ đi tổng của khối tiếp theo. Có lẽ không phải là cách tiếp cận hiệu quả nhất, nhưng trực quan độc đáo.

— Sói Julian
nguồn
2

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

Hãy thử nó ở đây.

Giải thích chung:

Giả sử mảng đầu vào có kích thước 4x6. Phần đầu tiên của mã sẽ tạo ra một ma trận tạm thời và điền vào nó như sau:

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

Và trong phần thứ hai của mã, nó sẽ lặp qua ma trận tạm thời này và tính tổng tất cả các giá trị của ma trận đầu vào cho mỗi số riêng biệt trong ma trận tạm thời.

Giải thích về mã:

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
— Kevin Cruijssen
nguồn
2

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})}
  • $_ là đầu vào ma trận cho hàm ẩn danh
  • .skip là ma trận đầu vào với hàng đầu tiên được loại bỏ
  • [Z] .skiplà chuyển vị của ma trận đầu vào với hàng đầu tiên được loại bỏ; đó là, chuyển vị mà không có cột đầu tiên của nó
  • $_ Z [Z] .skip nén ma trận đầu vào với cột chuyển tiếp-sans-đầu tiên, tạo ra một danh sách ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
  • .kv tiền tố mỗi cặp với chỉ số của nó
  • map({...})ánh xạ qua các cặp, sử dụng hàm lấy đối số thứ nhất (chỉ mục) trong $^avà cặp thứ hai (cặp hàng / cột) trong$^b
  • $^b.flatmap(*[$^a..*]).sumloại bỏ các $^aphần tử đầu tiên của mỗi cặp hàng / cột, sau đó tính tổng tất cả các phần tử còn lại

Sau một số suy nghĩ, tôi nhận ra rằng tước bỏ cột đầu tiên của chuyển vị trước khi nén là tương đương với việc trừ các phần tử đường chéo đóng góp gấp đôi, như trong giải pháp đầu tiên của tôi. Điều đó cho phép tôi xóa phép trừ đó và chỉ sử dụng từng đối số cho hàm ánh xạ một lần khiến {...$^a...$^b...}phương thức truyền đối số cho hàm ẩn danh hiệu quả hơn so với ban đầu -> \a, \b {...a...b...}.

— Sean
nguồn
1

Thạch , 10 byte

Ḣ;Ḣ€SṄȧßS¿

Một chương trình đầy đủ in các giá trị

Hãy thử trực tuyến!

Làm sao?

Ḣ;Ḣ€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)
— Jonathan Allan
nguồn
1

Bình thường, 16 15 byte

.es+>b+1k>@CQkk

Lấy một mảng các kiểu số python, trả về một mảng tổng.

Thử nó!

Giải trình

.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
— KarlKastor
nguồn
1

GNU APL 1.7, 123 byte

Giải pháp yêu cầu hai hàm: một tạo ra một mảng toàn cục và các cuộc gọi thứ hai, nối tiếp đệ quy các khoản tiền vào mảng đó.

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

∇bắt đầu và kết thúc chức năng Cả hai fvà glấy các bảng làm đối số (về cơ bản là mảng 2D). Đây có thể được tạo ra với X←rows cols ⍴ 1 2 3 4....

R←⍬gán một vectơ trống cho biến toàn cục R.

g N gọi hàm thứ hai với cùng một đối số được đưa ra cho hàm thứ nhất.

⍴Nđưa ra kích thước của N; khi một trong các kích thước bằng 0, sẽ không có thêm hàng / cột nào để thêm vào. 0∈⍴Ntrả về 1 nếu có số 0 trong các kích thước. →2+2×0∈⍴Ncác nhánh cho dòng số 2 cộng với 2 lần giá trị trả về của ∈hàm: nếu không có 0, ∈trả về 0 và các nhánh của dòng cho dòng 2 (dòng tiếp theo). Nếu có là một số không, ∈lợi nhuận 1 và các ngành chức năng để dòng 4 (kết thúc chức năng, vì vậy returnvề cơ bản).

/là toán tử giảm. Nó áp dụng đối số bên trái, là một toán tử ( +) cho mọi phần tử trong danh sách được đưa ra làm đối số bên phải. N[1;]đưa ra toàn bộ hàng đầu tiên của bảng và N[;1]đưa ra cột đầu tiên. (+/N[1;])+(+/N[;1])-N[1;1]tính tổng hàng và cột đầu tiên và trừ giá trị ở góc trên bên trái vì nó được thêm cả vào tổng cột và tổng hàng. R←R,...nối giá trị mới được tính vào vectơ toàn cầu R.

Hàm sau đó tự gọi (lặp lại cho đến khi không còn hàng hoặc cột). Các ⊃nhà khai thác lựa chọn có được những yếu tố nhất định từ danh sách. 1⊃⍴Nđưa ra số lượng hàng, 2⊃⍴Nsố lượng cột. ⍳đưa ra tất cả các số từ 1 đến số được chỉ định. Các ↓nhà điều hành thả loại bỏ các yếu tố từ sự khởi đầu của danh sách. Nếu bạn đưa ra nhiều chỉ số khi truy cập các phần tử từ bảng hoặc vectơ (ví dụ N[1 2 3]), APL sẽ truy cập từng phần. Do đó, 1↓⍳1⊃⍴Nđưa ra các chỉ số của mỗi hàng không bao gồm hàng đầu tiên ( 2, 3, 4, ..., N) và 1↓⍳2⊃⍴Nđưa ra một vectơ tương tự nhưng cho các cột. g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]gọi lại hàm nhưng không có hàng hoặc cột đầu tiên.

— Arc676
nguồn
0

Toán học, 116 byte

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

Mẫu đầu vào

[{{5}}], [{{1}, {4}}], [{{7,2}}] hoặc [{{....}, {....} ... {. ...}}]

— J42161217
nguồn
0

Clojure, 98 byte

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

Lặp lại các đầu vào với các chỉ mục hàng và cột (theo cách rất dài dòng), tạo ra một bản đồ băm với mức tối thiểu ivà jlà khóa, hợp nhất các bản đồ băm với +một bản đồ được sắp xếp, trả về các giá trị.

— NikoNyrh
nguồn
0

R, 102 byte

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

trả về một hàm ẩn danh; in kết quả ra bàn điều khiển, với một dòng mới. Tôi có lẽ cần một cách tiếp cận khác.

Lặp lại trên mức tối thiểu của các hàng và cột; in tổng của x[,1](cột đầu tiên) và x[1,-1]hàng đầu tiên ngoại trừ mục nhập đầu tiên, sau đó đặt xthành ma trận bằng x[-1,-1](nghĩa là xkhông bao gồm hàng và cột đầu tiên của nó). Thật không may, chỉ đơn giản là thiết lập x=x[-1,-1]khiến nó bị lỗi trong trường hợp ma trận vuông, bởi vì khix là 2x2, tập hợp con trả về một vectơ chứ không phải là ma trận.

Hãy thử trực tuyến!

— Giuseppe
nguồn
0

Java 7, 280 276 byte

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

Hãy thử nó ở đây.

Cách tiếp cận khác so với câu trả lời trước của tôi với mảng, vẫn còn ngắn hơn câu trả lời cuối cùng (vì vậy tôi hơi lãng phí thời gian để thử phương pháp thay thế này).

Giải thích chung:

Cảm hứng từ @Riley 's câu trả lời tuyệt vời 05AB1E
câu trả lời này sử dụng một danh sách và sau mỗi tổng được tính toán nó loại bỏ cột đầu tiên và hàng đầu tiên từ danh sách ma trận, như thế này:

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

Giải thích về mã:

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
— Kevin Cruijssen
nguồn
0

Python, 93 byte

Tương tự như câu trả lời của mbomb007, nhưng không có 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])))]
— PattuX
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.