Получить диагональ без использования numpy?

Question

Я пытаюсь получить диагональ от матрицы в Python без использования numpy (я действительно не могу его использовать). Кто-то здесь знает, как это сделать?

Пример того, что я хочу получить:

get_diagonal ([[1,2,3,4],[5,6,7,8],[9,10,11,12]], 1, 1, 1) 
Result: [1, 6, 11] 

Или как:

get_diagonal ([[1,2,3,4],[5,6,7,8],[9,10,11,12]], 1, 2, 1) 
Result: [2, 7, 12] 

До знаю, я пробовал много вещей, но не работает.

def obter_diagonal(matrix, line, column, direc): 
    d = [] 
    if direc == 1: 
     for i in matrix: 
      for j in i: 
       if all(i == line, j == column): 
        d.extend(matrix[i][j]) 
    else: 
     for i in matrix: 
      for j in i: 
       d.extend[len(matrix)-1-i][j] 
    return d 

Если direc==1 мне нужно, чтобы получить диагональ, которая идет от лево-> правой, топ-> внизу.
Если direc==-1 необходимо получить диагноз, который идет справа-> влево, сверху-> снизу.

Answer 1

Чтобы получить главной диагонали вы могли бы сделать

diag = [ mat[i][i] for i in range(len(mat)) ] 

или даже

diag = [ row[i] for i,row in enumerate(mat) ] 

и играть в подобные игры для других диагоналей. Например, для борьбы с диагональной (сверху справа вниз налево) вы могли бы сделать что-то вроде:

diag = [ row[-i-1] for i,row in enumerate(mat) ] 

Для других второстепенных диагоналей вы должны использовать if условными в списке понимания, например:

diag = [ row[i+offset] for i,row in enumerate(mat) if 0 <= i+offset < len(row)] 

Answer 2

def get_diagonal(m, i0, j0, d): 
    return [m[(i0 + i - 1)%len(m)][(j0 + d*i - 1)%len(m[0])] 
       for i in range(len(m))] 

который получает диагоналей в прямом или обратном направлениях:

m = [[1, 2, 3, 4], 
    [5, 6, 7, 8], 
    [9,10,11,12]] 

print get_diagonal(m, 1, 1, 1) # [1, 6, 11] 
print get_diagonal(m, 1, 2, 1) # [2, 7, 12] 
print get_diagonal(m, 1, 4,-1) # [4, 7, 10] 

Это даже оборачивается вокруг матрицы, чтобы получить диагонали:

print get_diagonal(m, 1, 4, 1) # [4, 5, 10] 
print get_diagonal(m, 1, 1,-1) # [1, 8, 11] 
print get_diagonal(m, 3, 1, 1) # [9, 2, 7 ] 

Answer 3

Ну, у меня есть решение, которое работает для меня.

Входной сигнал:

Первая строка содержит целое число N

Следующие N линии обозначают строки матрицы, в каждой строке, содержащей пробел записаны целые числа, описывающие столбцы.

Пример ввода:

3 
11 2 4 
4 5 6 
10 8 -12 

Код:

import sys 


n = int(input().strip()) 
a = [] 
for a_i in range(n): 
    a_t = [int(a_temp) for a_temp in input().strip().split(' ')] 
    a.append(a_t) 

pri_d = []; 
pri_m = 0; 
sec_d = []; 
sec_m = n - 1; 
for i in a: 
    pri_d.append(i[pri_m]); 
    sec_d.append(i[sec_m]); 
    pri_m = pri_m + 1; 
    sec_m = sec_m - 1; 
print(pri_d); 
print(sec_d); 

выход:

[11, 5, -12] 
[4, 5, 10] 

Answer 4

Поскольку никто не упомянул карту или лямбды здесь, я оставлю решение:

list(map(lambda x: x[a.index(x)], a)) 

Таким образом, в массиве 0 он будет захватывать элемент 0 и т. Д.

Что касается противоположной диагонали вы можете либо перевернуть массив снизу вверх или принять во внимание длину массива минус один и вычитать текущий индекс к нему:

list(map(lambda x: x[(len(a) - 1) - a.index(x)], a))) 

Надеется, что это помогает!

Answer 5

Для диагонали:

[m[i][i] for i in xrange(0, len(m))]

Для борьбы с диагональной:

[m[i][~i] for i in xrange(0, len(m))]