создание списка допустимых ходов для компьютера в реверси (python)

Question

создание списка допустимых ходов для компьютера в реверси (python)

1

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

board - это список из 64 двух списков элементов, каждый из которых представляет собой плата реверса
игрок - это часть игрока, которая либо "X", либо "O" (определяется ранее в программе).
компьютер - это часть компьютера, которая является противоположной.

Первый шаг - собрать все пятна на доске, которые в настоящее время пустые (valid_list). Затем я пытаюсь пройти через каждое из этих пятен, чтобы увидеть, является ли какое-либо соседнее пятно частью игрока. Если это так, я хочу собрать все пятна, чтобы в одной строке (или столбце) была другая часть компьютера. Код, кажется, имеет смысл для меня, но это дает мне неожиданные результаты. Мне просто интересно, может ли кто-нибудь угадать, что вызывает странные результаты (список valid_list1).

def comp_move(board, player, computer):

    valid_list = []
    for xcoord in range(8):
        for ycoord in range(8):
            if board[xcoord][ycoord] == ' ':
                valid_list.append([xcoord, ycoord])

    copy = getCopy(board)
    num_list = [-1,0,1,-1,1,-1,0,1]
    num_list2 = [-1,-1,-1,0,0,1,1,1]

    for num in range(8):
        for i in range(len(valid_list)):

            xcoord_orig = valid_list[i][0]
            ycoord_orig = valid_list[i][1]
            xcoord1 = valid_list[i][0] + num_list[num]
            ycoord1 = valid_list[i][1] + num_list2[num]

            #test to see whether any of the surrounding spots are occupied by the player piece
            if 0 <= xcoord1 <= 7 and 0 <= ycoord1 <= 7:
                piece = board[xcoord1][ycoord1]

                if piece == player:

                    move_list = []
                    move_list1 = []
                    move_list2 = []
                    move_list3 = [] 
                    move_list4 = []
                    move_list5 = []
                    move_list6 = []
                    move_list7 = []
                    valid_list1 = []

                    #I changed the beginning of the range to 2 because we already know that the adjacent piece is the player piece

                    #test spots above
                    for i in range(2,8):
                        #iterate through spots above the computer spot.
                        #create a list of all the spots above the computer spot
                        xcoordT = xcoord_orig
                        ycoordT = ycoord_orig - i
                        if 0 <= ycoordT <= 7:
                            if board[xcoordT][ycoordT] == computer:
                                move_list.append([xcoordT, ycoordT])

                    if move_list:
                        valid_list1.append([xcoord_orig, ycoord_orig])


                    #Test spots below
                    for i in range(2,8):
                        xcoordB = xcoord_orig
                        ycoordB = ycoord_orig + i
                        if 0 <= ycoordB <= 7:
                            if board[xcoordB][ycoordB] == computer:
                                move_list1.append([xcoordB, ycoordB])

                    if move_list1:
                        valid_list1.append([xcoord_orig, ycoord_orig])

                    #Test spots to the right
                    for i in range(2,8):
                        xcoordR = xcoord_orig + i
                        ycoordR = ycoord_orig
                        if 0 <= xcoordR <= 7:                           
                            if board[xcoordR][ycoordR] == computer:
                                move_list2.append([xcoordR, ycoordR])

                    if move_list2:
                        valid_list1.append([xcoord_orig, ycoord_orig])

                    #Test spots to the left
                    for i in range(2,8):
                        xcoordL = xcoord_orig - i
                        ycoordL = ycoord_orig
                        if 0 <= xcoordL <= 7:
                            if board[xcoordL][ycoordL] == computer:
                                move_list3.append([xcoordL, ycoordL])

                    if move_list3:
                        valid_list1.append([xcoord_orig, ycoord_orig])


                    #Test upper-right diagonal spots  
                    for i in range(2,8):
                        xcoordTD = xcoord_orig + i
                        ycoordTD = ycoord_orig - i
                        if 0 <= xcoordTD <= 7 and 0 <= ycoordTD <= 7:
                            if board[xcoordTD][ycoordTD] == computer:
                                move_list4.append([xcoordTD, ycoordTD])

                    if move_list4:
                        valid_list1.append([xcoord_orig, ycoord_orig])


                    #Test lower-right diagonal spots
                    for i in range(2,8):
                        xcoordBD = xcoord_orig + i
                        ycoordBD = ycoord_orig + i
                        if 0 <= xcoordBD <= 7 and 0 <= ycoordBD <= 7:
                            if board[xcoordBD][ycoordBD] == computer:
                                move_list5.append([xcoordBD, ycoordBD])

                    if move_list5:
                        valid_list1.append([xcoord_orig, ycoord_orig])

                    #Test upper-left diagonal spots
                    for i in range(2,8):
                        xcoordTD1 = xcoord_orig - i
                        ycoordTD1 = ycoord_orig - i
                        if 0 <= xcoordTD1 <= 7 and 0 <= ycoordTD1 <= 7:
                            if board[xcoordTD1][ycoordTD1] == computer:
                                move_list6.append([xcoordTD1, ycoordTD1])

                    if move_list6:
                        valid_list1.append([xcoord_orig, ycoord_orig])

                    #Test lower-left diagal spots
                    for i in range(2,8):
                        xcoordBD1 = xcoord_orig - i
                        ycoordBD1 = ycoord_orig + i
                        if 0 <= xcoordBD1 <= 7 and 0 <= ycoordBD1 <= 7:
                            if board[xcoordBD1][ycoordBD1] == computer:
                                move_list7.append([xcoordBD1, ycoordBD1])

                    if move_list7:
                        valid_list1.append([xcoord_orig, ycoord_orig])

