ผลรวมของแถวและคอลัมน์แรกจากนั้นแถวและคอลัมน์ที่สอง…และอื่น ๆ

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 
— Stewie Griffin
แหล่งที่มา
2
@JanathanAllan การพิมพ์เลขศูนย์ตลอดไปนั้นค่อนข้างยืดเยื้อดังนั้นฉันคิดว่าฉันต้องไม่พูดกับคนนั้น
— Stewie Griffin
1
โปรแกรม Retinaเพื่อแปลงจากตัวอย่างสวย ๆ ไปยัง Python Array
— mbomb007
1
ดูตัวอย่าง ภารกิจประเภทที่ไม่ถูกต้อง คอลัมน์ที่สองในตัวอย่างแรกคือ10,7,7,1แถวที่สองคือและรวมเป็น9,7,7,2,9 59และอื่น ๆ
— edc65
1
@ edc65 ดูที่ตัวอย่างปรากฏว่าตัวเลขที่ใช้ในการคำนวณครั้งก่อนไม่ถูกนำมาใช้ หรืออีกวิธีหนึ่งเมื่อพิจารณาแถวที่ n ให้ใช้เฉพาะค่าจากคอลัมน์ nth และไม่สนใจค่าในคอลัมน์ 1 ถึง n-1
— ไบรอัน J
1
@ Arc676 กฎ io มาตรฐาน ฟังก์ชันอาร์กิวเมนต์เป็นหนึ่งในวิธีการอินพุตที่ยอมรับ
— Stewie Griffin

คำตอบ:

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คำนวณองค์ประกอบขั้นต่ำที่ชาญฉลาดด้วยการออกอากาศซึ่งให้เมทริกซ์

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

X:linearizes เมทริกซ์นี้ (ตามลำดับคอลัมน์หลัก) [1; 1; 1; 1; 1; 2; 2; ... ; 4]เป็นเวกเตอร์คอลัมน์ เวกเตอร์และเมทริกซ์เชิงเส้นการป้อนข้อมูลที่ได้รับเป็นGX:, จะถูกส่งผ่านเป็นปัจจัยการผลิตไปยังฟังก์ชั่นหรือaccumarray(... @sum) 1XQสิ่งนี้คำนวณผลรวมของอินพุตที่สองที่จัดกลุ่มตามค่าของอินพุตแรก

— หลุยส์เมนโด
แหล่งที่มา
5

CJam , 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
@FrodCube มันจะได้รับอนุญาตโดยฉันทามติ meta
— ธุรกิจ Cat
2
ที่จริงแล้วในทางเทคนิคแล้วมันจะมีความยาวเท่ากับโปรแกรมเต็มรูปแบบเนื่องจากฉันไม่สามารถเปิด[ได้ แต่เป็นบล็อกฉันคิดว่าฉันต้องการเพราะมันไม่จำเป็นต้องจับสแต็คด้านล่างทั้งหมดด้วย
— ธุรกิจ Cat
4

JavaScript (ES6), 60 ไบต์

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

ทางออกไร้เดียงสาอาจเป็นวิธีที่ดีกว่า

— ETHproductions
แหล่งที่มา
4

Mathematica, 60 ไบต์

แรงบันดาลใจจากคำตอบ MATL หลุยส์ Mendo ของ

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@#]}iterates nกว่า

นี่คือ 1 ไบต์ที่สั้นกว่าวิธีnaïve:

{#[[n,n;;]],#[[n+1;;,n]]}~Total~2~Table~{n,Min@Dimensions@#}&
— ไม่ใช่ต้นไม้
แหล่งที่มา
4

Haskell, 50 49 ไบต์

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

ลองออนไลน์!

หากมีอย่างน้อยหนึ่งแถวที่มีองค์ประกอบอย่างน้อยหนึ่งรายการผลลัพธ์คือผลรวมของแถวแรกและส่วนหัวของแถวอื่น ๆ ทั้งหมดตามด้วยการเรียกแบบเรียกซ้ำด้วยส่วนท้ายของแถวอื่น ๆ ทั้งหมด ในกรณีอื่นทั้งหมดผลลัพธ์คือรายการว่าง

แก้ไข: Ørjan Johansen บันทึกไบต์ ขอบคุณ!

— Nimi
แหล่งที่มา
4

อ็อกเทฟ64 64ไบต์

ขอบคุณ @StewieGriffin สำหรับการบันทึก 1 ไบต์!

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

เสียงคู่แปดฟ63 63ไบต์

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

Java 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
— Kevin Cruijssen
แหล่งที่มา
2

Perl 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 ซิปอินพุตเมทริกซ์ด้วย transpose-sans-first-column สร้างรายการ ((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)
— Jonathan Allan
แหล่งที่มา
1

Python 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
แหล่งที่มา
มีช่องว่างในคำตอบนี้ที่สามารถลบออกได้เป็นจำนวนมาก
— ข้าวสาลีตัวช่วยสร้าง
@WheatWizard ขอบคุณ! ลดคำตอบของฉันลง 4 ไบต์ :)
— ZestyLemon
1

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

GNU APL 1.7, 123 bytes

โซลูชันต้องการฟังก์ชันที่สอง: หนึ่งสร้างอาร์เรย์ส่วนกลางและการเรียกที่สองซึ่งผนวกผลรวมซ้ำกับอาร์เรย์นั้นซ้ำ

∇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∈⍴NBranch ไปยังหมายเลขบรรทัด 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]) APL จะเข้าถึงแต่ละรายการ ดังนั้น1↓⍳1⊃⍴Nให้ดัชนีของแต่ละแถวไม่รวมหนึ่ง ( 2, 3, 4, ..., N) แรกและ1↓⍳2⊃⍴Nให้เวกเตอร์ที่คล้ายกัน แต่สำหรับคอลัมน์ g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]เรียกใช้ฟังก์ชันอีกครั้ง แต่ไม่มีแถวหรือคอลัมน์แรก

— Arc676
แหล่งที่มา
0

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

Clojure 98 ไบต์

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

ทำซ้ำอินพุตที่มีดัชนีแถวและคอลัมน์ (ในลักษณะที่ละเอียดมาก) สร้าง hash-map ที่มีค่าต่ำสุดiและjเป็นคีย์ผสาน hash-maps +เข้ากับแผนที่เรียงแล้วส่งคืนค่า

— NikoNyrh
แหล่งที่มา
0

R, 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]ทำให้มันล้มเหลวในกรณีของเมทริกซ์จตุรัสเพราะเมื่อใดx 2x2 การเซ็ตย่อยจะส่งคืนเวกเตอร์แทนที่จะเป็นเมทริกซ์

ลองออนไลน์!

— จูเซปเป้
แหล่งที่มา
0

Java 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 's ที่น่าตื่นตาตื่นใจ
คำตอบนี้จะใช้รายการและทุกครั้งหลังมีการคำนวณผลรวมก็เอาคอลัมน์แรกและแถวแรกจากรายการที่แมทริกซ์เช่นนี้

// 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
— Kevin Cruijssen
แหล่งที่มา
0

Python ขนาด 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.