Thử thách:

Cho ma trận đầu vào vuông A , đệm ma trận với một hàng và một cột ở cả bốn phía.

• Giá trị của mỗi phần tử ở hàng trên cùng và dưới cùng phải là tổng của các phần tử trong mỗi cột tương ứng.
• Giá trị của mỗi phần tử trong cột bên trái và bên phải phải là tổng của các phần tử trong mỗi hàng tương ứng.
• Giá trị của các phần tử ở góc trên bên trái và góc dưới bên phải phải là tổng của các phần tử trên đường chéo
• Giá trị của các phần tử ở góc trên bên phải và góc dưới bên trái phải là tổng của các phần tử trong đường chéo.

Thí dụ:

A = 
1   5   3
3   2   4
2   5   5

Output:
 8    6   12   12    7
 9    1    5    3    9
 9    3    2    4    9
12    2    5    5   12
 7    6   12   12    8

Giải trình:

Các phần tử trên cùng bên trái và dưới cùng bên phải là tổng của đường chéo 1 + 2 + 5 = 8 . Các phần tử trên cùng bên phải và dưới cùng bên trái là tổng của đường chéo 2 + 2 + 3 = 7 .

Hàng trên cùng và dưới cùng (trừ các góc) là tổng của mỗi cột trong A : 1 + 3 + 2 = 6 , 5 + 2 + 5 = 12 và 3 + 4 + 5 = 12 . Tương tự, cột bên trái và bên phải (trừ các góc) là tổng của mỗi hàng của A : 1 + 5 + 3 = 9 , 3 + 2 + 4 = 9 và 2 + 5 + 5 = 12 .

Đầu vào:

• Một ma trận vuông không rỗng, với các số nguyên không âm.
• Định dạng tùy chọn

Đầu ra:

• Ma trận đệm như đã giải thích ở trên
• Định dạng tùy chọn, nhưng nó phải giống với định dạng đầu vào

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

Sử dụng các bài nộp trong thử thách này nếu bạn muốn chuyển đổi định dạng đầu vào thành một định dạng phù hợp hơn (ví dụ [[1, 5],[0, 2]]).

0
----------------
0 0 0
0 0 0
0 0 0

1 5
0 2
----------------
3 1 7 5
6 1 5 6
2 0 2 2
5 1 7 3

17   24    1    8   15
23    5    7   14   16
 4    6   13   20   22
10   12   19   21    3
11   18   25    2    9 
----------------
65   65   65   65   65   65   65
65   17   24    1    8   15   65
65   23    5    7   14   16   65
65    4    6   13   20   22   65
65   10   12   19   21    3   65
65   11   18   25    2    9   65
65   65   65   65   65   65   65

15    1    2   12
 4   10    9    7
 8    6    5   11
 3   13   14    0
----------------
30   30   30   30   30   30
30   15    1    2   12   30
30    4   10    9    7   30
30    8    6    5   11   30
30    3   13   14    0   30
30   30   30   30   30   30

Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất trong mỗi ngôn ngữ sẽ thắng. Giải thích rất được khuyến khích.

Octave , 64 byte

Cảm ơn Tom Carpenter vì đã tiết kiệm được 4 byte và sửa lỗi tôi gặp phải trong mã gốc!

@(a)[b=(t=@trace)(a),c=sum(a),d=t(flip(a));z=sum(a,2),a,z;d,c,b]

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

Giải trình:

@(a)                 % Anonymous function that takes the matrix 'a' as input
 [ ... ]             % Concatenate everything inside to a single matrix
  b=(t=@trace)(a),   % Clever trick by Tom Carpenter. Save a function handle 
                     % for 't=trace', and call it with 'a' as input
                     % Save the result in the variable 'b'
  c=sum(a)           % Sum of all columns of 'a'
  d=t(flip(a));      % Save the trace of 'a' flipped as a variable 'd', while 
                     % concatenating [b,c,d] horizontally at the same time, creating the 
                     % first row of the output
  z=sum(a,2)         % The sum of each row of the input, and store it in a variable 'z'
  ,a,z;              % Concatenate it with 'a' and 'z' again, to create the middle part of the output
 d,c,b]              % Add [d,c,b] to complete the bottom row

