Get diagonal ohne numpy zu verwenden?

Question

Ich versuche, die Diagonale von einer Matrix in Python zu bekommen, ohne numpy zu verwenden (ich kann es wirklich nicht benutzen). Weiß jemand hier, wie es geht?

Beispiel dessen, was ich zu bekommen:

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

Oder wie:

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

Bis weiß, dass ich eine Menge Sachen ausprobiert habe aber nicht funktioniert.

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 

Wenn direc==1 Ich brauche die diagonal zu erhalten, die von links> rechts geht, oben-> unten.
Wenn direc==-1 müssen die Diag gehen, die von rechts geht-> links, oben-> unten.

Answer 1

Um die führende Diagonale erhalten Sie ähnliche Spiele für andere Diagonalen

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

oder sogar

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

Und spielen tun könnte. Zum Beispiel für die Gegendiagonale (oben rechts nach unten links) Sie möchten etwas tun:

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

für andere kleinere Diagonalen würden Sie if conditionals in der Liste Verständnis verwenden, zum Beispiel:

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

, die die Diagonalen in Vorwärts- oder Rückwärtsrichtung wird:

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] 

Es wickelt sogar rund um die Matrix Diagonalen zu erhalten:

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

Nun, ich habe eine Lösung, die für mich funktioniert.

Input:

erste Zeile enthält eine ganze Zahl N

Die nächsten N Linien bezeichnen die Zeilen der Matrix, wobei jede Zeile, die durch Leerzeichen getrennte ganze Zahlen, die Spalten beschreiben.

Probe Input:

3 
11 2 4 
4 5 6 
10 8 -12 

Code:

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

Ausgang:

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

Answer 4

Da niemand hier Karte oder lambda erwähnt, werde ich eine Lösung verlassen:

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

Auf diese Weise bei Array 0 wird Element 0 und so weiter greifen.

Was die diagonal gegenüberliegenden Sie können die Länge des Arrays minus eins und subtrahieren den aktuellen Index, um es entweder Flip das Array von unten nach oben oder in Betracht ziehen wollen:

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

Hoffe, es hilft!

Answer 5

Für diagonal:

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

Für Gegendiagonale:

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