在矩阵中查找邻居？

Question

这是一个 7x7 矩阵：

 11  21  31  41  51  61  71
12  22  32  42  52  62  72
13  23  33  43  53  63  73
14  24  34  44  54  64  74
15  25  35  45  55  65  75
16  26  36  46  56  66  76
17  27  37  47  57  67  77

数字 11, 21, 33 … 是位置的值。如果给定半径，行数和列数，如何找到邻居？

例如，函数 neighbors(radius = 1, rowNumber = 3, columnNumber = 3) 应该返回一个矩阵：

 22  32  42
23  33  43
24  34  44

function neighbors(radius = 2, rowNumber = 3, columnNumber = 3) 应该返回一个矩阵：

 11  21  31  41  51
12  22  32  42  52
13  23  33  43  53
14  24  34  44  54
15  25  35  45  55

当邻居越界时，其值应为0。例如 function neighbors(radius = 2, rowNumber = 1, columnNumber = 1) 应返回一个矩阵

0   0   0   0   0
0   0   0   0   0
0   0   11  21  31
0   0   12  22  32
0   0   13  23  33

我已经解决这个问题 3 天了，但我仍然无法为它开发解决方案。

原文由 Cheer 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

这在其他语言中可能很难，但在 Python 中这很容易。这是一个可以执行您要求的功能的功能：

 def neighbors(radius, row_number, column_number):
     return [[a[i][j] if  i >= 0 and i < len(a) and j >= 0 and j < len(a[0]) else 0
                for j in range(column_number-1-radius, column_number+radius)]
                    for i in range(row_number-1-radius, row_number+radius)]

这是一个二维列表：

  a = [[ 11,  21,  31,  41,  51,  61,  71],
      [ 12,  22,  32,  42,  52,  62,  72],
      [ 13,  23,  33,  43,  53,  63,  73],
      [ 14,  24,  34,  44,  54,  64,  74],
      [ 15,  25,  35,  45,  55,  65,  75],
      [ 16,  26,  36,  46,  56,  66,  76],
      [ 17,  27,  37,  47,  57,  67,  77]]

请参阅 列表推导。

更新了解决方案中缺少的“和” - 请查看

原文由 Gnijuohz 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

此代码将二维数组（矩阵）作为参数并返回包含所有邻居的元素列表。

输入：

  arr = [['a', 'b', 'c'],
        ['d', 'e', 'f'],
        ['g', 'h', 'k']]

输出：

 [{'value': 'a', 'neighbors': ['b', 'd']}
 {'value': 'b', 'neighbors': ['c', 'e', 'a']}
 {'value': 'c', 'neighbors': ['f', 'b']}
 {'value': 'd', 'neighbors': ['a', 'e', 'g']}
 {'value': 'e', 'neighbors': ['b', 'f', 'h', 'd']}
 {'value': 'f', 'neighbors': ['c', 'k', 'e']}
 {'value': 'g', 'neighbors': ['d', 'h']}
 {'value': 'h', 'neighbors': ['e', 'k', 'g']}
 {'value': 'k', 'neighbors': ['f', 'h']}]

更多细节在这里 - > GitHub

 def find_neighbours(arr):

    neighbors = []

    for i in range(len(arr)):
        for j, value in enumerate(arr[i]):

            if i == 0 or i == len(arr) - 1 or j == 0 or j == len(arr[i]) - 1:
                # corners
                new_neighbors = []
                if i != 0:
                    new_neighbors.append(arr[i - 1][j])  # top neighbor
                if j != len(arr[i]) - 1:
                    new_neighbors.append(arr[i][j + 1])  # right neighbor
                if i != len(arr) - 1:
                    new_neighbors.append(arr[i + 1][j])  # bottom neighbor
                if j != 0:
                    new_neighbors.append(arr[i][j - 1])  # left neighbor

            else:
                # add neighbors
                new_neighbors = [
                    arr[i - 1][j],  # top neighbor
                    arr[i][j + 1],  # right neighbor
                    arr[i + 1][j],  # bottom neighbor
                    arr[i][j - 1]   # left neighbor
                ]

            neighbors.append({
                "value": value,
                "neighbors": new_neighbors})

    return neighbors

原文由 maxrudometkin 发布，翻译遵循 CC BY-SA 4.0 许可协议