Для данной матрицы суммируйте ее значения вверх / вниз или влево / вправо, чтобы сформировать X, сложите ее и верните список. Я опишу алгоритм здесь:

Алгоритм

Ваш ввод будет квадратной матрицей нечетного размера целых чисел в пределах разумной числовой емкости вашего языка.

Давайте возьмем следующую матрицу в качестве примера:

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   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        1
  5    5
    39
  17  15
0        5

Затем мы складываем его, выравнивая X и переплетая элементы с верхним левым первым и нижним левым последним. Это дает следующий результат:

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

Вы можете представить это как растяжение главной диагонали и вращение против часовой стрелки.

Это конечный результат.

Вызов

Реализуйте этот алгоритм. Применяются стандартные лазейки. Все приемлемые форматы ввода / вывода приемлемы.

Тестовые случаи

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 байт

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>

Желе , 25 23 21 байт

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

Попробуйте онлайн!

Альтернативная версия, 19 байт

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

Это не использовалось для работы, потому что Ġвел себя неправильно для вложенных массивов. Единственное отличие состоит в том, что пары [q, p], упомянутые в разделе « Как это работает» , сортируются лексикографически, а не отображаются в p + nq перед сортировкой.

Попробуйте онлайн!

Фон

Начнем с замены его элементов координатами, увеличения влево и вниз и размещения (0, 0) в центре матрицы.

Для матрицы 7x7 M мы получаем следующие координаты.

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

Теперь мы вычисляем минимальное абсолютное значение каждой пары координат и умножаем на нее знаки обеих координат, сопоставляя (i, j) с (sign (i) m, sign (j) m) , где 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)

Матричные элементы, которые соответствуют одной и той же паре, должны суммироваться. Для того, чтобы определить порядок сумм, каждую пару (P, Q) , чтобы р + NQ , где п есть число строк / столбцов М .

-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

Порядок сумм соответствует порядку целых чисел, соответствующих его слагаемым.

Как это устроено

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 байт

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]

Попробуйте онлайн!

Dyalog APL , 101 99 64 62 59 байт

_{3 байта сохранены @ Adám}

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

Попробуйте онлайн!

Используя потрясающий алгоритм Денниса .

APL (Dyalog) , 60 байт *

В сотрудничестве с моим коллегой Маршаллом .

Анонимный префикс лямбда. Принимает матрицу в качестве аргумента и возвращает вектор. Предполагается ⎕IO ( I ndex O rigin) равным нулю, что по умолчанию во многих системах.

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

Попробуйте онлайн!

{... } анонимная лямбда; ⍵Правильный аргумент (как самая правая буква греческого алфавита):

 ⍴⍵ форма аргумента (список из двух одинаковых элементов)

 r← сохранить как r(как в r ho)

 ⍳ все ɩ ndices массива такого размера, то есть (0 0), (0 1)...

 i← хранить в i(как в i ota)

 =/¨ Булево, где координаты равны (то есть диагональ)

 (… ) Применить эту анонимную функцию молчаливого префикса:

  ⌽ изменить аргумент

  ⊢∨ ИЛИ что с неизмененным аргументом

 , Равель (выпрямить в простой список)

 Теперь у нас есть логическая маска для диагоналей.

 (… )/⍨ Используйте это для фильтрации следующего:

  ⊢⍵ приводить (отделять r) от аргумента

  {… }⌺r Вызвать следующий анонимный лямбда-инфикс для каждого элемента, rуказав в качестве аргумента -neighbourhood (дополненный нулями ⍵), и список из двух элементов с числами, дополненными числом, столбцами (отрицательный для нижнего / правого, нулевой для нулевого) как левый аргумент ( ⍺):

   r÷2 разделить rс двумя

   ⊃ выбрать первый элемент (они идентичны)

   ⌊ пол это

   s← сохранить как s(для s hape)

   i∊⍨¨ для каждого элемента i, логическое значение if sявляется его членом

   ⍵× умножить соседство с ним

   (… )↓ Удалить следующее количество строк и столбцов (отрицательное для нижнего / правого):

    ×⍺ Signum левого аргумента (то есть направление отступов)

    - NEGATE

    s× умножить sс этим

   , Равель (выпрямить в список)

   +/ сумма (плюс уменьшение)

Теперь у нас есть полная матрица сумм, но нам нужно отфильтровать все значения, считанные по столбцам.

  ⍉ транспонирования

  , Равель (выпрямить в простой список)

* Считая ⌺как ⎕U233A . Попробуйте онлайн!