चुनौती:

एक वर्ग इनपुट मैट्रिक्स ए को देखते हुए , मैट्रिक्स को एक पंक्ति और एक कॉलम को चारों तरफ से पैड करें।

ऊपर और नीचे की पंक्ति में प्रत्येक तत्व का मान प्रत्येक संगत कॉलम में तत्वों का योग होना चाहिए।
बाएं और दाएं कॉलम में प्रत्येक तत्व का मूल्य प्रत्येक संगत पंक्ति में तत्वों का योग होना चाहिए।
शीर्ष बाएं और निचले दाएं कोने में तत्वों का मूल्य विकर्ण पर तत्वों का योग होना चाहिए
शीर्ष दाएं और नीचे बाएं कोने में तत्वों का मूल्य विरोधी-विकर्ण में तत्वों का योग होना चाहिए।

उदाहरण:

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

स्पष्टीकरण:

शीर्ष बाएं और नीचे दाएं तत्व विकर्ण 1 + 2 + 5 = 8 का योग हैं । शीर्ष दाएं और निचले बाएं तत्व एंटी-विकर्ण 2 + 2 + 3 = 7 का योग हैं ।

ऊपर और नीचे की पंक्ति (कोनों को छोड़कर) A : 1 + 3 + 2 = 6 , 5 + 2 + 5 = 12 और 3 + 4 + 5 = 12 में प्रत्येक कॉलम का योग है । इसी प्रकार, बाएँ और दाएँ स्तंभ (कोनों को छोड़कर) A : 1 + 5 + 3 = 9 , 3 + 2 + 4 = 9 और 2 + 5 + 5 = 12 की प्रत्येक पंक्तियों का योग है ।

इनपुट:

एक गैर-खाली वर्ग मैट्रिक्स, गैर-नकारात्मक पूर्णांक के साथ।
वैकल्पिक प्रारूप

आउटपुट:

ऊपर बताए अनुसार मैट्रिक्स गद्देदार
वैकल्पिक प्रारूप, लेकिन यह इनपुट प्रारूप के समान होना चाहिए

परीक्षण के मामलों:

यदि आप इनपुट प्रारूप को अधिक उपयुक्त एक (उदाहरण के लिए ) में बदलना चाहते हैं, तो इस चुनौती में सबमिशन का उपयोग करें [[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

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम समाधान जीतता है। स्पष्टीकरण को अत्यधिक प्रोत्साहित किया जाता है।

— स्टीवी ग्रिफिन
स्रोत

2

क्या यह जादू वर्गों की जांच करने के लिए है?

— mdahmoune

बस जाँच करना थोड़ा आसान है, लेकिन यह देखना वास्तव में आसान है कि क्या कोई वर्ग इस तरह से जादू करता है, हाँ :-)

— स्टीवी ग्रिफिन

5

ऑक्टेव , 64 बाइट्स

4 बाइट बचाने और मूल कोड में एक त्रुटि को सुधारने के लिए टॉम कारपेंटर का धन्यवाद !

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

_{ध्यान दें, मैंने चुनौती पोस्ट करने के बाद यह लिखा था।}

— स्टीवी ग्रिफिन
स्रोत

4

जेली , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— आउटगोल्फर को एरिक करें
स्रोत

2

मैं जानना चाहता हूं कि यह कैसे काम करता है, कृपया।

— कॉमरेड स्पार्कलेपनी

@ComradeSparklePony मुझे नहीं पता कि मेरे पास अभी स्पष्टीकरण लिखने का समय है, क्षमा करें।

— आउटगोल्फ जूल

यह ठीक है, चिंता न करें।

— कॉमरेड स्पार्कलपनी

4

MATL , 27 26 बाइट्स

,!tXswyv]GXds5L(PGPXds5L(P

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

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

— लुइस मेंडो
स्रोत

बेशक MATL को जेली के विपरीत मैट्रिसेस के साथ काम करने के लिए डिज़ाइन किया गया है। > _>

— निकोल निकोल

@EriktheOutgolfer लेकिन आपके जवाब में अधिक यूरो है!

— लुइस मेंडू

3

हाँ, यह यूरो डॉलर और येन है ... दुर्भाग्य से यहाँ जीतने की कसौटी नहीं है। डी:

— एरिक आउटगोल्फर

3

APL (Dyalog) , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 1∘⍉ विकर्ण (एक में दोनों कुल्हाड़ियों को गिराना)

d← उस फ़ंक्शन को d के रूप में संग्रहीत करें और उसे तर्क पर लागू करें

+⌿ स्तंभ रकम को प्रीपेन्ड करें

d∘⌽, Prepend d उलटे हुए तर्क पर लागू होता है

(… )⍪ शीर्ष पर निम्नलिखित स्टैक करें:

+/,⊢,+/ पंक्ति रकम, अनमोल तर्क, पंक्ति रकम

(… )⍪ शीर्ष पर निम्नलिखित स्टैक करें:

d,+⌿,d∘⌽ तर्क के लिए आवेदन किया, स्तंभ रकम, घ उलट तर्क के लिए आवेदन किया

— एडम
स्रोत

3

जेली , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आश्चर्यजनक रूप से एरिक के समाधान से अलग दिखता है ।

मैं आखिरकार यह समझने में कामयाब रहा कि कैसे ¦काम करता है (जेली के कोड के माध्यम से डीबग करके, लोल)। बहुत बुरा यह €साथ काम करने की आवश्यकता हैÇ मेरे मामले में ।

व्याख्या

कोड तीन लिंक का उपयोग करता है। पहला सहायक लिंक दोनों सिरों पर अपनी राशि के साथ एक वेक्टर को खींचता है, दूसरा सहायक लिंक मैट्रिक्स के दो कोनों को ठीक करता है और मुख्य लिंक इन उचित रूप से कहता है।

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

— PurkkaKoodari
स्रोत

3

अजगर ३ , 155 बाइट्स

यह @LeakyNun का सुझाव है, जो 54 बाइट बचाता है । मैंने तब इसे खुद ही थोड़ा सा गोल्फ दिया।

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]

इसे ऑनलाइन आज़माएं!

प्रारंभिक समाधान - पायथन 3 , 216 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— मिस्टर एक्सकोडर
स्रोत

162 बाइट्स

— लीकी नून

@LeakyNun धन्यवाद। बस ~ 190 बाइट्स के साथ अद्यतन कर रहा था, यह बहुत कम है: P

— श्री Xcoder

2

पायथन 2 , 268 250 184 174 बाइट्स

स्टीवी ग्रिफिन के लिए 10 धन्यवाद

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

इसे ऑनलाइन आज़माएं!

कुछ स्पष्टीकरण इनपुट को मैट्रिक्स के रूप में अपलोड किया गया है। पहले कोड प्रत्येक कॉलम और प्रत्येक पंक्ति के योग को numpy.sum का उपयोग करके गणना करता है। फिर यह संख्या के आधार पर विकर्ण के योग की गणना करता है। इसके बाद यह मैट्रिक्स पर बाएं-दाएं फ्लिप बनाकर अन्य विकर्ण प्राप्त करता है। अंत में, यह टुकड़ों को एक साथ गोंद करने के लिए numpy.vstack और numpy.hstack का उपयोग करता है।

— mdahmoune
स्रोत

@StewieGriffin ठीक है, मैंने अभी कोड अपडेट किया है :)

