31

इनपुट के रूप में धनात्मक पूर्णांक वाले एक गैर-खाली मैट्रिक्स / संख्यात्मक सरणी लें। इस क्रम में, पहली पंक्ति और कॉलम के योग, फिर दूसरी पंक्ति और कॉलम और तब तक जारी रखें जब तक कि कोई और पंक्तियाँ या कॉलम न हों।

मान लीजिए इनपुट है:

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

तब उत्पादन होना चाहिए:

45, 33, 16, 17

क्योंकि: 2+9+1+7+10+10+2+4=45, 7+7+1+7+2+9=33, 6+4+2+4=16, 8+9=17।

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

परीक्षण के मामले निम्नलिखित प्रारूप में हैं:

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

सरणियों के रूप में:

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

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

code-golf math matrix

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

2

@JonathanAllan, ज़ीरो को हमेशा के लिए प्रिंट करना थोड़ा खिंचाव है, इसलिए मुझे लगता है कि मुझे उस पर कोई बात नहीं कहनी चाहिए।

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

1

रेटिना कार्यक्रम को सुंदर उदाहरणों से पायथन सरणियों में परिवर्तित करना है।

— mbomb007

1

उदाहरणों को देखते हुए। कार्य हताशा गलत है। पहले उदाहरण में दूसरा स्तंभ है 10,7,7,1, दूसरी पंक्ति है 9,7,7,2,9और योग है 59। और इसी तरह

— edc65

1

@ edc65 उदाहरणों को देखते हुए, ऐसा प्रतीत होता है कि पिछली गणनाओं में प्रयुक्त संख्याओं का पुन: उपयोग नहीं किया गया है। या दूसरी तरह, जब nth रो पर विचार करते हैं, तो केवल nth कॉलम के मानों का उपयोग करें, और n-1 के माध्यम से उन कॉलम 1 को अनदेखा करें।

— ब्रायन जे

1

@ Arc676 मानक io नियम। फ़ंक्शन तर्क, स्वीकृत इनपुट विधियों में से एक हैं।

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

10

MATL , 16 बाइट्स

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

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

व्याख्या

एक उदाहरण के रूप में, इनपुट पर विचार करें

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

कोड &n:w:!Xlकॉलम वेक्टर [1; 2; 3; 4]और पंक्ति वेक्टर बनाता है [1 2 3 4 5]। फिर Xlप्रसारण के साथ न्यूनतम तत्व-वार की गणना करता है, जो मैट्रिक्स देता है

X:इस मैट्रिक्स (स्तंभ-प्रमुख क्रम में) को स्तंभ वेक्टर में रैखिक करता है [1; 1; 1; 1; 1; 2; 2; ... ; 4]। इस वेक्टर और रैखिक इनपुट मैट्रिक्स, के रूप में प्राप्त किया जाता है GX:, accumarray(... @sum)फ़ंक्शन के इनपुट के रूप में पारित किया जाता है , या 1XQ। यह पहले इनपुट के मूल्यों द्वारा समूहीकृत दूसरे इनपुट के योग की गणना करता है।

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

7

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

ŒDS

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

यह काम किस प्रकार करता है

ŒDS

ŒD   diagonals
  S  vectorized sum

— लीक नन
स्रोत

5

सीजाम , 23 18 बाइट्स

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

बेनामी ब्लॉक स्टैक पर तर्क की उम्मीद करता है और स्टैक पर परिणाम छोड़ता है।

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

व्याख्या

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

— बिजनेस कैट
स्रोत

