Détermination des voisins de la liste bidimensionnelle de cellules

Question

J'ai une liste de listes, quelque chose comme

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

Représenté graphiquement comme:

1 2 3
4 5 6
7 8 9

Je recherche une méthode élégante pour vérifier la valeur des voisins d’une cellule, horizontalement, verticalement et en diagonale. Par exemple, les voisins de [0] [2] sont [0] [1], [1] [1] et [1] [2] ou les nombres 2, 5, 6.

Maintenant, je réalise que je pourrais faire une attaque par force brute en vérifiant chaque valeur à la fois:

[i-1][j]
[i][j-1]
[i-1][j-1]
[i+1][j]
[i][j+1]
[i+1][j+1]
[i+1][j-1]
[i-1][j+1]

Mais c’est facile, et j’ai pensé que je pourrais en apprendre davantage en découvrant des approches plus élégantes.

Answer 1

# Size of "board"
X = 10
Y = 10

neighbors = lambda x, y : [(x2, y2) for x2 in range(x-1, x+2)
                               for y2 in range(y-1, y+2)
                               if (-1 < x <= X and
                                   -1 < y <= Y and
                                   (x != x2 or y != y2) and
                                   (0 <= x2 <= X) and
                                   (0 <= y2 <= Y))]

>>> print(neighbors(5, 5))
[(4, 4), (4, 5), (4, 6), (5, 4), (5, 6), (6, 4), (6, 5), (6, 6)]

Je ne sais pas si cela est considéré comme propre, mais ce one-liner vous donne à tous les voisins en itérant sur eux et en éliminant tous les cas extrêmes.

Answer 2

mb ...

from itertools import product, starmap

x, y = (8, 13)
cells = starmap(lambda a,b: (x+a, y+b), product((0,-1,+1), (0,-1,+1)))

// [(8, 12), (8, 14), (7, 13), (7, 12), (7, 14), (9, 13), (9, 12), (9, 14)]
print(list(cells)[1:])

Answer 3

En supposant que vous ayez une matrice carrée:

from itertools import product

size = 3

def neighbours(cell):
    for c in product(*(range(n-1, n+2) for n in cell)):
        if c != cell and all(0 <= n < size for n in c):
            yield c

Utilisation de itertools.product et grâce aux expression de rendement de Python et opérateur étoiles , la fonction est jolie sec , mais suffisamment lisible.

Étant donné une taille de matrice de 3, vous pouvez ensuite (si nécessaire) collecter les voisins dans une liste :

>>> list(neighbours((2,2)))
[(1, 1), (1, 2), (2, 1)]

Le fonctionnement de la fonction peut être visualisé comme suit:

Answer 4

for x_ in range(max(0,x-1),min(height,x+2)):
  for y_ in range(max(0,y-1),min(width,y+2)):
    if (x,y)==(x_,y_): continue
    # do stuff with the neighbours

>>> a=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> width=height=3
>>> x,y=0,2
>>> for x_ in range(max(0,x-1),min(height,x+2)):
...   for y_ in range(max(0,y-1),min(width,y+2)):
...     if (x,y)==(x_,y_): continue
...     print a[x_][y_]
... 
2
5
6

Answer 5

Il n'y a pas de moyen plus propre de faire cela. Si vous voulez vraiment, vous pouvez créer une fonction:

def top(matrix, x, y):
     try:
         return matrix[x][y - 1];
     except IndexError:
         return None

Answer 6

Si quelqu'un est intéressé par une autre façon de choisir des voisins directs (non diagonaux), la voici:

neighbors = [(x+a[0], y+a[1]) for a in 
                    [(-1,0), (1,0), (0,-1), (0,1)] 
                    if ( (0 <= x+a[0] < w) and (0 <= y+a[1] < h))]

Answer 7

Voici votre liste:

(x - 1, y - 1) (x, y - 1) (x + 1, y - 1)
(x - 1, y)     (x, y)     (x + 1, y)
(x - 1, y + 1) (x, y + 1) (x + 1, y + 1)

