recorrer - sumar columnas de una matriz python

Obtenga todas las diagonales en una matriz/lista de listas en Python

Question

Estoy buscando una forma Pythonic para obtener todas las diagonales de una matriz (cuadrada), representada como una lista de listas.

Supongamos que tengo la siguiente matriz:

matrix = [[-2, 5, 3, 2],
[ 9, -6, 5, 1],
[ 3, 2, 7, 3],
[-1, 8, -4, 8]]

Entonces las diagonales grandes son fáciles:

l = len(matrix[0])
print [matrix[i][i] for i in range(l)] # [-2, -6, 7, 8]
print [matrix[l-1-i][i] for i in range(l-1,-1,-1)] # [ 2, 5, 2, -1]

Pero tengo problemas para crear una forma de generar todas las diagonales. El resultado que estoy buscando es:

[[-2], [9, 5], [3,-6, 3], [-1, 2, 5, 2], [8, 7, 1], [-4, 3], [8],
[2], [3,1], [5, 5, 3], [-2, -6, 7, 8], [9, 2, -4], [3, 8], [-1]]

Answer 1

Comience con las diagonales que se inclinan hacia arriba y hacia la derecha.

Si (x, y) es una coordenada rectangular dentro de la matriz, desea transformar a / desde un esquema de coordenadas (p, q), donde p es el número de la diagonal y q es el índice a lo largo de la diagonal. (Entonces p = 0 es la diagonal [-2], p = 1 es la diagonal [9,5], p = 2 es la diagonal [3, -6,3], y así sucesivamente).

Para transformar a (p, q) en an (x, y), puede usar:

x = q
y = p - q

Intente conectar los valores de pyq para ver cómo funciona esto.

Ahora solo hace un bucle ... Para p de 0 a 2N-1, yq de max (0, p-N + 1) a min (p, N-1). Transforma p, q a x, y e imprime.

Luego, para las otras diagonales, repita los bucles pero use una transformación diferente:

x = N - 1 - q
y = p - q

(Esto efectivamente solo voltea la matriz de izquierda a derecha).

Lamento no haber codificado esto en Python. :-)

Answer 2

Esto es para Moe , quien hizo una pregunta similar .

Empiezo haciendo funciones simples para copiar filas o columnas de cualquier matriz rectangular.

def get_rows(grid):
return [[c for c in r] for r in grid]
def get_cols(grid):
return zip(*grid)

Con estas dos funciones, obtengo las diagonales agregando un buffer creciente / decreciente al comienzo / final de cada fila. Luego obtengo las columnas de esta cuadrícula amortiguada, luego elimino el buffer en cada columna después. es decir)

1 2 3 |X|X|1|2|3| | | |1|2|3|
4 5 6 => |X|4|5|6|X| => | |4|5|6| | => [[7],[4,8],[1,5,9],[2,6],[3]]
7 8 9 |7|8|9|X|X| |7|8|9| | |

.

def get_backward_diagonals(grid):
b = [None] * (len(grid) - 1)
grid = [b[i:] + r + b[:i] for i, r in enumerate(get_rows(grid))]
return [[c for c in r if not c is None] for r in get_cols(grid)]
def get_forward_diagonals(grid):
b = [None] * (len(grid) - 1)
grid = [b[:i] + r + b[i:] for i, r in enumerate(get_rows(grid))]
return [[c for c in r if not c is None] for r in get_cols(grid)]

Answer 3

Me encontré con otra solución interesante para este problema. La fila, la columna, la diagonal hacia adelante y hacia atrás se pueden descubrir inmediatamente al observar una combinación de x e y.