क्या यह "धोखा" नहीं है? मेरा मतलब है, आप बाइट की गिनती में इनपुट और आउटपुट कोड नहीं गिन रहे हैं। इनपुट और आउटपुट दोनों के साथ यह केवल 1 बाइट लंबा है:q~[{(:+\z}h;]2/::+p

— फ्रॉडक्यूब

@FrodCube द्वारा इसकी अनुमति है मेटा सर्वसम्मति से ।

— बिजनेस कैट

2

वास्तव में, तकनीकी रूप से, यह एक पूर्ण कार्यक्रम के समान ही होगा, क्योंकि मैं उद्घाटन को छोड़ सकता हूं [। लेकिन एक ब्लॉक के रूप में मुझे लगता है कि मुझे इसकी आवश्यकता है क्योंकि इसे नीचे पूरे स्टैक पर भी कब्जा नहीं करना चाहिए।

— बिजनेस कैट

5

05AB1E , 14 11 बाइट्स

[ćOˆøŽ]¯2ôO

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

व्याख्या

[   Ž ]       # loop until stack is empty
 ć            # extract the head
  Oˆ          # sum and add to global list
     ø        # transpose
       ¯      # push global list
        2ô    # split into pairs
          O   # sum each pair

— Emigna
स्रोत

4

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

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

Naive solution, एक बेहतर तरीका हो सकता है।

— ETHproductions
स्रोत

4

गणितज्ञ, 60 बाइट्स

लुइस मेंडो के MATL उत्तर से प्रेरित ।

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

स्पष्टीकरण: Min~Array~Dimensions@#निम्नलिखित की तरह एक मैट्रिक्स का निर्माण करता है:

फिर Pick[#,...,n]~Total~2n उपरोक्त अजीब मैट्रिक्स में संख्या के अनुरूप इनपुट मैट्रिक्स की प्रविष्टियों को निकालता है, और उन्हें रकम देता है। आखिरकार...~Table~{n,Min[d=Dimensions@#]} पुनरावृति n।

यह भोले दृष्टिकोण से 1 बाइट छोटा है:

{#[[n,n;;]],#[[n+1;;,n]]}~Total~2~Table~{n,Min@Dimensions@#}&

— पेड़ नहीं
स्रोत

4

हास्केल, 50 49 बाइट्स

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

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

यदि कम से कम एक तत्व के साथ कम से कम एक पंक्ति है, तो परिणाम पहली पंक्ति का योग है और अन्य सभी पंक्तियों के प्रमुखों के बाद अन्य सभी पंक्तियों की पूंछ के साथ एक पुनरावर्ती कॉल है। अन्य सभी मामलों में, परिणाम खाली सूची है।

संपादित करें: अर्जन जोहानसन ने एक बाइट को बचाया। धन्यवाद!

— nimi
स्रोत

4

अष्टक , ६४ 52 बाइट्स

1 बाइट बचाने के लिए @StewieGriffin को धन्यवाद!

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

यह एक अनाम फ़ंक्शन को परिभाषित करता है।

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

व्याख्या

कोड मेरे MATL उत्तर के समान है (वहां स्पष्टीकरण देखें)।

दो बाइट्स का उपयोग 1:size(x)करने के बजाय 1:size(x,1)इस तथ्य का फायदा उठाते हुए बचाया गया है कि 1:[a b]जैसा व्यवहार होता है 1:a। इसके अलावा, एक बाइट का उपयोग कर सहेज लिया गया है 1:rows(x')बजाय 1:size(x,2)Stewie करने के लिए धन्यवाद,।

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

3

k, 19 बाइट्स

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

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

स्पष्टीकरण:

           (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
स्रोत

3

05AB1E , 16 बाइट्स

[ćOsø.g<NQ#])2ôO

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

[                # Start loop
 ć               # Extract first element
  O              # Sum
   sø            # Transpose the input array (without the first N rows and columns)
     .g<NQ       # Push if (stack height - 1 == loop count)
          #]     # If they were equal break
            )2ô  # Break stack into chunks of 2
               O # Sum the chunks

— रिले
स्रोत

3

ऑक्टेव , 63 60 बाइट्स

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

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

इस मैट्रिक्स का उत्तर:

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

इसके ऊपरी त्रिकोणीय भाग की पंक्ति योगों का वेक्टर है:

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

इसके निचले त्रिकोणीय भाग के कॉलम योगों का सदिश:

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

जो ठीक है वह मेरा उत्तर कंप्यूटिंग है।

— eush77
स्रोत

2

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

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

पूरे मैट्रिक्स को फिर से जोड़कर और फिर अगले ब्लॉक के योग को घटाकर काम करता है। शायद सबसे प्रभावी दृष्टिकोण नहीं है, लेकिन अच्छी तरह से सहज है।

— जूलियन वुल्फ
स्रोत

2

जावा 7, 248 बाइट्स

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

इसे यहाँ आज़माएँ।

सामान्य स्पष्टीकरण:

मान लीजिए कि इनपुट ऐरे में 4x6 के आयाम हैं। कोड का पहला भाग एक अस्थायी मैट्रिक्स बनाएगा और इसे निम्न प्रकार से भरेगा:

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

और कोड के दूसरे भाग में यह इस अस्थायी मैट्रिक्स पर लूप करेगा, और अस्थायी मैट्रिक्स में प्रत्येक अलग-अलग संख्याओं के लिए इनपुट-मैट्रिक्स के सभी मूल्यों को sums।

कोड की व्याख्या:

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

— केविन क्रूज़सेन
स्रोत

2

पर्ल 6 , 63 55 बाइट्स

~~{($_ Z [Z] $_).kv.map(->\a,\b{b.flatmap(*[a..*]).sum -b[0;a]})}~~

{($_ Z [Z] .skip).kv.map({$^b.flatmap(*[$^a..*]).sum})}

$_ अनाम फ़ंक्शन के लिए मैट्रिक्स इनपुट है
.skip इसकी पहली पंक्ति के साथ इनपुट मैट्रिक्स को हटा दिया गया है
[Z] .skipइसकी पहली पंक्ति को हटाने के साथ इनपुट मैट्रिक्स का संक्रमण है; अर्थात्, इसके पहले कॉलम के बिना ट्रांज़ोज़
$_ Z [Z] .skip एक सूची के निर्माण के साथ अपने ट्रांसपोज़-सन्स-फर्स्ट-कॉलम के साथ इनपुट मैट्रिक्स को ज़िप करता है ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
.kv प्रत्येक जोड़े को उसके सूचकांक के साथ उपसर्ग करता है
map({...}) जोड़े में नक्शे, एक फ़ंक्शन का उपयोग करके जो अपने पहले तर्क (सूचकांक) को अंदर ले जाता है $^a और उसके दूसरे (पंक्ति / स्तंभ जोड़ी) में है$^b
$^b.flatmap(*[$^a..*]).sum पहले बंद स्ट्रिप्स $^aप्रत्येक पंक्ति / स्तंभ जोड़ी तत्वों को , फिर सभी शेष तत्वों को जोड़ दिया जाता है

कुछ विचार के बाद मैंने महसूस किया कि ज़िपिंग से पहले ट्रांसपोज़ के पहले कॉलम को अलग करना दोहरे योगदान देने वाले विकर्ण तत्वों को घटाने के बराबर था, जैसा कि मेरे पहले समाधान में था। कि मुझे उस घटाव को हटाने दें, और मैपिंग फ़ंक्शन के प्रत्येक तर्क का उपयोग करके केवल एक बार {...$^a...$^b...}अनाम फ़ंक्शन को मूल से अधिक कुशल तर्क देने की विधि बनाई -> \a, \b {...a...b...}।

— शॉन
स्रोत

1

विम, 66 , 52 बाइट्स

qq^f j<C-v>}dkV}Jo<esc>p@qq@q:%s/\v> +</+/g|%norm C<C-v><C-r>=<C-v><C-r>"<C-v><cr><cr>

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

नौकरी के लिए गलत टूल ...

— DJMcMayhem
स्रोत

1

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

Ḣ;Ḣ€SṄȧßS¿

एक पूर्ण कार्यक्रम जो मूल्यों को प्रिंट करता है

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

कैसे?

Ḣ;Ḣ€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)

— जोनाथन एलन
स्रोत

1

पायथन + न्यूमपी, 75 बाइट्स

इनपुट एक 2 डी संख्यात्मक सरणी है।

lambda L:[sum(L[i,i:])+sum(L[i+1:,i])for i in range(min(len(L),len(L[0])))]

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

— mbomb007
स्रोत

1

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

f=lambda m:[reduce(lambda x,y:x+y[i],m[i:],sum(m[i][i+1:]))for i in range(min(len(m),len(m[0])))]

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

— ZestyLemon
स्रोत

इस उत्तर में व्हॉट्सएप का एक अच्छा सौदा है जिसे हटाया जा सकता है।

— गेहूं जादूगर

@HeatWizard धन्यवाद! मेरे जवाब को 4 बाइट्स से कम कर दिया :)

— ZestyLemon

1

पायथ, 16 15 बाइट्स

.es+>b+1k>@CQkk

संख्याओं के सरणियों के एक अजगर-शैली की सरणी लेता है, एक सरणी देता है।

कोशिश करो!

व्याख्या

.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
स्रोत

1

जीएनयू एपीएल 1.7, 123 बाइट्स

समाधान के लिए दो कार्यों की आवश्यकता होती है: एक वैश्विक सरणी बनाता है और दूसरा कॉल करता है, जो पुनरावर्ती रूप से उस सरणी में जोड़ देता है।

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

∇फ़ंक्शन को शुरू और समाप्त करता है। दोनों fऔर gटेबल को तर्क के रूप में लेते हैं (अनिवार्य रूप से 2 डी सरणियां)। इनसे बनाया जा सकता है X←rows cols ⍴ 1 2 3 4...।

R←⍬वैश्विक चर के लिए एक खाली वेक्टर प्रदान करता है R।

g N दूसरे फ़ंक्शन को पहले दिए गए उसी तर्क के साथ कॉल करता है।

⍴Nके आयाम देता है N; जब कोई एक आयाम शून्य होता है, तो जोड़ने के लिए अधिक पंक्तियाँ / कॉलम नहीं होते हैं। 0∈⍴Nआयाम में शून्य होने पर 1 रिटर्न। फ़ंक्शन →2+2×0∈⍴Nके रिटर्न मान को लाइन नंबर 2 प्लस 2 गुना करने के लिए शाखाएं ∈: यदि कोई शून्य नहीं है, तो ∈रिटर्न 0 और फ़ंक्शन शाखाएं लाइन 2 (अगली पंक्ति) पर लौटती हैं। अगर है एक शून्य, ∈रिटर्न 1 और लाइन 4 समारोह शाखाओं (समारोह के अंत है, तो returnअनिवार्य रूप से)।

/कम ऑपरेटर है। यह बाएं तर्क को लागू करता है, जो +सही तर्क के रूप में दी गई सूची में प्रत्येक तत्व के लिए एक ऑपरेटर ( ) है। N[1;]तालिका की पूरी पहली पंक्ति N[;1]देता है और पहला कॉलम देता है। (+/N[1;])+(+/N[;1])-N[1;1]पहली पंक्ति और कॉलम को सम्‍मिलित करता है और ऊपरी बाएँ कोने में मान घटाता है क्योंकि यह कॉलम योग और पंक्ति योग दोनों में जुड़ जाता है।R←R,...वैश्विक वेक्टर के लिए नए परिकलित मूल्य को जोड़ता है R।

फ़ंक्शन तब खुद को कॉल करता है (तब तक पुनरावृत्ति करता है जब तक कि अधिक पंक्तियों या स्तंभों में नहीं)। ⊃पिकअप ऑपरेटर सूची से निर्दिष्ट तत्व प्राप्त करता है। 1⊃⍴Nपंक्तियों 2⊃⍴Nकी संख्या, स्तंभों की संख्या देता है । ⍳1 से सभी नंबर को निर्दिष्ट संख्या में देता है। ↓ड्रॉप ऑपरेटर सूची की शुरुआत से तत्वों को हटा। यदि आप तालिका या वेक्टर (जैसे N[1 2 3]) से तत्वों को एक्सेस करते समय कई संकेत देते हैं , तो एपीएल हर एक को एक्सेस करता है। इसलिए, 1↓⍳1⊃⍴Nपहले एक को छोड़कर प्रत्येक पंक्ति के सूचक देता है ( 2, 3, 4, ..., N) और 1↓⍳2⊃⍴Nएक समान वेक्टर देता है लेकिन कॉलम के लिए। g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]फ़ंक्शन को फिर से कॉल करें लेकिन पहली पंक्ति या कॉलम के बिना।

— Arc676
स्रोत

0

PHP, 76 बाइट्स

<?foreach($_GET as$k=>$v)foreach($v as$n=>$i)$r[min($k,$n)]+=$i;print_r($r);

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

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

0

गणितज्ञ, ११६ बाइट्स

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

इनपुट फॉर्म

[{{5}}}], [{{1}, {4}}], [{{7,2}}] या [{{....}, {....} ... {। ...}}]

— J42161217
स्रोत

0

क्लोजर, 98 बाइट्स

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

पंक्ति और स्तंभ अनुक्रमणिका (बहुत ही क्रियात्मक तरीके से) के साथ इनपुट पर इरेट करता है, न्यूनतम के साथ हैश-मैप बनाता है iऔर jकुंजी के रूप में, हैश-मैप +को एक सॉर्ट-मैप में विलय कर देता है, मान लौटाता है।

— NikoNyrh
स्रोत

0

आर, 102 बाइट्स

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

एक अनाम फ़ंक्शन देता है; ट्रेसिंग न्यूलाइन के साथ रिजल्ट को कंसोल पर प्रिंट करता है। मुझे शायद एक अलग दृष्टिकोण की आवश्यकता है।

पंक्तियों और स्तंभों के न्यूनतम पर Iterates; पहली प्रविष्टि को छोड़कर x[,1](पहली कॉलम) और x[1,-1]पहली पंक्ति के योग को प्रिंट करता है , फिर xएक मैट्रिक्स के बराबर सेट होता है x[-1,-1](यानी, xइसकी पहली पंक्ति और कॉलम को छोड़कर)। दुर्भाग्य से, बस सेटिंग के x=x[-1,-1]कारण यह वर्ग मैट्रिक्स के मामले में विफल हो जाता है, क्योंकि जब x2x2 होता है, तो सबसेटिंग मैट्रिक्स के बजाय एक वेक्टर देता है।

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

— ग्यूसेप
स्रोत

0

जावा 7, 280 276 बाइट्स

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

इसे यहाँ आज़माएँ।

मेरे पिछले उत्तर की तुलना में वैकल्पिक दृष्टिकोण साथ सरणियों , जो अभी भी अंत में इस एक से कम है (इसलिए मैं थोड़े समय बर्बाद कर इस वैकल्पिक दृष्टिकोण की कोशिश कर रहा हूं)।

सामान्य स्पष्टीकरण:

@Riley की अद्भुत 05AB1E उत्तर से प्रेरणा
यह उत्तर एक सूची का उपयोग करता है और प्रत्येक राशि की गणना के बाद यह सूची-मैट्रिक्स से पहली कॉलम और पहली पंक्ति को इस तरह निकालता है:

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

कोड की व्याख्या:

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

— केविन क्रूज़सेन
स्रोत

0

पायथन, 93 बाइट्स

Mbomb007 के उत्तर के समान, लेकिन बिना 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
स्रोत

पहली पंक्ति और स्तंभ का योग, फिर दूसरी पंक्ति और स्तंभ… और इसी तरह

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

MATL , 16 बाइट्स

व्याख्या

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

यह काम किस प्रकार करता है

सीजाम , 23 18 बाइट्स

व्याख्या

05AB1E , 14 11 बाइट्स

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

गणितज्ञ, 60 बाइट्स

हास्केल, 50 49 बाइट्स

अष्टक , ६४ 52 बाइट्स

व्याख्या

k, 19 बाइट्स

05AB1E , 16 बाइट्स

ऑक्टेव , 63 60 बाइट्स

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

जावा 7, 248 बाइट्स

पर्ल 6 , 63 55 बाइट्स

विम, 66 , 52 बाइट्स

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

कैसे?

पायथन + न्यूमपी, 75 बाइट्स

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

पायथ, 16 15 बाइट्स

व्याख्या

जीएनयू एपीएल 1.7, 123 बाइट्स

PHP, 76 बाइट्स

गणितज्ञ, ११६ बाइट्स

क्लोजर, 98 बाइट्स

आर, 102 बाइट्स

जावा 7, 280 276 बाइट्स

पायथन, 93 बाइट्स