Как найти побочную диагональ матрицы питон

Here is a simple way using numpy slicing. I personally find it not too hard on the eyes, but agree that fliplr is more descriptive.

Just to highlight this example’s contribution to existing answers, I ran the same simple benchmark:

In [1]: import numpy as np

In [3]: X = np.random.randint(0, 10, (5, 5))

In [4]: X
Out[4]: 
array([[7, 2, 7, 3, 7],
       [8, 4, 5, 9, 6],
       [0, 2, 9, 0, 4],
       [8, 2, 1, 0, 3],
       [3, 1, 0, 7, 0]])

In [5]: Y = X[:, ::-1]

In [6]: Z1 = np.diag(Y)

In [7]: Z1
Out[7]: array([7, 9, 9, 2, 3])

Parity comparison to fastest alternative:

In [8]: step = len(X) - 1

In [9]: Z2 = np.take(X, np.arange(step, X.size-1, step))

In [10]: Z2
Out[10]: array([7, 9, 9, 2, 3])

In [11]: np.array_equal(Z1, Z2)
Out[11]: True

Benchmarks

In [12]: %timeit np.diag(X[:, ::-1])
1.92 µs ± 29.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [13]: %timeit step = len(X) - 1; np.take(X, np.arange(step, X.size-1, step))
2.21 µs ± 246 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Initial comparisons indicate that my solution is additionally linear in complexity, while using the second ‘step’ solution is not:

In [14]: big_X = np.random.randint(0, 10, (10000, 10000))

In [15]: %timeit np.diag(big_X[:, ::-1])
2.15 µs ± 96.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [16]: %timeit step = len(big_X) - 1; np.take(big_X, np.arange(step, big_X.size-1, step))
100 µs ± 1.85 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

I generally use this method to either flip images (mirroring them), or to convert between opencv‘s format of (channels, height, width) to matplotlib‘s format of (height, width , channels). So for a three dimensional image, it’d simply be flipped = image[:, :, ::-1]. Of course you can generalise it to flip along any dimension, by putting the ::-1 part in the desired dimension.

Квадратная матрица

Квадратные матрицы

Пусть матрица А содержит N строк и столько же столбцов. Такие матрицы называют квадратными.
У квадратных матриц можно выделить главную и побочную диагонали.

Главная диагональ — диагональ, которая идет с левого верхнего угла в правый нижний угол.
Побочная диагональ — идет с правого верхнего угла в левый нижний угол.

Тогда для перебора всех элементов, стоящих на главной диагонали достаточно одного цикла:

псевдокод:
для i от 0 до N-1
     работаем с A[i][i]

Таким же циклом можно перебрать элементы побочной диагонали.

Для элементов, стоящих на побочной диагонали сумма индексов строки и столбца постоянна и равна N-1.

псевдокод:
для i от 0 до N-1
     работаем с A[i][N-1-i]

Чтобы обработать все элементы, расположенные на главной диагонали и под ней, нужен вложенный цикл:
— номер строки меняется от 0 до N-1;
— номер столбца от 0 до i.

псевдокод:
для i от 0 до N-1
    для j от 0 до i
     работаем с A[i][j]

1

Получение диагоналей в матрице. Алгоритм

Одна из причин, почему я захотел написать строчки насчет этого алгоритма, так как сам в большинстве случаев находил лишь вариант решения с numPy. Это, безусловно, отличная библиотека, но все же интересен сам алгоритм для использования в различных целях. Ну а начать, пожалуй, хочется с минимальным количеством воды, поэтому сразу начну с объяснения метода.

Очевидное, что приходит в голову, что если «продлить» диагонали, или же, другими словами, представить диагонали в виде набора элементов, то количество тех самых элементов будет равно, но не все матрицы будут заполнены «по максимуму». Посмотрим на изображение 1, в котором числами сверху отмечены номера диагоналей и они проведены через элементы таблицы чисел. Не трудно осознать, что количество таких диагоналей равно $inline$N + M — 1$inline$, где N — количество строк в таблице, а M — количество столбцов в таблице. Пускай номера диагоналей, чье начало начинается с отсутствия элементов, обозначим зеленым цветом для удобства понимания.

В голову напрашивается очевидный вариант, как можно получить все диагонали с их элементами. А точнее, перебрать $inline$N + M — 1$inline$, в начале пусто заполненных, диагоналей и заполнить их соответствующими элементами. Перебирать будем в диапазоне

$$display$$[-(N — 1); M)$$display$$

, поскольку все числа, какие будут «с минусом» в данном диапазоне будет, как раз, равно кол-ву диагоналям, чье начало идет с «пустыми элементами», а точнее вообще без ничего и будет равно кол-ву $inline$N — 1 = (N + M — 1 — M)$inline$. Удобно использовать в реализации.

diagonals = [[] for i in range(N + M - 1)]
for i in range(-(N - 1), M):
....

Изображение 1

Соображение №1

Давайте выясним, как можно заполнить нужными элементами. Для начала вспомним, что элементы главной диагонали подчиняются правилу, что индекс позиции элемента a (= a[i][i]), где i — номер столбца и строки соответственно. Теперь можно обратить внимание, что другие безымянные диагонали отличаются лишь позицией лишь началом «отсчёта». В общем виде каждый $inline$i$inline$-овый элемент дополнительных диагоналей, параллельных главной диагонали, можно выразить так: $inline$b[i] = a[i][i + j]$inline$, $inline$b$inline$ — набор элементов диагонали, где $inline$i$inline$ — номер элемента, $inline$j$inline$ — «коэффициент отклонения диагонали», то есть на сколько столбец уходит в сторону от нулевого. Влево, вправо — неважно. И также, безусловно, условия, чтобы не выходить за границы.
Получаем:

$$display$$begin{cases} b[i] = a[i][i + j], &text{где $i$ — это номер элемента в $j + N — 1$ диагонали, $a$ — исходная матрица} \ 0 <= i < n \ 0 <= i + j < m end{cases}$$display$$

То есть достаточно добавить до N элементов в набор каждой диагонали. Отметим, что если индекс выходит за границы размера таблицы, то элемент явно не является частью набор любой диагонали. Также поскольку номер позиции каждого элемента диагонали = номеру строки, в которой он находится, то значение некому row присвоим j. Столбец (col), можно понять, что равен i + j, исходя из соображения под номером (1). Нам остается лишь обязательно учитывать границы row и col, дабы избежать выхода из границ существующих элементов для наших диагоналей.

diagonals = [[] for i in range(N + M - 1)]
for i in range(-(N - 1), M):
    for j in range(N):
        row, col = j, i + j
        if 0 <= row < len(matrix) and 0 <= col < len(matrix[0]):
            diagonals[i + len(matrix) - 1].append(matrix[row][col])

Также этот алгоритм можно немного изменить, чтобы проделать процесс относительно диагоналей, параллельных побочной диагонали, изменив лишь эту строчку таким образом:

diagonals[i + len(matrix) - 1].append(matrix[row][M - col - 1])

На этом в принципе все. Нетрудный для понимания алгоритм поможет найти все диагонали в матрице.