Ai thắng tic tac toe Python?

Trong bài viết này, chúng tôi đã trình bày thuật toán kiểm tra thắng thua cho một cấu hình Tic Tac Toe cho trước.

GHI CHÚ. thuật toán này giả định rằng dữ liệu trò chơi được truyền ở định dạng sau

data = [
    # the lists are rows while the individual dictionaries are tiles [the move made and the tile number]
    [
        {'move': 'x', 'number': 1},
        {'move': 'o', 'number': 2},
        {'move': 'x', 'number': 3}
    ],
    [
        {'move': 'x', 'number': 4},
        {'move': 'o', 'number': 5},
        {'move': 'o', 'number': 6}
    ],
    [
        {'move': 'x', 'number': 7},
        {'move': 'x', 'number': 8},
        {'move': 'x', 'number': 9}
    ]
]

Tại sao lại là định dạng trên? .

From the above image, we can see that there is one big block which is like the container, we have rows [the blocks that run horizontally from left to right] and columns [blocks that run vertically from up to down] and each row has 3 smaller blocks or tiles.
Trong đoạn mã trên, chúng ta có cùng cấu trúc.

1. Chúng tôi có một danh sách [được đặt tên là dữ liệu] giống như vùng chứa
2. 3 danh sách khác bên trong "danh sách vùng chứa" đại diện cho 3 hàng
3. Bên trong mỗi hàng, chúng tôi có một ô, được biểu thị dưới dạng từ điển python. Tại sao?

Bây giờ, hãy nói về việc triển khai thuật toán
Trong ví dụ này, chúng tôi sẽ lấy X làm nước đi "chiến thắng" [để làm cho mọi thứ dễ dàng hơn].

BƯỚC 1. Điều gì được coi là một chiến thắng?

