Dengan matriks, jumlah nilainya naik / turun atau kiri / kanan untuk membentuk X, lipat ke atas, dan kembalikan daftar. Saya jelaskan algoritme di sini:

Algoritma

Input Anda akan berupa matriks persegi bilangan bulat berukuran ganjil dalam kapasitas numerik wajar bahasa Anda.

Mari kita ambil matriks berikut sebagai contoh:

1 2 3 2 1
0 3 2 3 0
4 2 5 6 3
7 4 7 9 4
0 6 7 2 5

Pertama, tambahkan setiap angka ke nomor terdekat yang ada di diagonal utama atau antidiagonal. Yaitu, bagi matriks menjadi empat bagian di sepanjang diagonal utama dan antidiagonal, dan kemudian jumlah semua angka di setiap bagian menuju pusat, seperti:

1   2   3   2   1
    ↓   ↓   ↓    
0 → 3   2   3 ← 0
        ↓        
4 → 2 → 5 ← 6 ← 3
        ↑        
7 → 4   7   9 ← 4
    ↑   ↑   ↑    
0   6   7   2   5

Langkah ini memberikan hasil sebagai berikut:

1        1
  5    5
    39
  17  15
0        5

Kemudian, kita lipat dengan meratakan X dan menjalin elemen dengan kiri atas terlebih dahulu dan kiri bawah terakhir. Ini memberikan hasil sebagai berikut:

1, 0, 5, 17, 39, 5, 15, 1, 5

Anda dapat membayangkan ini sebagai peregangan diagonal utama dan memutarnya berlawanan arah jarum jam.

Ini adalah hasil akhir.

Tantangan

Terapkan algoritma ini. Celah standar berlaku. Semua format I / O yang masuk akal dapat diterima.

Uji Kasus

Input
Output

1 2 3 2 1
0 3 2 3 0
4 2 5 6 3
7 4 7 9 4
0 6 7 2 5

1, 0, 5, 17, 39, 5, 15, 1, 5

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

1, 6, 11, 16, 47, 7, 22, 5, 0

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

1, 8, 15, 11, 23, 20, 62, 32, 25, 13, 18, 3, 9

JavaScript, 113 byte

s=>(l=s.length-1,a=[],s.map((v,y)=>v.map((n,x)=>a[q=2*[x,y,l-y].sort((u,v)=>u-v)[1]+(y>l/2),q-=q>l]=~~a[q]+n)),a)

f=

s=>(l=s.length-1,a=[],s.map((v,y)=>v.map((n,x)=>a[q=2*[x,y,l-y].sort((u,v)=>u-v)[1]+(y>l/2),q-=q>l]=~~a[q]+n)),a)

<p><textarea id="i" style="width: 400px; height: 120px">1 2 3 2 1
0 3 2 3 0
4 2 5 6 3
7 4 7 9 4
0 6 7 2 5</textarea></p>
<p><button onclick="o.value=f(i.value.trim().split`\n`.map(l=>l.trim().split(/\s+/).map(v => parseInt(v,10)))).join` `">Run</button></p>
<p><output id="o"></output></p>

Jelly , 25 23 21 byte

AṂ×ṠṚ
LHŒRṗ2Ç€ḅLĠịFS€

Cobalah online!

Versi alternatif, 19 byte

AṂ×ṠṚ
LHŒRṗ2Ç€ĠịFS€

Ini tidak digunakan untuk bekerja karena Ġberperilaku tidak tepat untuk array bersarang. Satu-satunya perbedaan adalah bahwa pasangan [q, p] disebutkan dalam Cara kerjanya diurutkan secara leksikografis alih-alih memetakannya ke p + nq sebelum menyortir.

Cobalah online!

Latar Belakang

Kita mulai dengan mengganti elemen-elemennya dengan koordinat, meningkat ke kiri dan ke bawah dan menempatkan (0, 0) di tengah-tengah matriks.

Untuk matriks 7x7 M , kita mendapatkan koordinat berikut.

(-3,-3) (-3,-2) (-3,-1) (-3, 0) (-3, 1) (-3, 2) (-3, 3)
(-2,-3) (-2,-2) (-2,-1) (-2, 0) (-2, 1) (-2, 2) (-2, 3)
(-1,-3) (-1,-2) (-1,-1) (-1, 0) (-1, 1) (-1, 2) (-1, 3)
( 0,-3) ( 0,-2) ( 0,-1) ( 0, 0) ( 0, 1) ( 0, 2) ( 0, 3)
( 1,-3) ( 1,-2) ( 1,-1) ( 1, 0) ( 1, 1) ( 1, 2) ( 1, 3)
( 2,-3) ( 2,-2) ( 2,-1) ( 2, 0) ( 2, 1) ( 2, 2) ( 2, 3)
( 3,-3) ( 3,-2) ( 3,-1) ( 3, 0) ( 3, 1) ( 3, 2) ( 3, 3)

Kami sekarang menghitung nilai absolut minimum dari setiap pasangan koordinat dan mengalikan tanda-tanda dari kedua koordinat tersebut, memetakan (i, j) ke (tanda (i) m, tanda (j) m) , di mana m = min (| i | , | j |) .

(-3,-3) (-2,-2) (-1,-1) ( 0, 0) (-1, 1) (-2, 2) (-3, 3)
(-2,-2) (-2,-2) (-1,-1) ( 0, 0) (-1, 1) (-2, 2) (-2, 2)
(-1,-1) (-1,-1) (-1,-1) ( 0, 0) (-1, 1) (-1, 1) (-1, 1)
( 0, 0) ( 0, 0) ( 0, 0) ( 0, 0) ( 0, 0) ( 0, 0) ( 0, 0)
( 1,-1) ( 1,-1) ( 1,-1) ( 0, 0) ( 1, 1) ( 1, 1) ( 1, 1)
( 2,-2) ( 2,-2) ( 1,-1) ( 0, 0) ( 1, 1) ( 2, 2) ( 2, 2)
( 3,-3) ( 2,-2) ( 1,-1) ( 0, 0) ( 1, 1) ( 2, 2) ( 3, 3)

