Нахождение соседей в двумерном массиве

Question

Есть ли простой способ найти соседей (то есть восемь элементов вокруг элемента) элемента в двумерном массиве? Если не считать простого вычитания и добавления в индекс в различных комбинациях, например:

array[i-1][i]
array[i-1][i-1]
array[i][i-1]
array[i+1][i]

... и т. Д.

Answer 1

Поскольку в матрице вокруг элемента имеется только 8 элементов, вы можете использовать массив для хранения различных значений индекса. Например,

  int iarr[8] = {-1,-1,-1,0,0,+1,+1,+1};
  int jarr[8] = {-1,0,+1,-1,+1,-1,0,+1};
  for(int i = 0 ; i < 8 ; i++)
   {
    if(arr[x-iarr[i]][y-jarr[i]] == 1)
    {
     //statements
    }
   }  
  /* x and y are the position of elements from where you want to reach out its neighbour */

, так как оба массива содержат только 8 значений, пробел может не быть проблемой.

Answer 2

вот код для C #:

public Cell[,] MeetNeigbours(Cell[,] Grid)
    {
        for (int X = 0; X < Grid.GetLength(0); X++)
        {
            for (int Y = 0; Y < Grid.GetLength(1); Y++)
            {
                int NeighbourCount = 0;
                for (int i = -1; i < 2; i++)
                {
                    for (int j = -1; j < 2; j++)
                    {
                        if (CellExists(Grid, (X + i)), (Y + j) && (i != 0 && j != 0))
                        {
                            Grid[X, Y].Neighbours[NeighbourCount] = Grid[(X + i), (Y + j)];
                        }
                        if(!(i == 0 && j == 0))
                        {
                            NeighbourCount++;
                        }
                    }
                }
            }
        }
        return Grid;
    }

    public bool CellExists(Cell[,] Grid, int X, int Y)
    {
        bool returnValue = false;
        if (X >= 0 && Y >= 0)
        {
            if (X < Grid.GetLength(0) && Y < Grid.GetLength(1))
            {
                returnValue = true;
            }
        }

        return returnValue;
    }

с классом "Cell", похожим на это:

public class Cell
{
    public Cell()
    {
        Neighbours = new Cell[8];
    }

    /// <summary>
    /// 0 3 5
    /// 1 X 6
    /// 2 4 7
    /// </summary>
    public Cell[] Neighbours;
}

Answer 3

private ArrayList<Element> getNeighbors(Element p) {
    ArrayList<Element> n = new ArrayList<Element>();

    for (int dr = -1; dr <= +1; dr++) {
        for (int dc = -1; dc <= +1; dc++) {
            int r = p.row + dr;
            int c = p.col + dc;

            if ((r >= 0) && (r < ROWS) && (c >= 0) && (c < COLS)) {
                // skip p
                if ((dr != 0) || (dc != 0))
                    n.add(new Element(r, c));
            }               
        }
    }

    return n;
}

Answer 4

Rows and Cols - общее количество строк и столбцов

Определить структуру или класс CellIndex. Или вы можете просто вернуть фактические значения вместо индексов.

public List<CellIndex> GetNeighbors(int rowIndex, int colIndex)
{
var rowIndexes = (new int[] { rowIndex - 1, rowIndex, rowIndex + 1 }).Where(n => n >= 0 && n < Rows);

var colIndexes = (new int[] { colIndex - 1, colIndex, colIndex + 1 }).Where(n => n >= 0 && n < Cols);

return (from row in rowIndexes from col in colIndexes where row != rowIndex || col != colIndex select new CellIndex { Row = row, Col = col }).ToList();
}

Answer 5

Многое зависит от ваших данных. Например, если ваш 2D-массив представляет собой логическую матрицу, вы можете преобразовать строки в целые числа и использовать побитовые операции, чтобы найти нужные.

Для решения более общего назначения, я думаю, вы застряли в индексировании, как решение SebaGR.

Answer 6

JS образец:

    function findingNeighbors(myArray, i, j){
        return myArray.reduce(function(a, b, c){
            if(Math.max(0, i-1) <= c && c <= Math.min(i+1, myArray.length-1)){
                a = a.concat(
                    b.reduce(function(d, e, f){
                    if(f == j && c == i)
                        return d;
                    if(Math.max(0, j-1) <= f && f <= Math.min(j+1, myArray.length-1))
                        d.push(e)
                    return d;
                    },[])
                );
            }
            return a;
        },[]);
    }

Answer 7

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

def neighbours(m, i, j):
    return [m[x][y] for x in [i-1,i,i+1] for y in [j-1,j,j+1] if x in range(0,len(m)) and y in range(0,len(m[x])) and (x,y) != (i,j)]