三子棋、井字棋 -python版本代码-C语言版本代码

三子棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉棋、一条龙、井字棋等。游戏分为两边对战，两边依次在9宫格棋盘上摆放棋子，率先将自己的三个棋子走成一条线就视为胜利，而对方就算输了，但是三子棋在很多时间会出现和棋的局面。
  

废话不多说，直接上代码，好用请给个三连关注谢谢，我的B站是技术宅学长的个人空间-技术宅学长个人主页-哔哩哔哩视频 (bilibili.com)

1. #作者：技术宅学长（CSDN、B站、抖音均为该ID）
2. #电赛交流1群：586475593
3. #电赛交流2群：878095340
4. #电赛交流3群：873779462
5. #电赛交流4群：208635284
6. #电赛交流5群：903429622
9. import random
11. # 定义棋盘大小和玩家符号
12. ROWS, COLS = 3, 3
13. PLAYER_X = 'X'#玩家
14. PLAYER_O = 'O'#电脑AI
15. EMPTY = ' '
18. # 函数：打印棋盘
19. def print_board(board):
20.     for row in board:
21.         print(" | ".join(row))
22.         print("-" * 9)
25. # 函数：检查当前状态是否是结束状态（胜负或平局）
26. def check_game_over(board):
27.     # 检查行和列
28.     for i in range(ROWS):
29.         if board[i][0] == board[i][1] == board[i][2] != EMPTY:  # 检查行
30.             return board[i][0]
31.         if board[0][i] == board[1][i] == board[2][i] != EMPTY:  # 检查列
32.             return board[0][i]
34.     # 检查对角线
35.     if board[0][0] == board[1][1] == board[2][2] != EMPTY:  # 主对角线
36.         return board[0][0]
37.     if board[0][2] == board[1][1] == board[2][0] != EMPTY:  # 副对角线
38.         return board[0][2]
40.     # 检查是否平局
41.     if all(board[i][j] != EMPTY for i in range(ROWS) for j in range(COLS)):
42.         return "Draw"
44.     # 游戏未结束
45.     return None
48. # 函数：实现Minimax算法来找到最优的下棋位置
49. def minimax(board, depth, is_maximizing):
50.     result = check_game_over(board)
52.     if result == PLAYER_X:
53.         return -1  # X赢了
54.     elif result == PLAYER_O:
55.         return 1  # O赢了
56.     elif result == "Draw":
57.         return 0  # 平局
59.     if is_maximizing:
60.         best_score = -float('inf')
61.         for i in range(ROWS):
62.             for j in range(COLS):
63.                 if board[i][j] == EMPTY:
64.                     board[i][j] = PLAYER_O
65.                     score = minimax(board, depth + 1, False)
66.                     board[i][j] = EMPTY
67.                     best_score = max(score, best_score)
68.         return best_score
69.     else:
70.         best_score = float('inf')
71.         for i in range(ROWS):
72.             for j in range(COLS):
73.                 if board[i][j] == EMPTY:
74.                     board[i][j] = PLAYER_X
75.                     score = minimax(board, depth + 1, True)
76.                     board[i][j] = EMPTY
77.                     best_score = min(score, best_score)
78.         return best_score
81. # 函数：让电脑选择最优的下棋位置
82. def computer_move(board):
83.     best_move = None
84.     best_score = -float('inf')
85.     for i in range(ROWS):
86.         for j in range(COLS):
87.             if board[i][j] == EMPTY:
88.                 board[i][j] = PLAYER_O
89.                 score = minimax(board, 0, False)
90.                 board[i][j] = EMPTY
91.                 if score > best_score:
92.                     best_score = score
93.                     best_move = (i, j)
95.     board[best_move[0]][best_move[1]] = PLAYER_O
98. # 主函数：控制游戏流程
99. def main():
100.     board = [[EMPTY for _ in range(COLS)] for _ in range(ROWS)]
101.     current_player = PLAYER_O#设置先行玩家PLAYER_X为人，PLAYER_O为AI
103.     print("欢迎使用三子棋程序!")
104.     print_board(board)
106.     while True:
107.         if current_player == PLAYER_X:
108.             row = int(input("请输入你要下的行 (0, 1, 2) ："))
109.             col = int(input("请输入你要下的列 (0, 1, 2) ："))
110.             if board[row][col] == EMPTY:
111.                 board[row][col] = PLAYER_X
112.                 current_player = PLAYER_O
113.             else:
114.                 print("移动错误，当前位置有棋，请重下")
115.                 continue
116.         else:
117.             print("AI走棋")
118.             computer_move(board)
119.             current_player = PLAYER_X
121.         print_board(board)
122.         game_result = check_game_over(board)
123.         if game_result:
124.             if game_result == "Draw":
125.                 print("平局!")
126.             else:
127.                 if game_result == 'O':
128.                     print(f" AI获胜!")
129.                 else:
130.                     print(f" 恭喜你获胜!")
131.             break
134. if __name__ == "__main__":
135.     main()