Row = x Column = y F-Diag = x+y B-Diag = x-y B-Diag` = -MIN+x-y
| 0 1 2 | 0 1 2 | 0 1 2 | 0 1 2 | 0 1 2
--|--------- --|--------- --|--------- --|--------- --|---------
0 | 0 1 2 0 | 0 0 0 0 | 0 1 2 0 | 0 1 2 0 | 2 3 4
1 | 0 1 2 1 | 1 1 1 1 | 1 2 3 1 |-1 0 1 1 | 1 2 3
2 | 0 1 2 2 | 2 2 2 2 | 2 3 4 2 |-2 -1 0 2 | 0 1 2

En el diagrama, puede ver que cada diagonal y eje es identificable de forma única con estas ecuaciones. Tome cada número único de cada tabla y cree un contenedor para ese identificador.

Tenga en cuenta que las diagonales hacia atrás se han compensado para comenzar en un índice cero, y que la longitud de las diagonales hacia adelante es siempre igual a la longitud de las diagonales hacia atrás.

test = [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
max_col = len(test)
max_row = len(test[0])
cols = [[] for i in range(max_col)]
rows = [[] for i in range(max_row)]
fdiag = [[] for i in range(max_col + max_row - 1)]
bdiag = [[] for i in range(len(fdiag))]
min_bdiag = -max_col + 1
for y in range(max_col):
for x in range(max_row):
cols[y].append(test[y][x])
rows[x].append(test[y][x])
fdiag[x+y].append(test[y][x])
bdiag[-min_bdiag+x-y].append(test[y][x])
print(cols)
print(rows)
print(fdiag)
print(bdiag)

Cuál imprimirá

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

Answer 4

Probablemente haya mejores formas de hacerlo en numpy que debajo, pero aún no estoy muy familiarizado con esto:

import numpy as np
matrix = np.array(
[[-2, 5, 3, 2],
[ 9, -6, 5, 1],
[ 3, 2, 7, 3],
[-1, 8, -4, 8]])
diags = [matrix[::-1,:].diagonal(i) for i in range(-3,4)]
diags.extend(matrix.diagonal(i) for i in range(3,-4,-1))
print [n.tolist() for n in diags]

Salida

[[-2], [9, 5], [3, -6, 3], [-1, 2, 5, 2], [8, 7, 1], [-4, 3], [8], [2], [3, 1], [5, 5, 3], [-2, -6, 7, 8], [9, 2, -4], [3, 8], [-1]]

Editar : se actualizó para generalizar para cualquier tamaño de matriz.

import numpy as np
# Alter dimensions as needed
x,y = 3,4
# create a default array of specified dimensions
a = np.arange(x*y).reshape(x,y)
print a
print
# a.diagonal returns the top-left-to-lower-right diagonal "i"
# according to this diagram:
#
# 0 1 2 3 4 ...
# -1 0 1 2 3
# -2 -1 0 1 2
# -3 -2 -1 0 1
# :
#
# You wanted lower-left-to-upper-right and upper-left-to-lower-right diagonals.
#
# The syntax a[slice,slice] returns a new array with elements from the sliced ranges,
# where "slice" is Python''s [start[:stop[:step]] format.
# "::-1" returns the rows in reverse. ":" returns the columns as is,
# effectively vertically mirroring the original array so the wanted diagonals are
# lower-right-to-uppper-left.
#
# Then a list comprehension is used to collect all the diagonals. The range
# is -x+1 to y (exclusive of y), so for a matrix like the example above
# (x,y) = (4,5) = -3 to 4.
diags = [a[::-1,:].diagonal(i) for i in range(-a.shape[0]+1,a.shape[1])]
# Now back to the original array to get the upper-left-to-lower-right diagonals,
# starting from the right, so the range needed for shape (x,y) was y-1 to -x+1 descending.
diags.extend(a.diagonal(i) for i in range(a.shape[1]-1,-a.shape[0],-1))
# Another list comp to convert back to Python lists from numpy arrays,
# so it prints what you requested.
print [n.tolist() for n in diags]

Salida

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[0], [4, 1], [8, 5, 2], [9, 6, 3], [10, 7], [11], [3], [2, 7], [1, 6, 11], [0, 5, 10], [4, 9], [8]]

Answer 5

Terminé reinventando esta rueda recientemente. Aquí hay un método fácil de reutilizar / extender para encontrar las diagonales en una lista de listas cuadradas:

def get_diagonals(grid, bltr = True):
dim = len(grid)
assert dim == len(grid[0])
return_grid = [[] for total in xrange(2 * len(grid) - 1)]
for row in xrange(len(grid)):
for col in xrange(len(grid[row])):
if bltr: return_grid[row + col].append(grid[col][row])
else: return_grid[col - row + (dim - 1)].append(grid[row][col])
return return_grid

Asumiendo índices de lista:

00 01 02 03

10 11 12 13

20 21 22 23

30 31 32 33

a continuación, estableciendo bltr = True (valor predeterminado), devuelve las diagonales de abajo a la izquierda a la parte superior derecha, es decir,

00 # row + col == 0
10 01 # row + col == 1
20 11 02 # row + col == 2
30 21 12 03 # row + col == 3
31 22 13 # row + col == 4
32 23 # row + col == 5
33 # row + col == 6

configuración bltr = False , devuelve las diagonales de abajo a la izquierda a la parte superior derecha, es decir,

30 # (col - row) == -3
20 31 # (col - row) == -2
10 21 32 # (col - row) == -1
00 11 22 33 # (col - row) == 0
01 12 23 # (col - row) == +1
02 13 # (col - row) == +2
03 # (col - row) == +3

Aquí hay una versión ejecutable usando la matriz de entrada de OP.

Answer 6

Esto solo funciona para matrículas de igual ancho y alto. Pero tampoco depende de terceros.

matrix = [[11, 2, 4],[4, 5, 6],[10, 8, -12]]
# only works for diagnoals of equal width and height
def forward_diagonal(matrix):
if not isinstance(matrix, list):
raise TypeError("Must be of type list")
results = []
x = 0
for k, row in enumerate(matrix):
# next diag is (x + 1, y + 1)
for i, elm in enumerate(row):
if i == 0 and k == 0:
results.append(elm)
break
if (x + 1 == i):
results.append(elm)
x = i
break
return results
print ''forward diagnoals'', forward_diagonal(matrix)