it-roy-ru.com

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

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

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

... И так далее.

20
Emil Svansø

(Псевдо-код)

row_limit = count(array);
if(row_limit > 0){
  column_limit = count(array[0]);
  for(x = max(0, i-1); x <= min(i+1, row_limit); x++){
    for(y = max(0, j-1); y <= min(j+1, column_limit); y++){
      if(x != i || y != j){
        print array[x][y];
      }
    }
  }
}

Конечно, это занимает почти столько же строк, сколько оригинальное жестко запрограммированное решение, но с этим вы можете расширить «соседство» настолько, насколько сможете (на 2-3 или более ячеек)

27
Seb

Я думаю, что Бен прав в своем подходе, хотя я мог бы изменить его, чтобы возможно улучшить местность.

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

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

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

Один из способов избежать проблем с проверкой границ - сделать размеры массива 2 больше, чем нужно. Итак, маленькая матрица, как это

3 1 4
1 5 9
2 6 5

на самом деле реализуется как 

0 0 0 0 0
0 3 1 4 0
0 1 5 9 0
0 2 6 5 0
0 0 0 0 0 

затем при суммировании я могу использовать от 1 до 3 в обоих измерениях, и приведенные выше ссылки на массивы гарантированно будут действительными и не окажут влияния на итоговую сумму . Я предполагаю c и нулевые индексы для примера

11
EvilTeach

Вот рабочий пример Javascript из оригинального псевдокода @seb:

function findingNeighbors(myArray, i, j) {
  var rowLimit = myArray.length-1;
  var columnLimit = myArray[0].length-1;

  for(var x = Math.max(0, i-1); x <= Math.min(i+1, rowLimit); x++) {
    for(var y = Math.max(0, j-1); y <= Math.min(j+1, columnLimit); y++) {
      if(x !== i || y !== j) {
        console.log(myArray[x][y]);
      }
    }
  }
}
5
Ryan Alberts

альтернатива @SebaGR, если ваш язык поддерживает это:

var deltas = { {x=-1, y=-1}, {x=0, y=-1}, {x=1, y=-1},
               {x=-1, y=0},               {x=1, y=0},
               {x=-1, y=1},  {x=0, y=1},  {x=1, y=1} };
foreach (var delta in deltas)
{
    if (x+delta.x < 0 || x + delta.x >= array.GetLength(0) ||
        y+delta.y < 0 || y + delta.y >= array.GetLength(1))
        continue;

    Console.WriteLine("{0}", array[x + delta.x, y + delta.y]);
}

Небольшое преимущество в удобочитаемости, возможной производительности, если вы можете статически распределять дельты.

5
FryGuy

array[i][j] имеет соседей

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

Вероятно, это самый быстрый/простой способ - просто перечислить всех возможных соседей. Удостоверьтесь, чтобы сделать индекс из связанной проверки все же.

Некоторые языки могут предложить быстрый способ сделать это, но я не знаю ни одного.

3
Ben S

Вот удобный метод в Python:

def neighbors(array,pos):
    n = []
     string = "array[pos.y+%s][pos.x+%s]"
    for i in range(-1,2):
        for j in range(-1,2):
            n.append(eval(string % (i,j)))
    return n

Предполагая, что pos - это некоторый объект 2D Point, а массив - это 2D массив.

2
AdrianC

Это реализация ответа @ Seb в python3 +, которая является краткой и использует генераторы для максимальной производительности:

def neighbours(pos, matrix):
    rows = len(matrix)
    cols = len(matrix[0]) if rows else 0
    for i in range(max(0, pos[0] - 1), min(rows, pos[0] + 2)):
        for j in range(max(0, pos[1] - 1), min(cols, pos[1] + 2)):
            if (i, j) != pos:
                yield matrix[i][j]
1
Salvatore Fiorenza

вот код для 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;
}
0
TDM

Подход, который я обычно использую, описан в нижней части этого блога: https://royvanrijn.com/blog/2019/01/longest-path/

Вместо того, чтобы жестко кодировать направления или иметь два вложенных цикла, я бы хотел использовать один целочисленный цикл для 8 «направлений» и использовать (i% 3) -1 и (i/3) -1; проверить блог с изображениями.

Он не такой глубокий и легко написан, не нужно много кода!

0
Roy van Rijn

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

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

0
Sarah Mei

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();
}
0
Krishna

Это было очень полезно для меня в недавнем проекте, так что вот реализация псевдокода @Seb в Swift. Это предполагает, что двумерный массив является квадратным:

func adjacentIndexPaths(to indexPath: IndexPath) -> [IndexPath] {
var neighboringSquareIndexes: [IndexPath] = []

// gridSquareCount is the size of the 2D array. For example, in an 8 x 8 [[Array]], gridSquareCount is 8
let maxIndex = gridSquareCount - 1
var neighborRowIndex = max(0, indexPath.section - 1)
var neighborColumnIndex = max(0, indexPath.row - 1)

while neighborRowIndex <= min(indexPath.section + 1, maxIndex) {
    while neighborColumnIndex <= min(indexPath.row + 1, maxIndex) {
        if neighborRowIndex != indexPath.section || neighborColumnIndex != indexPath.row {
            neighboringSquareIndexes.append(IndexPath(row: neighborColumnIndex, section: neighborRowIndex))
        }
        neighborColumnIndex += 1
    }
    neighborRowIndex += 1
    neighborColumnIndex = max(0, indexPath.row - 1)
}

return neighboringSquareIndexes }
0
ArielSD

Поскольку в матрице вокруг элемента имеется только 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 значений, пробел может не быть проблемой.

0
Shubh Tripathi
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;
}
0
Vijay M

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

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