检查网格对角线的更简单方法是什么？

Question

我试图在网格上找到所有对角线有效的正方形并将其值设置为1。对角线的定义类似于Bishop在国际象棋中的移动。

目前，我有一些有效的方法，但是感觉很笨拙。 通常，由于我要进行大量检查以确保所讨论的对角线正方形在数组的范围内。

网格是8x8 ...

消除对角线

        for j in range (1,8):
            diagx1 = randx + j
            diagx2 = randx - j
            diagy1 = randy + j
            diagy2 = randy - j
            if diagx1 <= 7:
                if diagy1 <= 7:
                    setSquare(squares, diagx1, diagy1, 1)
                if diagy2 >= 0:
                    setSquare(squares, diagx1, diagy2, 1)
            if diagx2 >= 0:
                if diagy1 <= 7:
                    setSquare(squares, diagx2, diagy1, 1)
                if diagy2 >= 0:
                    setSquare(squares, diagx2, diagy2, 1)

Answer 1

基本上，您的方法要尽可能简单。 您必须进行边界检查，并且必须添加和减去偏移量。 您可以更改的是语法。

def in_bounds(coords: tuple) -> bool:
    """Ensures both x and y values are in range(8)"""
    return all( 0 <= coord <= 7 for coord in coords)

origin = (3, 3)
diagonals = []
for offset in range(-8, 8):    # -8, -7, -6, ..., 6, 7
    if offset == 0:  continue  # skip origin
    new_location = origin[0] + offset, origin[1] + offset
    if in_bounds(new_location):
        diagonals.append(in_bounds)

或更简单地说：

origin = (3, 3)
diagonals = [new_location for offset in range(-8, 8)
                          for new_location in [(origin[0] + offset,
                                                origin[1] + offset)]
                          if offset != 0 and in_bounds(new_location)]

您唯一的其他选择是预先计算您的范围，以保持自己的范围。 就像是：

origin = (5, 3)
# diagonals should be
# # x  y     offset
# # 2, 0     -3
# # 3, 1     -2
# # 4, 2     -1
# # 6, 4      1
# # 7, 5      2

other_origin = (1, 1)
# diagonals should be
# # x  y     offset
# # 0, 0     -1
# # 2, 2      1
# # ...       ...
# # 7, 7      6

get_range(origin:tuple) -> range:
    """returns the range of offsets to produce diagonals"""
    small, large = min(origin), max(origin)
    from = 0 - small
    to = 8 - large
    return range(from, to)

origin = (3, 3)
diagonals = [(origin[0] + offset, origin[1] + offset) 
             for offset in get_range(origin)]

请注意，建造可以找到自己的对角线的正方形可能值得您花些时间。

class Square(object):
    def __init__(self, x, y, parent=None):
        """A square in a coordinate plane"""
        self.x = x
        self.y = y
        self.parent = parent  # might be a larger container of squares?

    def __add__(self, other):
        if isinstance(other, tuple) and len(other) == 2:
            # hack the tuple into a square so we can add them easily
            other = Square(*tuple)
        try:
            return self.__class__((self.x + other.x, self.y + other.y))
        except AttributeError:
            raise TypeError("type Square can only add to other coordinate plane types")

    def __iter__(self):
        yield self.x
        yield self.y

    def __repr__(self):
        return "Square({}, {})".format(self.x, self.y)

    @staticmethod
    def find_diagonals(origin):
        diagonals = []
        for offset in range(1, 8):
            trial_vectors = [(offset, offset), (-offset, -offset),
                             (offset, -offset), (-offset, offset)]
            result_coords = [origin + vector for vector in trial_vectors]
            diagonals.extend(list(filter(
                origin._in_bounds, result_coords)))
        return diagonals

    @staticmethod
    def _in_bounds(coords):
        return all( 0 <= coord <= 7 for coord in coords)

origin = Square(3, 3)
diagonals = origin.find_diagonals(origin)
# [ Square(2, 2), Square(4, 4), Square(2, 4), Square(4, 2),
#   Square(1, 1), Square(5, 5), Square(1, 5), Square(5, 1),
#   Square(0, 0), Square(6, 6), Square(0, 6), Square(6, 0),
#                 Square(7, 7) ]