复制代码

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <stdbool.h>
5. #define ROWS 3
6. #define COLS 3
7. #define PLAYER_X 'X'
8. #define PLAYER_O 'O'
9. #define EMPTY ' '
11. // 打印棋盘
12. void print_board(char board[ROWS][COLS]) {
13.     for (int i = 0; i < ROWS; ++i) {
14.         printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
15.         if (i != ROWS - 1) {
16.             printf("---|---|---\n");
17.         }
18.     }
19. }
21. // 检查游戏是否结束（胜负或平局）
22. char check_game_over(char board[ROWS][COLS]) {
23.     // 检查行和列
24.     for (int i = 0; i < ROWS; ++i) {
25.         if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != EMPTY) {
26.             return board[i][0];
27.         }
28.         if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != EMPTY) {
29.             return board[0][i];
30.         }
31.     }
33.     // 检查对角线
34.     if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != EMPTY) {
35.         return board[0][0];
36.     }
37.     if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != EMPTY) {
38.         return board[0][2];
39.     }
41.     // 检查是否平局
42.     bool is_draw = true;
43.     for (int i = 0; i < ROWS; ++i) {
44.         for (int j = 0; j < COLS; ++j) {
45.             if (board[i][j] == EMPTY) {
46.                 is_draw = false;
47.                 break;
48.             }
49.         }
50.         if (!is_draw) {
51.             break;
52.         }
53.     }
54.     if (is_draw) {
55.         return 'D'; // 平局
56.     }
58.     return ' '; // 游戏未结束
59. }
61. // Minimax算法实现
62. int minimax(char board[ROWS][COLS], int depth, bool is_maximizing) {
63.     char result = check_game_over(board);
64.     if (result == PLAYER_X) {
65.         return -1; // X赢了
66.     } else if (result == PLAYER_O) {
67.         return 1; // O赢了
68.     } else if (result == 'D') {
69.         return 0; // 平局
70.     }
72.     if (is_maximizing) {
73.         int best_score = -1000; // 初始最小值
74.         for (int i = 0; i < ROWS; ++i) {
75.             for (int j = 0; j < COLS; ++j) {
76.                 if (board[i][j] == EMPTY) {
77.                     board[i][j] = PLAYER_O;
78.                     int score = minimax(board, depth + 1, false);
79.                     board[i][j] = EMPTY;
80.                     best_score = score > best_score ? score : best_score;
81.                 }
82.             }
83.         }
84.         return best_score;
85.     } else {
86.         int best_score = 1000; // 初始最大值
87.         for (int i = 0; i < ROWS; ++i) {
88.             for (int j = 0; j < COLS; ++j) {
89.                 if (board[i][j] == EMPTY) {
90.                     board[i][j] = PLAYER_X;
91.                     int score = minimax(board, depth + 1, true);
92.                     board[i][j] = EMPTY;
93.                     best_score = score < best_score ? score : best_score;
94.                 }
95.             }
96.         }
97.         return best_score;
98.     }
99. }
101. // 计算并返回电脑的最优下棋位置
102. void computer_move(char board[ROWS][COLS]) {
103.     int best_score = -1000;
104.     int best_move_row = -1;
105.     int best_move_col = -1;
107.     for (int i = 0; i < ROWS; ++i) {
108.         for (int j = 0; j < COLS; ++j) {
109.             if (board[i][j] == EMPTY) {
110.                 board[i][j] = PLAYER_O;
111.                 int score = minimax(board, 0, false);
112.                 board[i][j] = EMPTY;
113.                 if (score > best_score) {
114.                     best_score = score;
115.                     best_move_row = i;
116.                     best_move_col = j;
117.                 }
118.             }
119.         }
120.     }
122.     board[best_move_row][best_move_col] = PLAYER_O;
123. }
125. // 主函数：控制游戏流程
126. int main() {
127.     char board[ROWS][COLS];
128.     char current_player = PLAYER_X;//先落子玩家，PLAYER_X为玩家，PLAYER_O为电脑
130.     // 初始化棋盘
131.     for (int i = 0; i < ROWS; ++i) {
132.         for (int j = 0; j < COLS; ++j) {
133.             board[i][j] = EMPTY;
134.         }
135.     }
137.     // 游戏循环
138.     while (true) {
139.         // 打印当前棋盘状态
140.         printf("\nCurrent board:\n");
141.         print_board(board);
143.         // 检查游戏是否结束
144.         char game_result = check_game_over(board);
145.         if (game_result != ' ') {
146.             if (game_result == 'D') {
147.                 printf("It's a draw!\n");
148.             } else {
149.                 printf("%c wins!\n", game_result);
150.             }
151.             break;
152.         }
154.         // 根据当前玩家决定下棋
155.         if (current_player == PLAYER_X) {
156.             int row, col;
157.             printf("\nEnter row number (0, 1, 2) for your move: ");
158.             scanf("%d", &row);
159.             printf("Enter column number (0, 1, 2) for your move: ");
160.             scanf("%d", &col);
161.             if (board[row][col] == EMPTY) {
162.                 board[row][col] = PLAYER_X;
163.                 current_player = PLAYER_O;
164.             } else {
165.                 printf("Invalid move! That position is already taken. Try again.\n");
166.                 continue;
167.             }
168.         } else {
169.             printf("\nComputer's turn:\n");
170.             computer_move(board);
171.             current_player = PLAYER_X;
172.         }
173.     }
175.     return 0;
176. }

复制代码

 
 
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。