Bryce Siedschlaw 17 май 2011, в 21:31

Источник

2

"дает мне неожиданные результаты"? В самом деле? Вы должны объяснить это в некоторых деталях. Кроме того, очень и очень полезно помещать операторы print (или функции) в ваш код, чтобы отслеживать выполнение и показывать промежуточные результаты. Пожалуйста (1) определите, что неожиданно и (2) вставьте достаточное количество операторов печати, чтобы сузить проблему, и (3), основываясь на этом, опубликуйте наименьший кусок кода, который включает в себя реальную проблему.
S.Lott 17 май 2011, в 19:04
0

Какие результаты вы получаете, и что вы ожидаете? Предоставление некоторых примеров ввода и вывода поможет сузить суть проблемы. Кроме того, если это домашняя работа, вы должны пометить ее как таковую.
SteveMc 17 май 2011, в 19:06
0

Вы пытались использовать отладчик на нем? Код слишком длинный, чтобы ошибка была очевидна при беглом осмотре. Хитрость заключается в том, чтобы узнать, как понять, что пошло не так.
Winston Ewert 17 май 2011, в 19:09
1

Эта функция слишком длинная. Если разбить его на более мелкие шаги, вы можете проверить и проверить каждый маленький кусочек. Итак, из вашего описания «если какое-либо смежное пятно является частью игрока», это, естественно, должно переводиться в оператор if и одну функцию «опатогенный_спот_is_the_players_piece ». Надеюсь, это поможет.
Ishtar 17 май 2011, в 19:16
0

Почему на доске 64 двухэлементных списка? Какие 2 предмета?
phkahler 17 май 2011, в 19:30

Показать ещё 3 комментария

Теги:

python

3 ответа

Ещё вопросы

