প্রথম সারি এবং কলামের যোগফল, তারপরে দ্বিতীয় সারি এবং কলাম ... এবং আরও কিছু

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
@ জোনাথান অ্যালান, চিরতরে জিরোস মুদ্রণ করা কিছুটা প্রসারিত, তাই আমি মনে করি আমাকে অবশ্যই এটির জন্য কিছু বলতে হবে না।
— স্টিভি গ্রিফিন 21
1
রেটিনা প্রোগ্রামটি সুন্দর উদাহরণ থেকে পাইথন অ্যারেতে রূপান্তর করতে।
— mbomb007
1
উদাহরণগুলি তাকান। টাস্ক অবক্ষয় ভুল। প্রথম উদাহরণে দ্বিতীয় কলামটি হ'ল 10,7,7,1, দ্বিতীয় সারিটি 9,7,7,2,9এবং যোগফল 59। এবং তাই
— edc65
1
@ edc65 উদাহরণগুলি দেখে মনে হচ্ছে যে পূর্ববর্তী গণনায় ব্যবহৃত সংখ্যাগুলি পুনরায় ব্যবহার করা হয়নি। অথবা অন্য কোনও উপায়ে, নবম সারিটি বিবেচনা করার সময়, কেবলমাত্র নবম কলামের মানগুলি ব্যবহার করুন এবং কলাম 1-এ এন -1 এর মাধ্যমে এড়িয়ে যান।
— ব্রায়ান জে
1
@ আর্ক 676 স্ট্যান্ডার্ড আইও নিয়ম। ফাংশন আর্গুমেন্ট গ্রহণযোগ্য ইনপুট পদ্ধতিগুলির মধ্যে একটি।
— স্টিভি গ্রিফিন

উত্তর:

10

এমএটিএল , 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সম্প্রচারের সাথে ন্যূনতম উপাদান অনুসারে গণনা করুন যা ম্যাট্রিক্স দেয়

1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4

X:এই ম্যাট্রিক্সকে (কলাম-প্রধান ক্রমে) কলাম ভেক্টরে রেখায়িত করে [1; 1; 1; 1; 1; 2; 2; ... ; 4]। এই ভেক্টর এবং লিনিয়ারাইজড ইনপুট ম্যাট্রিক্স হিসাবে প্রাপ্ত হিসাবে GX:, accumarray(... @sum)ফাংশনটির ইনপুট হিসাবে পাস করা হয়, বা 1XQ। এটি প্রথম ইনপুটটির মানগুলির দ্বারা গোষ্ঠীযুক্ত দ্বিতীয় ইনপুটটির যোগফলকে গণনা করে।

