रोटेशन योग

26

इनपुट के रूप में धनात्मक पूर्णांक युक्त एक वर्ग मैट्रिक्स लें, और मैट्रिक्स की "घुमाए गए योग" की गणना करें।

घुमाया गया योग:

मूल मैट्रिक्स का योग लें और उसी मैट्रिक्स को 90, 180 और 270 डिग्री घुमाया जाए।

मान लीजिए कि मैट्रिक्स है:

 2    5    8
 3   12    8
 6    6   10

तब घुमाया गया योग होगा:

2    5    8     8    8   10    10    6    6     6    3    2
3   12    8  +  5   12    6  +  8   12    3  +  6   12    5  = 
6    6   10     2    3    6     8    5    2    10    8    8   

26   22   26
22   48   22
26   22   26

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

इनपुट और आउटपुट डैश द्वारा अलग किए गए, विभिन्न परीक्षण मामलों को एक नई रेखा से अलग किया गया। अधिक सुविधाजनक प्रारूपों में परीक्षण के मामले यहां देखे जा सकते हैं ।

1
-------------
4

1 3
2 4
-------------
10   10 
10   10    

14    6    7   14
 6   12   13   13
 6    2    3   10
 5    1   12   12
-------------
45   37   24   45
24   30   30   37
37   30   30   24
45   24   37   45    

14    2    5   10    2
18    9   12    1    9
 3    1    5   11   14
13   20    7   19   12
 2    1    9    5    6
-------------
24   29   31   41   24
41   49   31   49   29
31   31   20   31   31
29   49   31   49   41
24   41   31   29   24

प्रत्येक भाषा में बाइट्स में सबसे छोटा कोड जीतता है। स्पष्टीकरण अत्यधिक प्रोत्साहित किया जाता है!

code-golf  math  number  array-manipulation  matrix 
— स्टीवी ग्रिफिन
स्रोत

जवाबों:

9

पायथन 2 , 78 बाइट्स

मेरे पिछले पुनरावर्ती दृष्टिकोण को बंद करने के लिए दो बाइट्स के लिए डेनिस का धन्यवाद ।

f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें।

पायथन 2 , 80 81 83 85 बाइट्स (गैर-पुनरावर्ती)

एक एकल सूची के रूप में इनपुट लेता है ।

l=input()
exec"l+=zip(*l[-1][::-1]),;"*3
print[map(sum,zip(*d))for d in zip(*l)]

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

कोड कार्यक्षमता

चूंकि यह पूरी तरह से विश्लेषण करने के लिए काफी लंबा-ईश है, आइए इसे टुकड़ा-दर-टुकड़ा देखें:

f = lambda *l:                # This defines a lambda-function that can accept any number
                              # of arguments (the matrix) using starred expressions.
l[3:] and ...X... or ...Y...  # If l[3:] is truthy (that is, the length of the list is
                              # higher than 3), return X, otherwise Y.

[map(sum,zip(*d))for d in zip(*l)]     # The first expression, X.
[                                ]     # Start a list comprehension, that:
                 for d in              # ... Iterates using a variable d on:
                          zip(*l)      # ... The "input", l, transposed.
         zip(*d)                       # ... And for each d, transpose it...
 map(sum,       )                      # ... And compute the sum of its rows.
                                       # The last two steps sum the columns of d.

f(zip(*l[0][::-1]),*l)     # The second expression, Y. This is where the magic happens.
f(                   )     # Call the function, f with the following arguments:
  zip(*          )         # ... The transpose of:
       l[0][::-1]          # ...... The first element of l (the first arg.), reversed.
                  ,        # And:
                   *l      # ... l splatted. Basically turns each element of l
                           # into a separate argument to the function.

और दूसरे कार्यक्रम के लिए:

l=input()                                # Take input and assign it to a variable l.
                                         # Note that input is taken as a singleton list.

exec"l+=zip(*l[-1][::-1]),;"*3           # Part 1. Create the list of rotations.
exec"                     ;"*3           # Execute (Do) the following 3 times:
     l+=                 ,               # ... Append to l the singleton tuple:
        zip(*           )                # ...... The transpose of:
             l[-1][::-1]                 # ......... The last element of l, reversed.

