Как сгенерировать все ходы коня?

Итак, спасибо Найлу Бирну, я придумал это:

from itertools import product
def knight_moves(position):
    x, y = position
    moves = list(product([x-1, x+1],[y-2, y+2])) + list(product([x-2,x+2],[y-1,y+1]))
    moves = [(x,y) for x,y in moves if x >= 0 and y >= 0 and x < 8 and y < 8]
    return moves

Почему бы не хранить относительные пары, в которых он может перемещаться? Итак, возьмите свою начальную точку и добавьте набор возможных ходов от нее, тогда вам просто понадобится проверка работоспособности, чтобы убедиться, что они все еще находятся в пределах границ или не находятся на другой части.

т.е. учитывая вашу (2, 4) начальную точку, варианты (-2,-1), (-2,+1), (-1,+2), (+2,+1) Таким образом, относительные позиции будут всегда быть одинаковым.

Не знаком с шахматами...

deltas = [(-2, -1), (-2, +1), (+2, -1), (+2, +1), (-1, -2), (-1, +2), (+1, -2), (+1, +2)]
def knight_moves(position):
    valid_position = lambda (x, y): x >= 0 and y >= 0 and ???
    return filter(valid_position, map(lambda (x, y): (position[0] + x, position[1] + y), deltas))

Вместо использования массива я бы посоветовал вам использовать битовые доски. Мало того, что ими очень легко манипулировать, они также уменьшат потребность в проверке границ. Имея всего 12 битовых досок, вы, вероятно, могли бы закодировать информацию, необходимую для всей игры.

https://www.chessprogramming.org/Bitboards

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

С таким представлением вы можете посмотреть по этой ссылке на шахматный движок, чтобы найти готовый алгоритм для реализации ходов конем.
http://www.mayothi.com/nagaskakichess6.html

Это может показаться излишним, если вы не знакомы с аналитической геометрией (или геометрией комплексных чисел), но я придумал очень элегантное математическое решение, когда реализовывал проверку движения фигур.

Ходы коня лежат на окружности, которую можно определить как (x-x_0)^2+(y-y_0)^2=5, где x_0 и y_0 — текущие координаты коня. Если вы переключитесь на полярные координаты, вы можете получить все возможные координаты с помощью этого простого кода:

import math
def knight_moves(x,y):
    new_positions=[]
    r=math.sqrt(5) #radius of the circle
    for phi in [math.atan(2),math.atan(1/2)]: #angles in radians
        for quadrant in range(4):
            angle=phi+quadrant*math.pi/2 # add 0, 90, 180, 270 degrees in radians      
            new_x=round(x+r*math.cos(angle))
            new_y=round(y+r*math.sin(angle))
            if max(new_x,new_y,7-new_x,7-new_y)<=7: #validation whether the move is in grid
                new_positions.append([new_x,new_y])
    return(new_positions)

def validate_knight_move(x,y,x_0,y_0):
    return((x-x_0)**2+(y-y_0)**2==5)

x_0=2
y_0=4

moves=knight_moves(x_0,y_0)
print(moves)

validation=[validate_knight_move(move[0],move[1],x_0,y_0) for move in moves]
print(validation)


[[3, 6], [0, 5], [1, 2], [4, 3], [4, 5], [1, 6], [0, 3], [3, 2]]
[True, True, True, True, True, True, True, True]

Здесь хорошо указать, что гораздо проще проверить позицию, чем построить ее напрямую. Поэтому было бы неплохо просто проверить, лежат ли все возможные ходы на круге или нет:

def knight_moves2(x,y):
    new_positions=[]
    for dx in [-2,-1,1,2]:
        for dy in [-2,-1,1,2]:
            if(validate_knight_move(x+dx,y+dy,x,y)): #is knight move?
                if max(x+dx,y+dy,7-(x+dx),7-(y+dy))<=7: #validation whether the move is in grid
                    new_positions.append([x+dx,y+dy])
    return(new_positions)

new_positions=knight_moves2(x_0,y_0)
print(new_positions)



[[0, 3], [0, 5], [1, 2], [1, 6], [3, 2], [3, 6], [4, 3], [4, 5]]

Вот простая реализация:

def knights_moves():
  a = []
  b = (1, 2)
  while 1:
    a.append(b)
    b = (-b[0], b[1])
    a.append(b)
    b = (b[1], b[0])
    if b in a:
      return a

[(1, 2), (-1, 2), (2, -1), (-2, -1), (-1, -2), (1, -2), (-2, 1), (2, 1)]

Оттуда вы можете просто добавить текущую позицию к каждому члену этого списка, а затем дважды проверить ее достоверность.

Завершая ответ xiaowl,

possible_places = [(-2, -1), (-2, +1), (+2, -1), (+2, +1), (-1, -2), (-1, +2), (+1, -2), (+1, +2)]
def knight_moves(cur_pos):
    onboard = lambda (x, y): x >= 0 and y >= 0 and x<8 and y<8
    eval_move = lambda(x,y): (cur_pos[0] + x, cur_pos[1] + y)
    return filter(onboard, map(eval_move, possible_places))

Для ходов конями:

def getAllValidMoves(x0, y0):
    deltas = [(-2, -1), (-2, +1), (+2, -1), (+2, +1), (-1, -2), (-1, +2), (+1, -2), (+1, +2)]
    validPositions = []
    for (x, y) in deltas:
        xCandidate = x0 + x
        yCandidate = y0 + y
        if 0 < xCandidate < 8 and 0 < yCandidate < 8:
            validPositions.append([xCandidate, yCandidate])

    return validPositions

print getAllValidMoves(3,3)

Я просто сохранил все возможные дельты, применил каждую из них к "исходной позиции" и сохранил те, что были внутри шахматной доски

from itertools import product

def moves():
    """ The available (relative) moves"""
    a = list(product( (1, -1), (2,-2)))
    return a + [tuple(reversed(m)) for m in a]

def neighbors(a,b):
    # true if x,y belongs in a chess table
    in_table = lambda (x, y): all((x < 8, y < 8, x >= 0, y >= 0))
    # returns the possible moving positions
    return filter(in_table, [(a+x, b+y) for x, y in moves()])

"соседи" - доступные позиции, на которые конь может перейти из a,b