— লুইস মেন্ডো
সূত্র
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
@ ফ্রডক्यूब এটি মেটা conকমত্য দ্বারা অনুমোদিত ।
— বিড়াল বিড়াল
2
প্রকৃতপক্ষে, প্রযুক্তিগতভাবে, এটি পুরো প্রোগ্রামের সমান দৈর্ঘ্য হবে, যেহেতু আমি উদ্বোধনটি বাদ দিতে পারি [। তবে একটি ব্লক হিসাবে আমার মনে হয় আমার এটি দরকার কারণ এটির নীচে পুরো স্ট্যাকটি ক্যাপচার করার দরকার নেই।
— বিড়াল বিড়াল
4

জাভাস্ক্রিপ্ট (ES6), 60 বাইট

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

নিষ্পাপ সমাধান, একটি ভাল উপায় হতে পারে।

— ETHproductions
সূত্র
4

গণিত, 60 বাইট

লুই মেন্ডোর এমএটিএল উত্তরের দ্বারা অনুপ্রাণিত ।

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

ব্যাখ্যা: Min~Array~Dimensions@#নিম্নলিখিতগুলির মতো একটি ম্যাট্রিক্স তৈরি করে:

1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4

তারপরে উপরের অদ্ভুত ম্যাট্রিক্সের Pick[#,...,n]~Total~2সংখ্যার সাথে সম্পর্কিত ইনপুট ম্যাট্রিক্সের এন্ট্রিগুলি খুঁজে বের করে nএবং তাদের অঙ্ক করে। শেষ পর্যন্ত ...~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 _=[]

এটি অনলাইন চেষ্টা করুন!

কমপক্ষে একটি উপাদানের সাথে যদি কমপক্ষে একটি সারি থাকে তবে ফলাফলটি প্রথম সারির যোগফল এবং অন্যান্য সমস্ত সারিগুলির শিরোনামগুলির পরে অন্য সমস্ত সারিগুলির লেজগুলির সাথে একটি পুনরাবৃত্ত কল হয় call অন্যান্য সমস্ত ক্ষেত্রে, ফলাফলটি খালি তালিকা।

সম্পাদনা: আরজান জোহানসেন একটি বাইট সংরক্ষণ করেছেন। ধন্যবাদ!

— nimi
সূত্র
4

অক্টাভা , 64 52 বাইট

1 বাইট বাঁচানোর জন্য @ স্টিভিগ্রিফিনকে ধন্যবাদ!

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

এটি একটি বেনামী ফাংশন সংজ্ঞায়িত করে।

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

কোডটি আমার এমএটিএল উত্তরের মতো (সেখানে ব্যাখ্যা দেখুন)।

দুই বাইট ব্যবহার সংরক্ষণ করা হয়েছে 1:size(x)পরিবর্তে 1:size(x,1)যে, আসলে শোষণ 1:[a b]হিসাবে একই আচরণ করবে 1:a। এছাড়াও, স্টিওয়ের 1:rows(x')পরিবর্তে পরিবর্তে একটি বাইট ব্যবহার করে সংরক্ষণ করা হয়েছে 1:size(x,2)।

— লুইস মেন্ডো
সূত্র
3

কে, 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

অক্টাভা , 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

এবং কোডের দ্বিতীয় অংশে এটি এই টেম্প ম্যাট্রিক্সের উপরে লুপ করবে এবং টেম্প ম্যাট্রিক্সের প্রতিটি স্বতন্ত্র সংখ্যার জন্য ইনপুট-ম্যাট্রিক্সের সমস্ত মানকে যোগ করবে।

কোডের ব্যাখ্যা:

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

জেলি , 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

পাইথন 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
সূত্র
এই উত্তরে সাদা জায়গার একটি ভাল চুক্তি রয়েছে যা সরানো যেতে পারে।
— গম উইজার্ড
@ উইট উইজার্ড ধন্যবাদ! 4 টি বাইট দ্বারা আমার উত্তর হ্রাস করেছে :)
— জেস্টিলেমন
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আর্গুমেন্ট হিসাবে টেবিলগুলি গ্রহণ করুন (মূলত 2D অ্যারে)। এগুলি দিয়ে তৈরি করা যায় X←rows cols ⍴ 1 2 3 4...।

R←⍬গ্লোবাল ভেরিয়েবলকে একটি খালি ভেক্টর নির্ধারণ করে R।

g N প্রথমটিকে একই আর্গুমেন্ট দিয়ে দ্বিতীয় ফাংশনটি কল করে।

⍴Nএর মাত্রা দেয় N; যখন মাত্রাগুলির একটি শূন্য হয় তখন আর সারি / কলাম আর যোগ করা যায় না। 0∈⍴Nমাত্রাগুলির মধ্যে শূন্য থাকলে 1 প্রদান করে returns →2+2×0∈⍴Nলাইন নম্বর 2 তে শাখাগুলি 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

গণিত, 116 বাইট

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

একটি বেনামী ফাংশন ফেরত; একটি পেছনের নিউলাইন সহ ফলাফলগুলি কনসোলে মুদ্রণ করে। আমার সম্ভবত একটি ভিন্ন পদ্ধতির প্রয়োজন।

সারি এবং কলামগুলির সর্বনিম্ন অংশের তুলনায় আইট্রেটস; প্রথম এন্ট্রি ব্যতীত x[,1](প্রথম কলাম) যোগফল এবং x[1,-1]প্রথম সারির মুদ্রণ করে , তারপরে xসমান একটি ম্যাট্রিক্স হিসাবে সেট করা হয় x[-1,-1](অর্থাত্, xএটির প্রথম সারি এবং কলাম বাদে)। দুর্ভাগ্যক্রমে, কেবল সেটিং এর x=x[-1,-1]ফলে স্কোয়ার ম্যাট্রিক্সের ক্ষেত্রে এটি ব্যর্থ হয়, কারণ যখন x2x2 হয় তখন সাবসেটিং ম্যাট্রিক্সের পরিবর্তে ভেক্টরকে ফেরত দেয়।

এটি অনলাইন চেষ্টা করুন!

— : Giuseppe
সূত্র
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;}

এখানে চেষ্টা করুন।

তুলনায় বিকল্প পদ্ধতি আমার আগের উত্তরেরঅ্যারের সাথে , যা শেষ পর্যন্ত এইটির চেয়ে এখনও ছোট (তাই আমি এই বিকল্প পদ্ধতির চেষ্টা করে সময় নষ্ট করছি)।

সাধারণ ব্যাখ্যা:

@ রিলে এর আশ্চর্যজনক 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
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.