print[map(sum,zip(*d))for d in zip(*l)]  # Part 2. Generate the matrix of sums.
print                                    # Output the result of this expression:
     [                for d in        ]  # Create a list comprehension, that iterates
                                         # with a variable called "d" over:
                               zip(*l)   # ... The transpose of l.
      map(sum,       )                   # ... And computes the sum:
              zip(*d)                    # ... Of each row in d's transpose.
                                         # The last 2 steps generate the column sums.

TL; DR: 90-डिग्री द्वारा 3 बार इनपुट को घुमाकर और परिणाम एकत्रित करके आवश्यक मेट्रिसेस की सूची तैयार करें। फिर, परिणाम के स्थानान्तरण में प्रत्येक मैट्रिक्स के स्तंभों को प्राप्त करें।

— श्री एक्सकोडर
स्रोत
f=lambda*l:l[3:]and[map(sum,zip(*d))for d in zip(*l)]or f(zip(*l[0][::-1]),*l)"सामान्य" इनपुट के साथ दो बाइट्स बचाता है। इसे ऑनलाइन आज़माएं!
— डेनिस
@ डेनिस धन्यवाद! मैंने सोचा कि lambda*lकिसी कारणवश अजगर 2 में संभव नहीं था।
— श्री एक्सकोडर
आप x,*y=1,2,3पायथन 2.7 या [*x]पायथन 3.4 में नहीं कर सकते हैं , लेकिन अभिनीत अभिव्यक्तियों का उपयोग पायथन 1.6 में भी फ़ंक्शन तर्कों के लिए किया जा सकता है। इसे ऑनलाइन आज़माएं!
— डेनिस
8

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

@(x)(y=x+rot90(x))+rot90(y,2)

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

व्याख्या

यह इनपुट मैट्रिक्स को स्वयं के 90-डिग्री घुमाए गए संस्करण के साथ जोड़ता है। इसके बाद परिणाम 180 डिग्री के घुमाए गए संस्करण के साथ जोड़ा जाता है।

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

क्लीन , 110 बाइट्स

import StdEnv,StdLib
r=reverse
t=transpose
z=zipWith(+)
$m=[z(z(r b)a)(z(r c)d)\\a<-m&b<-r m&c<-t m&d<-r(t m)]

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

मैट्रिक से:

  • X = transpose(reverse M): 90-डिग्री रोटेशन
  • Y = reverse(map reverse M): 180 डिग्री रोटेशन
  • Z = reverse(transpose M): 270-डिग्री रोटेशन

यह खत्म हो गया इसके अलावा ऑपरेटर से ज़िप Mऔर Xके रूप में, साथ ही Yऔर Zहै, और फिर परिणामों पर।

— Οurous
स्रोत
5

जूलिया 0.6 , 29 बाइट्स

x*y=rotr90(y,x)
!x=x+1x+2x+3x

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

मैं ल्यूक के समाधान के नीचे नहीं जा सका

लेकिन कोशिश करने में मैं इस के साथ आया, जो मुझे लगता है कि थोड़े प्यारा है।

पहले हम घुमाए जाने वाले ऑपरेशन को फिर से परिभाषित करने के लिए गुणा करते हैं, जहाँ पहली बार घूमने की संख्या होती है। इसलिए जब से जूलिया मल्टीपज द्वारा जूसपाइप करती है: 1xबन जाती है rotr90(x,1)और 3xबन जाती है rotr90(x,3)आदि।

फिर हम योग लिखते हैं।

— लिंडन व्हाइट
स्रोत
5

जूलिया 0.6 , 28 24 बाइट्स

~A=sum(rotr90.([A],0:3))

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

~A=sum(rotr90.([A],0:3)) #
~                        # redefine unary operator ~
 A                       # function argument
               [A]       # put input matrix A into a list with one element
                   0:3   # integer range from 0 to 3
       rotr90.(   ,   )  # apply function rotr90 elementwise, expand singleton dimensions
       rotr90.([A],0:3)  # yields list of rotated matrices:
                         # [rotr90(A,0), rotr90(A,1), rotr90(A,2), rotr90(A,3)]
  sum(                )  # sum
— Lukes
स्रोत
1
यह शायद ध्यान देने योग्य है कि [1]उदाहरण के लिए क्या करना चाहिए ~reshape([1], (1,1))क्योंकि जूलिया 0.6 में 1x1 मैट्रिक्स कैसे घोषित किया गया है।
— लिंडन व्हाइट
4

