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

Question

我试图在一个网格上找到所有对角有效的正方形，并将它们的值设置为1。对角线的定义就像象棋中的毕肖普的动作。在

我有一些东西，目前，但感觉很笨重。主要是因为我做了很多检查，以确保有问题的对角线平方在数组的边界内。在

网格是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)

或者更简单地说：

^{pr2}$

你唯一的另一个选择是预先计算出你的射程，这样你就可以把自己限制在范围之内。比如：

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