Elemen matriks yang sesuai dengan pasangan yang sama harus dijumlahkan. Untuk menentukan urutan jumlah, kami memetakan setiap pasangan (p, q) untuk p + nq , di mana n adalah jumlah baris / kolom M .

-24 -16  -8   0   6  12  18
-16 -16  -8   0   6  12  12
 -8  -8  -8   0   6   6   6
  0   0   0   0   0   0   0
 -6  -6  -6   0   8   8   8
-12 -12  -6   0   8  16  16
-18 -12  -6   0   8  16  24

Urutan jumlah sesuai dengan urutan bilangan bulat sesuai dengan puncaknya.

Bagaimana itu bekerja

LHŒRṗ2Ç€ḅLĠịFS€  Main link. Argument: M (matrix)

L                Compute n, the length (number of rows) of M.
 H               Halve it.
  ŒR             Symmetric range; map t to [-int(t), ..., 0, int(t)].
    ṗ2           Compute the second Cartesian power, yielding all pairs [i, j]
                 with -t ≤ i, j ≤ t.
      ǀ         Map the helper link over the resulting array of pairs.
         L       Yield n.
        ḅ        Unbase; map each pair [q, p] to (p + nq).
          Ġ      Group the indices of the resulting array of n² integers by their
                 corresponding values, ordering the groups by the values.
            F    Flatten M.
           ị     Index into the serialized matrix.
             S€  Compute the sum of each group.


AṂ×ṠṚ            Helper link. Argument: [i, j] (index pair)

A                Absolute value; yield [|i|, |j|].
 Ṃ               Minimum; yield m := min(|i|, |j|).
   Ṡ             Sign; yield [sign(i), sign(j)].
  ×              Multiply; yield [p, q] := [sign(i)m, sign(j)m].
    Ṛ            Reverse; yield [q, p].

Python, 159 158 byte

def f(m):l=len(m)-1;r=range(1,l);return m[0][::l]+f([[sum(m[x][1%y*y:(y>l-2)-~y])+m[0][y]*(x<2)+m[l][y]*(x>l-2)for y in r]for x in r])+m[l][::l]if l else m[0]

Cobalah online!

Dyalog APL , 101 99 64 62 59 byte

_{3 byte disimpan oleh @ Adám}

{+/∘,¨⍵∘רd∘=¨k[⍋k←↑∪/,d←∘.((+/1x×××⌊/∘|),)⍨(⍳x)-⌈.5×x←≢⍵]}

Cobalah online!

Menggunakan algoritma hebat Dennis .

APL (Dyalog) , 60 byte *

Bekerja sama dengan rekan saya Marshall .

Lambda awalan anonim. Membawa matriks sebagai argumen dan mengembalikan vektor. Asumsikan ⎕IO ( I ndex O rigin) menjadi nol, yang merupakan standar pada banyak sistem.

{(,⍉{+/,(s×-×⍺)↓⍵×i∊¨⍨s←⌊⊃r÷2}⌺r⊢⍵)/⍨,(⊢∨⌽)=/¨i←⍳r←⍴⍵}

Cobalah online!

{... } lambda anonim; ⍵adalah argumen yang benar (sebagai huruf paling kanan dari alfabet Yunani):

 ⍴⍵ bentuk argumen (daftar dua elemen identik)

 r← simpan sebagai r(seperti dalam r ho)

 ⍳ semua ɩ keterangan dari array sebesar itu, yaitu (0 0), (0 1)…

 i← simpan di i(seperti dalam i ota)

 =/¨ Boolean di mana koordinatnya sama (yaitu diagonal)

 (... ) terapkan fungsi awalan tersembunyi anonim ini:

  ⌽ membalikkan argumen

  ⊢∨ ATAU itu dengan argumen yang tidak dimodifikasi

 , ravel (luruskan menjadi daftar sederhana)

 Kami sekarang memiliki topeng Boolean untuk diagonal.

 (... )/⍨ gunakan itu untuk menyaring yang berikut ini:

  ⊢⍵ hasilkan (untuk memisahkan dari r) argumen

  {… }⌺r Panggil lambda infix anonim berikut pada setiap elemen, dengan r-neighbourhood (diisi dengan nol sesuai kebutuhan) sebagai argumen yang benar ( ⍵), dan daftar dua elemen dari jumlah baris berlapis, kolom (negatif untuk bawah / kanan, nol untuk tidak ada) sebagai argumen kiri ( ⍺):

   r÷2 bagi rdengan dua

   ⊃ pilih elemen pertama (mereka identik)

   ⌊ lantai itu

   s← simpan sebagai s(untuk s hape)

   i∊⍨¨ untuk setiap elemen i, Boolean jika smerupakan anggotanya

   ⍵× kalikan lingkungan dengan itu

   (... )↓ jatuhkan jumlah baris dan kolom berikut (negatif untuk bawah / kanan):

    ×⍺ signum dari argumen kiri (yaitu arah paddings)

    - meniadakan

    s× berkembang biak sdengan itu

   , ravel (luruskan ke daftar)

   +/ jumlah (plus reduksi)

Sekarang kita memiliki matriks total penjumlahan, tetapi kita perlu memfilter semua nilai yang dibaca secara kolom.

  ⍉ mengubah urutan

  , ravel (luruskan menjadi daftar sederhana)

* Dengan menghitung ⌺sebagai ⎕U233A . Cobalah online!