MATL , 9 बाइट्स

i3:"G@X!+

इसे MATL ऑनलाइन पर आज़माएं

व्याख्या

i       # Explicitly grab the input matrix
3:"     # Loop through the values [1, 2, 3], and for each value, N:
  G     # Grab the input again
  @X!   # Rotate the value by 90 degrees N times
  +     # Add it to the previous value on the stack
        # Implicitly end the for loop and display the resulting matrix
— Suever
स्रोत
4

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

@(a)a+(r=@rot90)(a)+r(a,2)+r(a,3)

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

स्पष्टीकरण:

(r=@rot90)rमैट्रिक्स 90 डिग्री को घुमाने के लिए उपयोग किए जाने वाले फ़ंक्शन हैंडल बनाने के इनलाइन तरीके से । यदि दूसरा तर्क kदिया जाता है, rतो यह मैट्रिक्स k*90डिग्री को घुमाएगा । तो यह छद्म कोड के बराबर है:

a + rot90(a) + rot180(a) + rot270(a)
— स्टीवी ग्रिफिन
स्रोत
3

MATL , 7 बाइट्स

,t@QX!+

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

मेरे ऑक्टेव उत्तर का पोर्ट।

,        % Do twice
  t      %   Duplicate. Takes input (implicit) the first time
  @Q     %   Push 1 in the first iteration, and 2 in the second
  X!     %   Rotate by that many 90-degree steps
  +      %   Add
         % End (implicit). Display (implicit)
— लुइस मेंडो
स्रोत
3

आर , 69 64 बाइट्स

function(x,a=function(y)apply(y,1,rev))x+a(x)+a(a(x))+a(a(a(x)))

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

कोडगॉल्फ में नंबर तीन का प्रयास। Giuseppe के लिए 69 से 64 बाइट्स के लिए धन्यवाद!

— फ्लोरियन
स्रोत
आगे बढ़ते aएक समारोह तर्क के लिए आप में से छुटकारा पाने के लिए अनुमति देकर बाइट्स की बचत होगी {}चारों ओर समारोह शरीर। इसके अलावा, लुइस मेंडो के ऑक्टेव दृष्टिकोण को पोर्ट करने से कुछ बाइट्स बच सकते हैं? अंत में, मैं 100% निश्चित नहीं हूं, लेकिन इसके t(apply(x,2,rev))बराबर है apply(x,1,rev)?
— ग्यूसेप
धन्यवाद, मैं टिप # 1 और # 3 के साथ सुधार करने में सक्षम था। मैं एक तर्क जोड़कर बाइट्स की बचत करने में सफल नहीं हो सका nकरने के लिए a()आपरेशन हालांकि दोहराने के लिए।
— फ्लोरियन
1
मेरा मतलब कुछ इस तरह था
— Giuseppe
2

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

a=>a.map((b,i)=>b.map((c,j)=>c+a[j][c=l+~i]+a[c][c=l+~j]+a[c][i]),l=a.length)
— नील
स्रोत
2

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

ṚZ$3СS

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

1 बाइट को एरिक आउटगॉल्फ के लिए धन्यवाद दिया (एक बग को ठीक करने के लिए एक सुझाव के लिए भी धन्यवाद)।

कैसे?

ṚZ $ 3ṚS || पूर्ण कार्यक्रम (मोनैडिक)।

   3 || ऐसा 3 बार करें और एक सूची में परिणाम एकत्र करें
  $ || -> अंतिम दो लिंक एक साधु के रूप में लागू करें
Ṛ || –––> उल्टा,
 जेड || –––> पारगमन।
      एस || योग।
— श्री एक्सकोडर
स्रोत
2

एपीएल (डायलॉग क्लासिक) , 17 बाइट्स

{⍵+⌽∘⍉⍵+⌽∘⊖⍵+⍉⌽⍵}

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

APL NARS 34bytes 21 17 वर्ण

{⍵+⌽∘⍉⍵+⌽∘⊖⍵+⍉⌽⍵}

-2 आकर्षण ngn के लिए धन्यवाद

-2 चार्ट क्योंकि ऑपरेटर कंपोजिट to पर पूर्वता है लगता है

