devbox
小惠珠哦
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：小惠珠哦 | 2024-08-18 10:40:56

赞

踩

三子棋python代码

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

8a552e3aa3a249f29da36578e001b2a1.png

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

  1. #作者：技术宅学长（CSDN、B站、抖音均为该ID）
  2. #电赛交流1群：586475593
  3. #电赛交流2群：878095340
  4. #电赛交流3群：873779462
  5. #电赛交流4群：208635284 
  6. #电赛交流5群：903429622 
  7.  
  8.  
  9. import random
  10.  
  11. # 定义棋盘大小和玩家符号
  12. ROWS, COLS = 3, 3
  13. PLAYER_X = 'X'#玩家
  14. PLAYER_O = 'O'#电脑AI
  15. EMPTY = ' '
  16.  
  17.  
  18. # 函数：打印棋盘
  19. def print_board(board):
  20.     for row in board:
  21.         print(" | ".join(row))
  22.         print("-" * 9)
  23.  
  24.  
  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]
  33.  
  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]
  39.  
  40.     # 检查是否平局
  41.     if all(board[i][j] != EMPTY for i in range(ROWS) for j in range(COLS)):
  42.         return "Draw"
  43.  
  44.     # 游戏未结束
  45.     return None
  46.  
  47.  
  48. # 函数：实现Minimax算法来找到最优的下棋位置
  49. def minimax(board, depth, is_maximizing):
  50.     result = check_game_over(board)
  51.  
  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  # 平局
  58.  
  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
  79.  
  80.  
  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)
  94.  
  95.     board[best_move[0]][best_move[1]] = PLAYER_O
  96.  
  97.  
  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
  102.  
  103.     print("欢迎使用三子棋程序!")
  104.     print_board(board)
  105.  
  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
  120.  
  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
  132.  
  133.  
  134. if __name__ == "__main__":
  135.     main()
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4.  
  5. #define ROWS 3
  6. #define COLS 3
  7. #define PLAYER_X 'X'
  8. #define PLAYER_O 'O'
  9. #define EMPTY ' '
  10.  
  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. }
  20.  
  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.     }
  32.  
  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.     }
  40.  
  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.     }
  57.  
  58.     return ' '; // 游戏未结束
  59. }
  60.  
  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.     }
  71.  
  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. }
  100.  
  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;
  106.  
  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.     }
  121.  
  122.     board[best_move_row][best_move_col] = PLAYER_O;
  123. }
  124.  
  125. // 主函数：控制游戏流程
  126. int main() {
  127.     char board[ROWS][COLS];
  128.     char current_player = PLAYER_X;//先落子玩家，PLAYER_X为玩家，PLAYER_O为电脑
  129.  
  130.     // 初始化棋盘
  131.     for (int i = 0; i < ROWS; ++i) {
  132.         for (int j = 0; j < COLS; ++j) {
  133.             board[i][j] = EMPTY;
  134.         }
  135.     }
  136.  
  137.     // 游戏循环
  138.     while (true) {
  139.         // 打印当前棋盘状态
  140.         printf("\nCurrent board:\n");
  141.         print_board(board);
  142.  
  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.         }
  153.  
  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.     }
  174.  
  175.     return 0;
  176. }

 

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/997173
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号