Les voisins horizontaux de (x, y) sont donc (x +/- 1, y).

Les voisins verticaux sont (x, y +/- 1).

Les voisins en diagonale sont (x +/- 1, y +/- 1).

Ces règles s'appliquent à une matrice infinie. Pour vous assurer que les voisins s’intègrent dans une matrice finie, si l’initiale (x, y) est au bord, appliquez simplement une restriction supplémentaire aux coordonnées des voisins - la taille de la matrice.

Answer 8

>>> import itertools
>>> def sl(lst, i, j):
    il, iu = max(0, i-1), min(len(lst)-1, i+1)
    jl, ju = max(0, j-1), min(len(lst[0])-1, j+1)
    return (il, iu), (jl, ju)

>>> lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> tup = 0, 2
>>> [lst[i][j] for i, j in itertools.product(*sl(lst, *tup)) if (i, j) != tup]
[2, 5, 6]

Je ne sais pas à quel point cela vous semble élégant, mais cela semble fonctionner sans codage en dur.

Answer 9

Ceci génère tous les index:

def neighboring( array ):
    nn,mm = len(array), len(array[0])
    offset = (0,-1,1) # 0 first so the current cell is the first in the gen
    indices = ( (i,j) for i in range(nn) for j in range(mm) )
    for i,j in indices:
        all_neigh =  ( (i+x,j+y) for x in offset for y in offset )
        valid = ( (i,j) for i,j in all_neigh if (0<=i<nn) and (0<=j<mm) ) # -1 is a valid index in normal lists, but not here so throw it out
        yield valid.next(), valid ## first is the current cell, next are the neightbors

for (x,y), neigh in neighboring( l ):
    print l[x][y], [l[x][y] for x,y in neigh]

Answer 10

peut-être cochez-vous une boîte de sudoku. Si la case est n x n et que la cellule actuelle est (x, y), commencez par vérifier:

startingRow = x / n * n;
startingCol = y/ n * n

Answer 11

Merci à @JS_is_bad pour un excellent aperçu des voisins. voici le code courant pour ce problème

    def findNeighbours(l,elem):
    #This try is for escaping from unbound error that happens 
    #when we try to iterate through indices that are not in array
    try:
        #Iterate through each item of multidimensional array using enumerate
        for row,i in enumerate(l):
            try:
                #Identifying the column index of the givem element
                column=i.index(elem)
            except ValueError:
                continue
            x,y=row,column

    #    hn=list(((x,y+1),(x,y-1))) #horizontal neighbours=(x,y+/-1)
    #    vn=list(((x+1,y),(x-1,y))) #vertical neighbours=(x+/-1,y)
    #    dn=list(((x+1,y+1),(x-1,y-1),(x+1,y-1),(x-1,y+1))) #diagonal neighbours=(x+/-1,y+/-1)
        #Creating a list with values that are actual neighbors for the extracted index of array
        neighbours=[(x,y+1),(x,y-1),(x+1,y),(x-1,y),(x+1,y+1),(x-1,y-1),(x+1,y-1),(x-1,y+1)]
        #Creating a universe of indices from given array
        index_list=[(i,j) for i in range(len(l)) for j in range(len(l[i]))]
        #Looping through index_list and nested loop for neighbours but filter for matched ones
        # and extract the value of respective index
        return_values=[l[index[0]][index[1]] for index in index_list for neighbour in neighbours if index==neighbour]
        return return_values,neighbours
    except UnboundLocalError:
        return []

Answer 12

Si lambdas vous intimide, vous êtes ici. Mais lambdas donne à votre code une apparence propre. @ johniek_comp a une solution très propre TBH

k,l=(2,3)
x = (0,-1,+1)
y = (0,-1,+1)
cell_u = ((k+a,l+b) for a in x for b in y)
print(list(cell_u))