ऐसा लगता है कि °a 90 ° से घूमता है, ,a 180 ° से घूमता है, °a 270 ° से a घूमता है

यदि ऑपरेटर पी मौजूद है:

∇r←(g p)n;a;i;k
   a←⌽,n⋄r←⍬⋄i←0⋄k←⍴a⋄→C
A: →B×⍳r≡⍬⋄r←g¨r
B: r←r,⊂i⊃a
C: →A×⍳k≥i+←1
   r←⌽r
∇

उपरोक्त ऑपरेटर p ऐसा होगा कि यदि g 1 तर्क फ़ंक्शन (monadic?) है तो यह होना चाहिए:

"g f a a a a" is "a ga gga ggga"

समाधान pheraps 15 वर्ण होगा

  g←{⊃+/⌽∘⍉ p 4⍴⊂⍵}
  a←2 2⍴1 3 2 4
  g a
10 10 
10 10 
  g 1
4

लेकिन बेहतर हो सकता है कि एक ऑपरेटर "एन एन टाइम" को इस तरह से बनाए कि "3 डीएफ डब्ल्यू" एफ (एफ (एफ (डब्ल्यू))) है।

अब मैंने कुछ लिखा है, लेकिन आवश्यकता प्रकार की जाँच के बिना यह बहुत नाजुक है।

लेकिन मुझे और अधिक ऑपरेटर q पसंद हैं जो तर्क m के साथ f की रचना दोहराते हैं (यह पूरा नहीं होता है क्योंकि प्रकार के त्रुटि मामले नहीं आते हैं]

∇r←(n q f)m;i;k;l
   r←⍬⋄k←⍴,n⋄→A×⍳k≤1⋄i←0⋄→D
C: r←r,⊂(i⊃n)q f m
D: →C×⍳k≥i+←1
   →0
A: l←n⋄r←m⋄→0×⍳n≤0
B: l-←1⋄r←f r⋄→B×⍳l≥1
∇

समाधान 17 वर्ण होगा, लेकिन मैं इसे पसंद करता हूं

  g←{⊃+/(0..3)q(⌽⍉)⍵}
  ⎕fmt g a
┌2─────┐
2 10 10│
│ 10 10│
└~─────┘
  ⎕fmt g 1
4
~
— RosLuP
स्रोत
270 बस हो सकता है ⍉⌽और पूरी बात एक ट्रेन
— ngn
यदि ऐसा कोई मौजूद है, तो gfwwww w gw है gww gggw उत्तर होगा + / rf 4 / rho w
— RosLuP
आपका मतलब है +/⌽∘⍉f 4⍴⊂⍵? की चार प्रतियां प्राप्त करने के लिए ⍵, पहले आपको इसे संलग्न करना चाहिए ⊂। ⌽⍉एक ऑपरेंड के रूप में करने के लिए f, आपको इसे इस तरह एकल फ़ंक्शन में बनाना होगा ⌽∘⍉:। रहस्यमय fस्कैन (बैकस्लैश) हो सकता है, लेकिन इसकी देखभाल करने के लिए एक और विवरण है - ⌽∘⍉एक बाएं तर्क मिलेगा, इसलिए हमें इसे अनदेखा करना चाहिए: +/{⌽⍉⍵}\4⍴⊂⍵या +/⊢∘⌽∘⍉\4⍴⊂⍵।
— NGN
अपनी पहली टिप्पणी में मैं इस ट्रेन का सुझाव दे रहा था ⊢ + ⌽∘⍉ + ⌽∘⊖ + ⍉∘⌽:। यदि आप स्क्वीगल्स को चतुराई से पुनर्व्यवस्थित करते हैं और गाड़ियों का अच्छा उपयोग करते हैं, तो इससे भी छोटे समाधान हो सकते हैं।
— NGN
@ कोई साधारण {⍵ + n} \ _ 2 2 4 4 वापसी डोमेन त्रुटि
— RosLuP
2

K4 / K (oK) , 23 8 बाइट्स

समाधान:

+/(|+:)\

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

उदाहरण:

+/(|+:)\5 5#14 2 5 10 2 18 9 12 1 9 3 1 5 11 14 13 20 7 19 12 2 1 9 5 6
24 29 31 41 24
41 49 31 49 29
31 31 20 31 31
29 49 31 49 41
24 41 31 29 24

