Meydan okuma:

Bir kare giriş matrisi A verildiğinde , matrisi dört tarafı da bir satır ve bir sütunla doldurun.

• Üst ve alt satırdaki her bir öğenin değeri, karşılık gelen her bir sütundaki öğelerin toplamı olmalıdır.
• Sol ve sağ sütundaki her bir öğenin değeri, karşılık gelen her satırdaki öğelerin toplamı olmalıdır.
• Sol üst ve sağ alt köşedeki öğelerin değeri, köşegen üzerindeki öğelerin toplamı olmalıdır
• Sağ üst ve alt sol köşedeki öğelerin değeri köşegen içindeki öğelerin toplamı olmalıdır.

Örnek:

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

Açıklama:

Sol üst ve sağ alt öğeler, köşegen 1 + 2 + 5 = 8'in toplamıdır . Sağ üst ve sol alt öğeler, köşegensel 2 + 2 + 3 = 7'nin toplamıdır .

Üst ve alt sıra (köşeler hariç) A : 1 + 3 + 2 = 6 , 5 + 2 + 5 = 12 ve 3 + 4 + 5 = 12 sütunlarının her birinin toplamıdır . Benzer şekilde, sol ve sağ sütun (köşeler hariç), A : 1 + 5 + 3 = 9 , 3 + 2 + 4 = 9 ve 2 + 5 + 5 = 12 sıralarının her birinin toplamıdır .

Giriş:

• Negatif olmayan tamsayılar içeren boş olmayan bir kare matris.
• İsteğe bağlı biçim

Çıktı:

• Matris yukarıda açıklandığı gibi dolgulu
• İsteğe bağlı biçim, ancak giriş biçimiyle aynı olmalıdır

Test durumları:

Giriş biçimini daha uygun bir biçime dönüştürmek istiyorsanız (örneğin ) bu zorlamadaki gönderileri kullanın [[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

Bu kod golf , yani her dilde en kısa çözüm kazanıyor. Açıklamalar şiddetle tavsiye edilir.

Oktav , 64 bayt

Her iki 4 bayt tasarruf Tom Carpenter sayesinde ve ben orijinal kodunda vardı bir hata düzeltme!

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

Çevrimiçi deneyin!

Açıklama:

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

_{Not, meydan okumayı gönderdikten uzun süre sonra yazdım.}

Jöle , 27 bayt

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

Çevrimiçi deneyin!

MATL , 27 26 bayt

,!tXswyv]GXds5L(PGPXds5L(P

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

açıklama

,        % 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 bayt

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

Çevrimiçi deneyin!

1 1∘⍉ köşegen (yanar, her iki ekseni birer birime daraltır)

d← bu işlevi d olarak saklayın ve argümana uygulayın

+⌿ sütun toplamlarını hazırla

d∘⌽,tersine çevrilmiş argümana uygulanan ön  hazırlık d

(… )⍪ Aşağıdakini üste istifleyin:

 +/,⊢,+/ satır toplamları, değiştirilmemiş argüman, satır toplamları

(… )⍪ Aşağıdakini üste istifleyin:

 d,+⌿,d∘⌽ argümana uygulanır, sütun toplamları, d ters argümana uygulanır

Jöle , 26 bayt

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

Çevrimiçi deneyin!

Erik'in çözümünden şaşırtıcı derecede farklı görünüyor .

Sonunda nasıl ¦çalıştığını anladım (Jelly'in kodu lol hata ayıklama yoluyla). Çok kötü , benim durumumda €çalışmak bir gerektirir Ç.

açıklama

Kod üç bağlantı kullanır. İlk yardımcı bağlantı, her iki ucunda da toplamı olan bir vektörü doldurur, ikinci yardımcı bağlantı matrisin iki köşesini sabitler ve ana bağlantı bunları uygun şekilde çağırır.

Ç€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 bayt

Bu, 54 bayt kazandıran @LeakyNun'in önerisidir . Daha sonra biraz kendim golf oynadım.

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]

Çevrimiçi deneyin!

İlk çözüm - Python 3 , 216 bayt

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

Çevrimiçi deneyin!

Python 2 , 268 250 184 174 bayt

Stewie Griffin'e 10 teşekkür

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

Çevrimiçi deneyin!

Bazı açıklamalar Giriş bir matris olarak yüklenir. İlk olarak, kod her sütun ve numpy.sum kullanarak her satırın toplamını hesaplar. Sonra köşegenlerin toplamını numpy.trace ile hesaplar. Bundan sonra matris üzerinde sol-sağ çevirerek diğer köşegeni elde eder. Son olarak, parçaları birbirine yapıştırmak için numpy.vstack ve numpy.hstack kullanır.

R, 129 bayt

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

Girdi olarak kare matris alan anonim bir işlev. İlgi olursa bir açıklama gönderirim.

PHP , 211 bayt

<?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);

Çevrimiçi deneyin!

Expanded

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 bayt

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

Çevrimiçi deneyin!

Biraz ungolfed:

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

Bu, bir rakam dizisi olarak biçimlendirilmiş girdiyi alır, daha sonra bir seferde yeni bir dizi oluşturmak için np.c_ve np.r_dizin oluşturma araçlarını kullanır . np.traceve np.sumsırasıyla köşegenler boyunca ve her yerde toplamları hesaplamak için kullanılır. TToplamları birleştirmeden önce ve sonra devrik yapmak için kullanılır, çünkü tüm dizileri 2 boyutlu yapmak ve kullanmaktan daha kısadır np.r_. İkinci köşegen için izi bulmak için m[::-1]karşılaştırıldığında rot90(m)veya karşılaştırıldığında bayt kaydeder fliplr(m).

JavaScript (ES6), 170 bayt

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

Giriş ve çıkış 2B sayı dizisidir.

Açıklaması

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

Test Parçacığı

Giriş / çıkış, yeni satırlar ve sekmeler ile biçimlendirildi.

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 bayt

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

Fonksiyon fbir matriste 2B liste olarak girer, ardından elde edilen matrisi verir. gyardımcı işlevdir.