_{Lưu ý, tôi đã viết điều này rất lâu sau khi tôi đăng thử thách.}

Thạch , 27 byte

,UŒDḢ$S$€,Ṛ$j€SW€jSẋ¥€2$j"$

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

MATL , 27 26 byte

,!tXswyv]GXds5L(PGPXds5L(P

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

,        % Do the following twice
  !      %   Tranpose. Takes input implititly in the first iteration
  t      %   Duplicate
  Xs     %   Row vector with the sum of each column
  wy     %   Push a copy to the bottom of the stack
  v      %   Concatenate stack vertically. This attaches the sum of
         %   each row (first iteration) and column (second), leaving 
         %   the matrix with the correct orientation (transposed twice)
]        % End
G        % Push input again
Xds      % Column vector with the diagonal of the matrix. Sum of vector
5L(      % Write that into first and last entries of the result matrix
         % matrix; that is, its upper-left and lower-right corners
P        % Flip result matrix vertically
GP       % Push input matrix vertically flipped
Xds      % Diagonal, sum. Since the input has been vertically flipped,
         % this gives the sum of the anti-diagonal of the input.
5L(      % Write that into the upper-left and lower-right corners of
         % the verticallly flipped version of the result matrix
P        % Flip vertically again, to restore initial orientation
         % Implicitly display

APL (Dyalog) , 37 byte

(d,+⌿,d∘⌽)⍪(+/,⊢,+/)⍪d∘⌽,+⌿,d←+/1 1∘⍉

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

1 1∘⍉ đường chéo (lit. thu gọn cả hai trục thành một)

d← lưu trữ chức năng đó như d và áp dụng nó cho đối số

+⌿ trả trước các khoản tiền cột

d∘⌽, trả trước d áp dụng cho đối số đảo ngược

(... )⍪ ngăn xếp sau trên đầu trang:

 +/,⊢,+/ tổng hàng, đối số không thay đổi, tổng hàng

(... )⍪ ngăn xếp sau trên đầu trang:

 d,+⌿,d∘⌽ áp dụng cho đối số, tổng cột, d áp dụng cho đối số đảo ngược

Thạch , 26 byte

ŒDµḊṖѵ€1¦ŒḌU
S;;S
Ç€Zµ⁺ÑÑ

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

Trông đáng ngạc nhiên khác với giải pháp của Erik .

Cuối cùng tôi cũng hiểu được cách ¦hoạt động (bằng cách gỡ lỗi thông qua mã của Jelly, lol). Quá tệ, nó đòi hỏi €phải làm việc Çtrong trường hợp của tôi.

Giải trình

Mã sử ​​dụng ba liên kết. Liên kết của trình trợ giúp đầu tiên đệm một vectơ với tổng của nó ở cả hai đầu, liên kết trợ giúp thứ hai sửa hai góc của ma trận và liên kết chính gọi chúng một cách thích hợp.

Ç€Zµ⁺ÑÑ    Main link. Argument: M (matrix)
Ç            Call the first helper link (pad row with sums)...
 €           ...on each row of the matrix.
  Z          Transpose, so that the second invocation uses the columns.
   µ         Begin a new monadic chain.
    ⁺        Repeat the previous chain (everything up to here).
     ÑÑ      Call the second helper link twice on the whole matrix.

S;;S    First helper link. Argument: v (1-dimensional list)
S         Sum the argument list.
 ;        Append the argument list to the sum.
  ;       Append...
   S      ...the sum of the argument list.

ŒDµḊṖѵ€1¦ŒḌU    Second helper link. Argument: M (matrix)
ŒD                 Get the diagonals of the matrix, starting with the main diagonal.
  µ                Begin a new monadic chain.
      µ€           Perform the following actions on each diagonal...
        1¦         ...and keep the result for the first item (main diagonal):
   Ḋ                 Remove the first item (incorrect top corner).
    Ṗ                Remove the last item (incorrect bottom corner).
     Ñ               Call the first helper link on the diagonal to pad it with its sum.
          ŒḌ       Convert the diagonals back to the matrix.
            U      Reverse each row, so that consecutive calls fix the other corners.

Python 3 , 155 byte

Đây là gợi ý của @LeakyNun, giúp tiết kiệm 54 byte . Sau đó tôi tự đánh gôn nó một chút.

def f(m):l=len(m);r=range(l);s=sum;b=[s(m[i][i]for i in r)];c=[s(m[i][l+~i]for i in r)];d=[*map(s,zip(*m))];return[b+d+c,*[[s(a),*a,s(a)]for a in m],c+d+b]

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

Giải pháp ban đầu - Python 3 , 216 byte

def f(m):l=len(m);r,s=range(l),sum;a,b,c,d=s(m[i][i]for i in r),s(m[i][l-i-1]for i in r),[s(m[i][j]for j in r)for i in r],[s(m[i][j]for i in r)for j in r];print([[a]+d+[b]]+[[c[i]]+m[i]+[c[i]]for i in r]+[[b]+d+[a]])

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

Con trăn 2 , 268 250 184 174 byte

10 nhờ Stewie Griffin

from numpy import *
a,c,v,s=sum,trace,vstack,matrix(input())
l,r,d,e=a(s,0),a(s,1),c(s),c(fliplr(s))
print hstack((v(([[d]],r,[[e]])),v((l,s,l)),v(([[e]],r,[[d]])))).tolist()

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

Một số giải thích Đầu vào được tải lên dưới dạng ma trận. Đầu tiên mã tính tổng của mỗi cột và mỗi hàng bằng cách sử dụng numpy.sum. Sau đó, nó tính tổng của đường chéo bằng numpy.trace. Sau đó, nó có được đường chéo khác bằng cách lật trái phải trên ma trận. Cuối cùng, nó sử dụng numpy.vstack và numpy.hstack để dán các mảnh lại với nhau.

R, 129 byte

pryr::f(t(matrix(c(d<-sum(diag(m)),c<-colSums(m),a<-sum(diag(m[(n<-nrow(m)):1,])),t(matrix(c(r<-rowSums(m),m,r),n)),a,c,d),n+2)))

Một hàm ẩn danh lấy ma trận vuông làm đầu vào. Tôi sẽ đăng một lời giải thích nếu có quan tâm.

PHP , 211 byte

<?foreach($_GET as$l=>$r){$y=0;foreach($r as$k=>$c){$y+=$c;$x[$k]+=$c;$l-$k?:$d+=$c;($z=count($_GET))-1-$k-$l?:$h+=$c;}$o[]=[-1=>$y]+$r+[$z=>$y];}$o[]=[-1=>$h]+$x+[$z=>$d];print_r([-1=>[-1=>$d]+$x+[$z=>$h]]+$o);

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

Mở rộng

foreach($_GET as$l=>$r){
  $y=0; # sum for a row
  foreach($r as$k=>$c){
    $y+=$c; # add to sum for a row
    $x[$k]+=$c; # add to sum for a column and store in array
    $l-$k?:$d+=$c; # make the diagonal sum left to right
    ($z=count($_GET))-1-$k-$l?:$h+=$c; # make the diagonal sum right to left
  }
  $o[]=[-1=>$y]+$r+[$z=>$y]; # add to result array the actual row with sum of both sides
}
$o[]=[-1=>$h]+$x+[$z=>$d]; # add to result array the last array
print_r([-1=>[-1=>$d]+$x+[$z=>$h]]+$o); #output after adding the first array to the result array

Python 3 , 125 byte

from numpy import*
f=lambda m,t=trace,s=sum:c_[r_[t(m),s(m,1),t(m[::-1])],c_[s(m,0),m.T,s(m,0)].T,r_[t(m[::-1]),s(m,1),t(m)]]

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

Hơi vô dụng:

import numpy as np

def f_expanded(m):
    return np.c_[np.r_[np.trace(m), np.sum(m, 1), np.trace(m[::-1])],
                 np.c_[np.sum(m, 0), m.T, np.sum(m, 0)].T,
                 np.r_[np.trace(m[::-1]), np.sum(m, 1), np.trace(m)]]

Điều này nhận đầu vào được định dạng như một mảng numpy, sau đó sử dụng các công cụ np.c_và np.r_lập chỉ mục để xây dựng một mảng mới trong một lần. np.tracevà np.sumđược sử dụng để tính toán các khoản tiền dọc theo các đường chéo và mọi nơi khác, tương ứng. Tđược sử dụng để chuyển vị trước và sau khi ghép các khoản tiền vì nó ngắn hơn so với việc tạo tất cả các mảng 2 chiều và sử dụng np.r_. m[::-1]lưu byte khi so sánh với rot90(m)hoặc fliplr(m)để tìm dấu vết cho đường chéo thứ hai.

JavaScript (ES6), 170 byte

(a,m=g=>a.map((_,i)=>g(i)),s=x=>eval(x.join`+`))=>[[d=s(m(i=>a[i][i])),...c=m(i=>s(m(j=>a[j][i]))),g=s(m(i=>a[i][a.length-i-1]))],...a.map(b=>[r=s(b),...b,r]),[g,...c,d]]

Đầu vào và đầu ra là một mảng 2D của các số.

Giải thích

(a,                             // input matrix: a
    m=g=>a.map((_,i)=>g(i)),    // helper func m: map by index
    s=x=>eval(x.join`+`)        // helper func s: array sum
) =>
[
    [
        d = s(m(i=>a[i][i])),           // diagonal sum: d
        ...c=m(i=>s(m(j=>a[j][i]))),    // column sums: c
        g = s(m(i=>a[i][a.length-i-1])) // antidiagonal sum: g
    ],
    ...a.map(b=>[r = s(b), ...b, r]),   // all rows with row sums on each end
    [g, ...c, d]                        // same as top row, with corners flipped
]

Kiểm tra đoạn trích

Đầu vào / đầu ra đã được định dạng với các dòng và tab mới.

f=
(a,m=g=>a.map((_,i)=>g(i)),s=x=>eval(x.join`+`))=>[[d=s(m(i=>a[i][i])),...c=m(i=>s(m(j=>a[j][i]))),g=s(m(i=>a[i][a.length-i-1]))],...a.map(b=>[r=s(b),...b,r]),[g,...c,d]]

let tests=[[[0]],[[1,5],[0,2]],[[17,24,1,8,15],[23,5,7,14,16],[4,6,13,20,22],[10,12,19,21,3],[11,18,25,2,9]],[[15,1,2,12],[4,10,9,7],[8,6,5,11],[3,13,14,0]]];

<select id=S oninput="I.value=S.selectedIndex?tests[S.value-1].map(s=>s.join`\t`).join`\n`:''"><option>Tests<option>1<option>2<option>3<option>4</select> <button onclick="O.innerHTML=I.value.trim()?f(I.value.split`\n`.map(s=>s.trim().split(/\s+/g))).map(s=>s.join`\t`).join`\n`:''">Run</button><br><textarea rows=6 cols=50 id=I></textarea><pre id=O>

LOGO , 198 byte

to g :v[:h reduce "+ :v]
op(se :h :v :h)
end
to f :s[:a reduce "+ map[item # ?]:s][:b reduce "+ map[item # reverse ?]:s][:c apply "map se "sum :s]
op `[[,:a ,@:c ,:b],@[map "g :s][,:b ,@:c ,:a]]
end

Hàm flấy trong một ma trận dưới dạng danh sách 2D, sau đó xuất ma trận kết quả. glà chức năng trợ giúp.