1. nếu cùng một nước đi kéo dài [theo chiều ngang] trên một hàng, nghĩa là,

   # assuming we are checking for the move x
   data = [
           [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
       ]
   
   def row_win[row]:
       for tile in row:
           if tile['move'] != 'x':
               return False
   

   4 hoặc

   # assuming we are checking for the move x
   data = [
           [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
       ]
   
   def row_win[row]:
       for tile in row:
           if tile['move'] != 'x':
               return False
   

   5 hoặc

   # assuming we are checking for the move x
   data = [
           [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
       ]
   
   def row_win[row]:
       for tile in row:
           if tile['move'] != 'x':
               return False
   

   6 đều là nước đi giống nhau. đây là cách đơn giản nhất để thực hiện
2. nếu cùng một nước đi kéo dài theo chiều dọc của một cột, nghĩa là

   # assuming we are checking for the move x
   data = [
           [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
       ]
   
   def row_win[row]:
       for tile in row:
           if tile['move'] != 'x':
               return False
   

   7 hoặc

   # assuming we are checking for the move x
   data = [
           [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
       ]
   
   def row_win[row]:
       for tile in row:
           if tile['move'] != 'x':
               return False
   

   8 hoặc

   # assuming we are checking for the move x
   data = [
           [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
       ]
   
   def row_win[row]:
       for tile in row:
           if tile['move'] != 'x':
               return False
   

   9 đều cùng một nước đi
3. nếu cùng một nước đi kéo dài theo đường chéo trong trò chơi, đó là

   for row in game:
       if row_win[row] != False:
           return 'x wins!'
   

   0 hoặc

   for row in game:
       if row_win[row] != False:
           return 'x wins!'
   

   1. GHI CHÚ. Sẽ luôn chỉ có 2 đường chéo

BƯỚC 2. Cách tính win cho bước 1. 1. di chuyển tương tự kéo dài trên [theo chiều ngang] trên một hàng

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

Tạm thời chỉ thế thôi, đây cũng sẽ là cơ sở để tính toán các chiến thắng khác [hãy tiếp tục đọc và bạn sẽ hiểu tại sao].
Ở đây chúng ta có một hàm tên là

for row in game:
    if row_win[row] != False:
        return 'x wins!'

2 để kiểm tra xem liệu có bất kỳ nước đi nào khác ngoài 'x' hay không và nếu có thì điều đó có nghĩa là điều kiện để giành chiến thắng đã bị vi phạm do đó không có chiến thắng nào cho hàng .
Chúng tôi sử dụng điều này để kiểm tra tất cả các hàng và nếu bất kỳ giá trị nào khác ngoài

for row in game:
    if row_win[row] != False:
        return 'x wins!'

3 được trả về thì sẽ thắng.
Để kiểm tra chiến thắng cho tất cả các hàng

for row in game:
    if row_win[row] != False:
        return 'x wins!'

BƯỚC 3. Cách tính win cho 1. 2. di chuyển tương tự kéo dài theo chiều dọc dọc theo một cột

Bây giờ, đây là nơi mọi thứ trở nên thú vị và bạn sẽ thấy lý do tại sao tôi chọn cấu trúc dữ liệu theo cách tôi đã làm.
Nếu bạn nhìn lại hình ảnh mà tôi đã đánh số ô. Tôi sẽ giúp bạn dễ dàng

Bạn có thể thấy rõ rằng hàng đầu tiên chứa các số 1, 2 và 3 hoặc dưới dạng danh sách

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

4 tương tự với các hàng khác.
Nhưng một lần nữa, hãy nhìn vào cột, chỉ là cột đầu tiên. Nó chứa các ô 1, 4 và 7 hoặc dưới dạng danh sách

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

7. Vì vậy, những gì chúng ta phải làm là tìm cách nhóm các thành phần đó lại với nhau và tạo thành cấu trúc giống như dữ liệu của chúng ta, nhưng trông như thế này

Hãy xem xét nó từ góc độ này.

for row in game:
    if row_win[row] != False:
        return 'x wins!'

6
Bây giờ tất cả đã được xếp thành hàng, tôi nghĩ nó rõ ràng hơn. Thật may mắn cho chúng tôi, python cung cấp một chức năng tích hợp có tên là

for row in game:
    if row_win[row] != False:
        return 'x wins!'

7 giúp chúng tôi làm điều đó khá nhiều. cứ thế.

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

7

Thế thôi. hàm

for row in game:
    if row_win[row] != False:
        return 'x wins!'

7 trả về một đối tượng zip mang lại từng giá trị khi bạn lặp lại nó. Chúng tôi chuyển đổi nó thành một danh sách bằng cách sử dụng

for row in game:
    if row_win[row] != False:
        return 'x wins!'

9
Bây giờ, để tính toán cho tất cả các hàng, chúng tôi sử dụng hàm tương tự như trong BƯỚC 2

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

0

BƯỚC 4. Cách tính win 3. di chuyển tương tự kéo dài theo đường chéo trong trò chơi

Một lần nữa, chúng ta cần tìm cách lọc ra các giá trị tạo thành các đường chéo của trò chơi. Đó là

for row in game:
    if row_win[row] != False:
        return 'x wins!'

0 và

for row in game:
    if row_win[row] != False:
        return 'x wins!'

1.
Không giống như lần trước, chúng tôi không có chức năng tích hợp sẵn nhưng rất dễ triển khai một chức năng có thể làm điều đó cho chúng tôi.
Hãy nghĩ về những gì chúng ta muốn làm trước, sau đó chúng ta xem chúng ta sẽ làm điều đó như thế nào.

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

3

Chúng tôi muốn lấy phần tử thứ nhất từ ​​danh sách thứ nhất, phần tử thứ 2 từ danh sách thứ 2 và phần tử thứ 3 từ danh sách thứ 3. Bây giờ đó là những gì tôi muốn gọi là một mô hình rõ ràng.
chúng ta phải lấy

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

72 này
nhớ. Lập chỉ mục mảng bắt đầu từ 0.

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

5

Hãy chia nhỏ mã

Đầu ra của mã này sẽ là một danh sách, tức là một cạnh chéo. chúng tôi tạo một danh sách trống

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

73 trong đó chúng tôi sẽ lưu trữ các giá trị của mình [ô xếp].
sau đó, chúng tôi duyệt qua các hàng và đối với mỗi hàng, chúng tôi nhận được ô xếp trước một bước so với hàng trước đó.

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

74 sẽ trả về 0 đến 2, tổng cộng là 3.
sau đó, chúng tôi lặp qua từng ô và

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

75 đến danh sách đầu ra có giá trị của

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

76

Chúng tôi đã khởi tạo biến

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

77 với giá trị 0. Chúng tôi chỉ tăng nó lên một sau khi tất cả các mục/ô trong một hàng đã được lặp lại và mục mong muốn đã được thêm vào danh sách đầu ra

Nhưng vấn đề nằm ở đây, ở vòng lặp thứ hai, tức là vòng lặp bên trong. Nó chạy nhiều lần bằng số lượng vật phẩm/ô xếp chúng tôi có trong hàng của mình, tức là 3. Và mỗi lần, nó lưu trữ một giá trị, đó là,

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

78 đối với hàng đầu tiên. Điều này là do biến đếm không được tăng lên cho đến khi hoàn thành vòng lặp bên trong

Vì vậy, chúng tôi kết thúc với các bản sao. Một danh sách đầu ra trông như thế này

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

2

Nếu danh sách của chúng tôi đơn giản như danh sách trên, chỉ với các con số, chúng tôi có thể làm một cái gì đó như thế này

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

3

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

79 là một cấu trúc dữ liệu không cho phép các đối tượng trùng lặp. Trong python, bạn có thể tạo một bộ mới bằng cách sử dụng

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

00

Nhưng chỉ có một điều, bạn không thể làm điều này với một danh sách từ điển. Tại sao?

Điều đó nghĩa là gì?

Dù sao đi nữa, điều quan trọng là làm cho đối tượng

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

01 có thể băm được là sử dụng phương thức

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

02. Nó trả về một tuple của đối tượng.
A

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

03 là một đối tượng bất biến, nghĩa là giá trị của nó không bao giờ thay đổi.

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

9

Nếu tôi phải giải thích khái niệm băm và tính bất biến, thì điều này sẽ trở nên khá lớn, vì vậy tôi đã tiếp tục và tìm ra một lời giải thích thực sự hay

Nhưng hãy nhớ rằng, chúng ta có hai đường chéo, vậy làm cách nào để lấy đường chéo còn lại, tôi sẽ đi thẳng vào vấn đề, chúng ta chỉ cần đảo ngược hoặc đảo ngược các ô

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

0

Với các ô hoặc cấu trúc bị đảo ngược, chúng ta có thể dễ dàng lấy đường chéo khác bằng cách sử dụng cùng một phương pháp mà chúng ta đã sử dụng để lấy đường chéo đầu tiên. Nhờ có python, chúng tôi có một tích hợp khác có tên là

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

04 trả về một

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

05. Và do đó chúng ta có thể làm một cái gì đó như thế này

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

1

Bây giờ chúng ta có mã để lấy danh sách dọc và danh sách ngang và để tính toán chiến thắng, chúng ta chỉ cần sử dụng mã từ BƯỚC 1
Hãy đóng gói chúng thành các hàm và chấp nhận .

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

2

Hãy thử nó ra. Tôi đã tạo ra một cách đơn giản để nhận thông tin đầu vào [chúng ta sẽ coi đó là trò chơi dành cho việc này]

# assuming we are checking for the move x
data = [
        [{'move': 'x', 'number': 1}, {'move': 'x', 'number': 2}, {'move': 'o', 'number': 3}], [{'move': 'o', 'number': 4}, {'move': 'o', 'number': 5}, {'move': 'x', 'number': 6}], [{'move': 'x', 'number': 7}, {'move': 'x', 'number': 8}, {'move': 'x', 'number': 9}]
    ]

def row_win[row]:
    for tile in row:
        if tile['move'] != 'x':
            return False

3

Điều này sẽ lấy 9 đầu vào, tức là cho 9 ô và sẽ định dạng dữ liệu theo cách phù hợp với cấu trúc mà chúng ta muốn

Đây là một đầu ra mẫu

Bây giờ một số người hoặc tất cả mọi người có thể xem và nói, đợi một chút, tất cả các ô được sử dụng hoặc cả hai đều thắng cho x và o. Và đó là lý do tại sao thuật toán này nên được sử dụng để tính toán chiến thắng sau khi bất kỳ người chơi nào thực hiện nước đi. Đó là một thử thách khác dành cho bạn, hãy thực hiện nó

Ai thắng trong tic

làm thế nào để làm cho tic

Thuật toán nào được sử dụng cho tic

logic đằng sau tic là gì