"дает мне неожиданные результаты"? В самом деле? Вы должны объяснить это в некоторых деталях. Кроме того, очень и очень полезно помещать операторы print (или функции) в ваш код, чтобы отслеживать выполнение и показывать промежуточные результаты. Пожалуйста (1) определите, что неожиданно и (2) вставьте достаточное количество операторов печати, чтобы сузить проблему, и (3), основываясь на этом, опубликуйте наименьший кусок кода, который включает в себя реальную проблему.
Какие результаты вы получаете, и что вы ожидаете? Предоставление некоторых примеров ввода и вывода поможет сузить суть проблемы. Кроме того, если это домашняя работа, вы должны пометить ее как таковую.
Вы пытались использовать отладчик на нем? Код слишком длинный, чтобы ошибка была очевидна при беглом осмотре. Хитрость заключается в том, чтобы узнать, как понять, что пошло не так.
Эта функция слишком длинная. Если разбить его на более мелкие шаги, вы можете проверить и проверить каждый маленький кусочек. Итак, из вашего описания «если какое-либо смежное пятно является частью игрока», это, естественно, должно переводиться в оператор if и одну функцию «опатогенный_спот_is_the_players_piece ». Надеюсь, это поможет.
Почему на доске 64 двухэлементных списка? Какие 2 предмета?

josias · Answer 1 · 2014-04-29T09-21-00.000Z

import numpy

def ai_player(board, scores, turn, valid_moves):
    """
    Input:
        board: numpy array of the disks for each player, e.g.
               [[0, 0, 0, 0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0, 0, 0, 0],
                [0, 0, 0, 1, 2, 0, 0, 0],
                [0, 0, 0, 2, 1, 0, 0, 0],
                [0, 0, 0, 0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0, 0, 0, 0]]

               - 0 empty locations
               - 1 player 1 disks
               - 2 player 2 disks
        scores: list of score values - [0, 0]
        turn: integer turn counter (starts from 1)
        valid_moves: numpy array of valid disk locations, represented in row
                     column combinations:
                     e.g [[3, 5],   # row 3 - col 5
                          [5, 3],   # row 5 - col 3
                          [4, 2],   # etc.
                          [3, 4]]

    Return:
        disk loction index --> a numpy array or a list
                           --> a valid row - col combination to place a disk
                           --> location must be empty
                           --> location must have flanks

        e.g. if valid_moves = [[3, 5],   # row 3 - col 5
                               [5, 3],   # row 5 - col 3
                               [4, 2],   # etc.
                               [3, 4]]
             and you want to place a disk at location row 4, col 2 then you
             need to return [4, 2]
"""

как вы программируете это знание, что у вас есть четыре ввода, или если вы хотите, как вы программируете в другом, чтобы получить лучшие valid_moves.

Bryce Siedschlaw · Answer 2 · 2011-05-17T18-14-00.000Z

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

Если вы замените свои операторы if move_listi: (где я - номер move_list) с valid_list1 += move_listi

Например:

# if move_list:  -- REMOVE THESE LINES
#     valid_list1.append([xcoord_orig, ycoord_orig])
valid_list1 += move_list
...

# if move_list1: -- REMOVE THESE LINES
#     valid_list1.append([xcoord_orig, ycoord_orig])
valid_list1 += move_list1
...

# Repeat for move_list2 - move_list7

Опять же, я не совсем уверен, что это то, о чем вы просили. Если это не так, дайте мне знать. valid_list1 будет содержать список всех мест, где часть компьютера находится в прямой видимости от оригинальной части компьютера.

phkahler · Answer 3 · 2011-05-17T17-19-00.000Z

Мне нравится представлять панель othello как 10x10 с рядом пустых квадратов вокруг края. Затем вместо того, чтобы использовать координаты x и y, вы представляете позицию как одно значение P = Y * 10 + x, где x и y идут от 0 до 9. Затем ваш num_list и numlist2 становятся единым списком с значениями направления dir = [- 11, -10, -9, -1,1,9,10,11], представляющие 8 направлений. Вы сканируете панель с позиции p, глядя на борт [p + dir [d] * distance]. Теперь у Python нет массивов, и просмотр N-го элемента списка может быть не самым эффективным способом, но все, что вы делаете в 2D, становится проще в 1D. Кстати, поскольку вы всегда сканируете смежные или диагональные квадраты, и вы смотрите только на то, что следующий квадрат занят куском противника или вашим собственным, цикл, естественно, заканчивается на границе пустых квадратов, и вы никогда не будете иметь чтобы проверить, убегаете ли вы с края доски. Это не решит вашу конкретную проблему с реализацией, но эта реализация будет намного проще отлаживать: -)