— mdahmoune

1

मेरा मानना है कि यह 174 tio.run/…

— Stewie Griffin

2

आर, 129 बाइट्स

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

एक अनाम फ़ंक्शन जो इनपुट के रूप में एक वर्ग मैट्रिक्स लेता है। अगर कोई दिलचस्पी है तो मैं एक स्पष्टीकरण पोस्ट करूँगा।

— rturnbull
स्रोत

2

PHP , 211 बाइट्स

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

इसे ऑनलाइन आज़माएं!

विस्तारित

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

— जार्ग हुल्सरमैन
स्रोत

2

पायथन 3 , 125 बाइट्स

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

इसे ऑनलाइन आज़माएं!

थोड़ा अपराजित:

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

यह इनपुट को फॉरमेट के रूप में लेता है, फिर एक बार में एक नया एरे बनाने के लिए np.c_और np.r_इंडेक्सिंग टूल्स का उपयोग करता है । np.traceऔर np.sumविकर्णों के साथ और हर जगह क्रमशः अन्य की गणना करने के लिए उपयोग किया जाता है। Tइसका उपयोग समासों को समाप्‍त करने से पहले और बाद में करने के लिए किया जाता है क्‍योंकि यह सभी सरणियों को 2-आयामी बनाने और उपयोग करने से कम है np.r_। दूसरे विकर्ण के लिए ट्रेस खोजने के m[::-1]लिए rot90(m)या तुलना करने पर बाइट्स बचाता है fliplr(m)।

— ईएफटी
स्रोत

अच्छा जवाब! साइट के लिए :) आपका स्वागत है

— DJMcMayhem

1

जावास्क्रिप्ट (ईएस 6), 170 बाइट्स

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

इनपुट और आउटपुट संख्या का 2 डी सरणी है।

व्याख्या की

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

टेस्ट स्निपेट

इनपुट / आउटपुट को नए सिरे और टैब के साथ स्वरूपित किया गया है।

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>

स्निपेट का विस्तार करें

— जस्टिन मेरिनर
स्रोत

0

लोगो , 198 बाइट्स

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

फ़ंक्शन fमैट्रिक्स में 2 डी सूची के रूप में लेता है, फिर परिणामी मैट्रिक्स को आउटपुट करता है। gसहायक कार्य है।

— user202729
स्रोत

पैड को अपने सोम्स के साथ लगाएं

चुनौती:

उदाहरण:

इनपुट:

आउटपुट:

परीक्षण के मामलों:

ऑक्टेव , 64 बाइट्स

जेली , 27 बाइट्स

MATL , 27 26 बाइट्स

व्याख्या

APL (Dyalog) , 37 बाइट्स

जेली , 26 बाइट्स

व्याख्या

अजगर ३ , 155 बाइट्स

प्रारंभिक समाधान - पायथन 3 , 216 बाइट्स

पायथन 2 , 268 250 184 174 बाइट्स

आर, 129 बाइट्स

PHP , 211 बाइट्स

पायथन 3 , 125 बाइट्स

जावास्क्रिप्ट (ईएस 6), 170 बाइट्स

व्याख्या की

टेस्ट स्निपेट

लोगो , 198 बाइट्स