स्पष्टीकरण:

सरलीकृत परिवर्तन तकनीक के लिए ngn के लिए धन्यवाद ।

+/(|+:)\ / the solution
       \ / converge
  (   )  / function to converge
    +:   / flip
   |     / reverse
+/       / sum over the result

अतिरिक्त:

क्यू में यह लिखा जा सकता है

sum (reverse flip @) scan
— streetster
स्रोत
— ngn
मुझे पता था कि परिवर्तनों को लागू करने का एक बेहतर तरीका था!
— स्ट्रीटस्टर
+ / (| (+ + :) \ tio.run/##y9bNz/7/X1tfo0bbSjPGWMFY2UjBVMMwwjj00AhImQGnHHwww दुख की बात है एक ही गिनती है ... जीएएच मोबाइल पर मार्कअप का पता नहीं लगा सकता है।
— स्ट्रीटस्टर
ऐसा लगता है कि टिप्पणियों में मार्कअप में एक बग है, न केवल मोबाइल पर - बैकस्लैश से पहले बैककौट चीजों को गड़बड़ कर देता है। मैंने जगह डालकर इसे टाल दिया।
— '12:
2

रूबी , 74 72 66 बाइट्स

->a{r=0...a.size;r.map{|i|r.map{|j|(0..3).sum{i,j=j,~i;a[i][j]}}}}

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

यह तत्व-दर-तत्व के आधार पर कार्य करता है, संबद्ध तत्वों को गणितीय रूप से खोजने के बजाय सरणी को घुमाने के लिए। मुख्य भाग है i,j=j,~i, जो घड़ी की दिशा (i, j) को 90 डिग्री पर घुमाता है।

-2 बाइट्स मिस्टर एक्सकोडर की बदौलत

-6 बाइट्स के कारण sum

— MegaTom
स्रोत
1

रूबी 89 79 बाइट्स

-10 बाइट्स यूनीहेड्रॉन के लिए धन्यवाद 

->m{n=m;3.times{n=n.zip(m=m.transpose.reverse).map{|i,j|i.zip(j).map &:sum}};n}

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

— आसोन तुहिद
स्रोत
1
मैं बहुत यकीन है कि आप की जगह ले सकता .map &:dupसाथ *1पात्रों में से एक बहुत कुछ बंद कटौती करने के लिए। array*lengthएक नई सरणी बनाता है और उथले क्लोन का एक आसान तरीका है।
— अनहाइड्रोन 20'18
दरअसल, n=*mऔर भी छोटा है।
— यूनीहेड्रॉन
@ यूनीहेड्रॉन यही समस्या है, मुझे गहरे क्लोन की जरूरत है
— Asone Tuhid
मुझे लगता है कि यह उत्पादन को प्रभावित नहीं करता है; मैंने इसे आपके "ऑनलाइन प्रयास करके देखें" लिंक में दिया और आउटपुट उस परिवर्तन के साथ सही प्रतीत होता है
— Unihedron
आप सही हैं, वास्तव में आपको उथले क्लोन की भी आवश्यकता नहीं है, इस बात transposeका ध्यान रखता है
— Asone Tuhid
1

हास्केल , 84 83 67 बाइट्स

z=zipWith
e=[]:e
f l=foldr(\_->z(z(+))l.foldr(z(:).reverse)e)l"123"

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

बहुत सारे बाइट्स बचाने के लिए लाइकोनी और पूरी तरह से धन्यवाद !

— क्रिस्टियन लुपस्कू
स्रोत
— पूरी तरह से
@totallyhuman यह चतुर है! धन्यवाद!
— क्रिस्टियन लुपस्कू
— लकोनी
1

भूसी , 9 बाइट्स

F‡+↑4¡(↔T

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

व्याख्या

F‡+↑4¡(↔T)  -- implicit input M, for example: [[1,0,1],[2,3,4],[0,0,2]]
     ¡(  )  -- repeat infinitely times starting with M  
        T   -- | transpose: [[1,2,0],[0,3,0],[1,4,2]]
       ↔    -- | reverse: [[1,4,2],[0,3,0],[1,2,0]]
            -- : [[[1,0,1],[2,3,4],[0,0,2]],[[1,4,2],[0,3,0],[1,2,0]],[[2,0,0],[4,3,2],[1,0,1]],[[0,2,1],[0,3,0],[2,4,1]],[[1,0,1],[2,3,4],[0,0,2]],…
   ↑4       -- take 4: [[[1,0,1],[2,3,4],[0,0,2]],[[1,4,2],[0,3,0],[1,2,0]],[[2,0,0],[4,3,2],[1,0,1]],[[0,2,1],[0,3,0],[2,4,1]]]
F           -- fold (reduce) the elements (example with [[1,0,1],[2,3,4],[0,0,2]] [[1,4,2],[0,3,0],[1,2,0]])
 ‡+         -- | deep-zip addition (elementwise addition): [[2,4,3],[2,6,4],[1,2,2]]
            -- : [[4,6,4],[6,12,6],[4,6,4]]
— ბიმო
स्रोत
1

टिनिइलिश , 132 बाइट्स

चलो transposeएक स्पिन के लिए हाल ही में जोड़ा गया पुस्तकालय समारोह ले लो !

(load library
(d T transpose
(d R(q((m #)(i #(c m(R(reverse(T m))(dec #)))(
(q((m)(foldl(q(p(map(q((r)(map sum(T r))))(T p))))(R m 4

अंतिम पंक्ति एक अनाम लंबो फ़ंक्शन है जो रोटेशन योग करता है। वास्तव में इसका उपयोग करने के लिए, आप dइसे एक नाम से बांधने के लिए उपयोग करना चाहेंगे । इसे ऑनलाइन आज़माएं!

टिप्पणियों के साथ, अपुष्ट

(load library) (comment Get functions from the standard library)

(comment Rotating a matrix by 90 degrees is just transpose + reverse)
(def rotate
 (lambda (matrix)
  (reverse (transpose matrix))))

(comment This function recursively generates a list of (count) successive rotations
          of (matrix))
(def rotations
 (lambda (matrix count)
  (if count
   (cons matrix
    (rotations (rotate matrix) (dec count)))
   nil)))

(comment To add two matrices, we zip them together and add the pairs of rows)
(def matrix-add
 (lambda two-matrices
  (map row-sum (transpose two-matrices))))

(comment To add two rows of a matrix, we zip them together and add the pairs of numbers)
(def row-sum
 (lambda (two-rows)
  (map sum (transpose two-rows))))

(comment Our final function: generate a list containing four rotations of the argument
          and fold them using matrix-add)
(def rotated-sum
 (lambda (matrix)
  (foldl matrix-add (rotations matrix 4))))
— DLosc
स्रोत
1

अटैची , 20 बाइट्स

Sum@MatrixRotate&0:3

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

व्याख्या

Sum@MatrixRotate&0:3

MatrixRotate&0:3, के लिए विस्तारित इनपुट के साथ x, MatrixRotate[x, 0:3]है, जो बारी exapnds में करने के लिए [MatrixRotate[x, 0], MatrixRotate[x, 1], MatrixRotate[x, 2], MatrixRotate[x, 3]]। यह कहना है, यह RHS पर वेक्टर करता है। फिर, Sumएक स्तर से इन सभी मैट्रिस का योग लेता है। यह वांछित परिणाम देता है।

— कोनोर ओ ब्रायन
स्रोत
1

जावा 8, 135 133 बाइट्स

a->{int l=a.length,r[][]=new int[l][l],i=0,j;for(;i<l;i++)for(j=0;j<l;)r[i][j]=a[i][j]+a[j][l+~i]+a[l+~i][l-++j]+a[l-j][i];return r;}

-2 बाइट्स @ceilingcat की बदौलत ।

स्पष्टीकरण:

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

a->{                        // Method with integer-matrix as both parameter and return-type
  int l=a.length,           //  Dimensions of the input-matrix
      r[][]=new int[l][l],  //  Result-matrix of same size
      i=0,j;                //  Index-integers
  for(;i<l;i++)             //  Loop over the rows
    for(j=0;j<l;)           //   Loop over the columns
      r[i][j]=              //    Set the cell of the result-matrix to:
              a[i][j]+a[j][l+~i]+a[l+~i][l-++j]+a[l-j][i];
                            //     The four linked cells of the input-matrix
  return r;}                //  Return the result-matrix
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.