BingAI : encore plus puissant que ChatGPT ?

import numpy as np

class TicTacToe:
    def __init__(self):
        self.board = np.zeros((3,3))
        self.player = 1

    def draw_board(self):
        print("\n")
        print(" ", self.board[0, 0], " | ", self.board[0, 1], " | ", self.board[0, 2], " ")
        print("----|-----|----")
        print(" ", self.board[1, 0], " | ", self.board[1, 1], " | ", self.board[1, 2], " ")
        print("----|-----|----")
        print(" ", self.board[2, 0], " | ", self.board[2, 1], " | ", self.board[2, 2], " ")
        print("\n")

    def player_can_play(self, x, y):
        if self.board[x, y] == 0:
            return True
        return False

    def play_move(self, x, y):
        self.board[x, y] = self.player
        self.player = 3 - self.player
        return

    def player_wins(self, player):
        for i in range(3):
            if np.all(self.board[i,:] == player) or np.all(self.board[:,i] == player):
                return True
        if np.all(np.diag(self.board) == player) or np.all(np.diag(np.fliplr(self.board)) == player):
            return True
        return False

    def player_loses(self, player):
        opponent = 3 - player
        return self.player_wins(opponent)

    def is_over(self):
        return np.all(self.board != 0) or self.player_wins(1) or self.player_wins(2)

    def score(self, depth):
        if self.player_wins(1):
            return 10 - depth
        elif self.player_wins(2):
            return depth - 10
        else:
            return 0

    def minimax(self, depth, alpha, beta, maximizing_player):
        if depth == 0 or self.is_over():
            return self.score(depth)

        if maximizing_player:
            max_score = -1000
            for i in range(3):
                for j in range(3):
                    if self.player_can_play(i, j):
                        self.play_move(i, j)
                        score = self.minimax(depth-1, alpha, beta, False)
                        self.play_move(i, j)
                        max_score = max(max_score, score)
                        alpha = max(alpha, score)
                        if beta <= alpha:
                            break
                if beta <= alpha:
                    break
            return max_score
        else:
            min_score = 1000
            for i in range(3):
                for j in range(3):
                    if self.player_can_play(i, j):
                        self.play_move(i, j)
                        score = self.minimax(depth-1, alpha, beta, True)
                        self.play_move(i, j)
                        min_score = min(min_score, score)
                        beta = min(beta, score)
                        if beta <= alpha:
                            break
                if beta <= alpha:
                    break
            return min_score

    def best_move(self):
        best_score = -1000
        best_move = (0, 0)
        for i in range(3):
            for j in range(3):
                if self.player_can_play(i, j):
                    self.play_move(i, j)
                    score = self.minimax(9, -1000, 1000, False)
                    self.play_move(i, j)
                    if score > best_score:
                        best_score = score
                        best_move = (i, j)
        return best_move

if __name__ == "__main__":
    t = TicTacToe()
    t.draw_board()
    while not t.is_over():
        if t.player == 1:
            x, y = map(int, input("Enter your move (row column): ").split())
            while not t.player_can_play(x, y):
                x, y = map(int, input("Enter your move (row column): ").split())
            t.play_move(x, y)
        else:
            x, y = t.best_move()
            t.play_move(x, y)
        t.draw_board()

    if t.player_wins(1):
        print("You win!")
    elif t.player_wins(2):
        print("You lose!")
    else:
        print("It's a draw!")

import sys

board = ["_"] * 9

def print_board():
    row1 = "| {} | {} | {} |".format(board[0], board[1], board[2])
    row2 = "| {} | {} | {} |".format(board[3], board[4], board[5])
    row3 = "| {} | {} | {} |".format(board[6], board[7], board[8])

    print()
    print(row1)
    print(row2)
    print(row3)
    print()

def winning_combination(board, icon):
    # return True if there is a winning combination on the board
    win_comb = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [0, 3, 6], [1, 4, 7], [2, 5, 8], [0, 4, 8], [2, 4, 6]]
    for combination in win_comb:
        if all(board[i] == icon for i in combination):
            return True
    return False

def return_score(board):
    # return the score for the current board state
    if winning_combination(board, "X"):
        return 1
    elif winning_combination(board, "O"):
        return -1
    else:
        return 0

def game_over(board):
    # return True if the game is over
    return winning_combination(board, "X") or winning_combination(board, "O") or "_" not in board

def minimax(board, number, alpha, beta):
    available_positions = [i for i, x in enumerate(board) if x == "_"]
    if game_over(board):
        return return_score(board), None
    if number == 1:
        best = -sys.maxsize
        move = None
        for i in available_positions:
            board[i] = "X"
            score, m = minimax(board, 2, alpha, beta)
            board[i] = "_"
            if score > best:
                best = score
                move = i
            alpha = max(alpha, best)
            if alpha >= beta:
                break
        return best, move
    else:
        best = sys.maxsize
        move = None
        for i in available_positions:
            board[i] = "O"
            score, m = minimax(board, 1, alpha, beta)
            board[i] = "_"
            if score < best:
                best = score
                move = i
            beta = min(beta, best)
            if alpha >= beta:
                break
        return best, move

def player_move(icon):
    if icon == "X":
        number = 1
    elif icon == "O":
        number = 2

    if number == 1:
        print("Your turn player {}".format(number))
        choice = int(input("Enter your move (1-9): ").strip())
        if board[choice - 1] == "_":
            board[choice - 1] = icon
        else:
            print()
            print("That space is already taken!")
    else:
        print("AI's turn")
        result, move = minimax(board, number, -sys.maxsize, sys.maxsize)
        if move == None:
            print("No moves left!")
        else:
            board[move] = icon
            
def is_victory(icon):
    if (board[0] == icon and board[1] == icon and board[2] == icon) or \
       (board[3] == icon and board[4] == icon and board[5] == icon) or \
       (board[6] == icon and board[7] == icon and board[8] == icon) or \
       (board[0] == icon and board[3] == icon and board[6] == icon) or \
       (board[1] == icon and board[4] == icon and board[7] == icon) or \
       (board[2] == icon and board[5] == icon and board[8] == icon) or \
       (board[0] == icon and board[4] == icon and board[8] == icon) or \
       (board[2] == icon and board[4] == icon and board[6] == icon):
        return False

def is_draw():
    if "_" not in board:
        return True
    else:
        return False

while True:
    print_board()
    player_move("X")
    print_board()
    if is_victory("X"):
        print("X wins! Congratulations!")
        break
    elif is_draw():
        print("It's a draw!")
        break
    player_move("O")
    if is_victory("O"):
        print_board()
        print("O wins! Congratulations!")
        break
    elif is_draw():
        print("It's a draw!")
        break

# Code généré par Sydney, le mode chat de Bing Search
# Ce code n'a pas été testé ni exécuté, il peut contenir des erreurs

# Importer la bibliothèque math
import math

# Définir la taille du plateau
N = 3

# Définir les symboles des joueurs
X = "X"
O = "O"
V = " "

# Créer le plateau de jeu
plateau = [[V] * N for _ in range(N)]

# Afficher le plateau de jeu
def afficher_plateau():
    for i in range(N):
        print("|", end="")
        for j in range(N):
            print(plateau[i][j], end="|")
        print()
    print()

# Vérifier si le plateau est plein
def plateau_plein():
    for i in range(N):
        for j in range(N):
            if plateau[i][j] == V:
                return False
    return True

# Vérifier si un joueur a gagné
def gagnant(joueur):
    # Vérifier les lignes
    for i in range(N):
        if all(plateau[i][j] == joueur for j in range(N)):
            return True
    # Vérifier les colonnes
    for j in range(N):
        if all(plateau[i][j] == joueur for i in range(N)):
            return True
    # Vérifier les diagonales
    if all(plateau[i][i] == joueur for i in range(N)):
        return True
    if all(plateau[i][N - 1 - i] == joueur for i in range(N)):
        return True
    # Sinon, pas de gagnant
    return False

# Évaluer la valeur du plateau pour un joueur
def evaluer(joueur):
    if gagnant(joueur):
        return 1
    if gagnant(adversaire(joueur)):
        return -1
    return 0

# Obtenir la liste des coups possibles
def coups_possibles():
    coups = []
    for i in range(N):
        for j in range(N):
            if plateau[i][j] == V:
                coups.append((i, j))
    return coups

# Obtenir l'adversaire d'un joueur
def adversaire(joueur):
    if joueur == X:
        return O
    return X

# Appliquer un coup sur le plateau
def appliquer_coup(coup, joueur):
    i, j = coup
    plateau[i][j] = joueur

# Annuler un coup sur le plateau
def annuler_coup(coup):
    i, j = coup
    plateau[i][j] = V

# Implémenter l'algorithme d'élagage alpha-bêta
def alpha_beta(joueur, alpha, beta):
    # Si le plateau est terminal, retourner la valeur et le coup nul
    if plateau_plein() or gagnant(X) or gagnant(O):
        return evaluer(joueur), None
    # Sinon, initialiser le meilleur coup et la meilleure valeur
    meilleur_coup = None
    if joueur == X:
        # Si le joueur est X, maximiser la valeur
        meilleure_valeur = -math.inf
        # Pour chaque coup possible
        for coup in coups_possibles():
            # Appliquer le coup
            appliquer_coup(coup, joueur)
            # Appeler récursivement alpha_beta sur l'adversaire
            valeur, _ = alpha_beta(adversaire(joueur), alpha, beta)
            # Annuler le coup
            annuler_coup(coup)
            # Si la valeur est meilleure que la meilleure valeur
            if valeur > meilleure_valeur:
                # Mettre à jour la meilleure valeur et le meilleur coup
                meilleure_valeur = valeur
                meilleur_coup = coup
            # Mettre à jour alpha
            alpha = max(alpha, meilleure_valeur)
            # Si alpha >= beta, élaguer
            if alpha >= beta:
                break
    else:
        # Si le joueur est O, minimiser la valeur
        meilleure_valeur = math.inf
        # Pour chaque coup possible
        for coup in coups_possibles():
            # Appliquer le coup
            appliquer_coup(coup, joueur)
            # Appeler récursivement alpha_beta sur l'adversaire
            valeur, _ = alpha_beta(adversaire(joueur), alpha, beta)
            # Annuler le coup
            annuler_coup(coup)
            # Si la valeur est meilleure que la meilleure valeur
            if valeur < meilleure_valeur:
                # Mettre à jour la meilleure valeur et le meilleur coup
                meilleure_valeur = valeur
                meilleur_coup = coup
            # Mettre à jour beta
            beta = min(beta, meilleure_valeur)
            # Si alpha >= beta, élaguer
            if alpha >= beta:
                break
    # Retourner la meilleure valeur et le meilleur coup
    return meilleure_valeur, meilleur_coup

# Jouer un tour
def jouer(joueur):
    # Si le joueur est X, demander le coup au joueur humain
    if joueur == X:
        print("À vous de jouer, X !")
        # Obtenir la liste des coups possibles
        coups = coups_possibles()
        # Afficher les coups possibles
        print("Coups possibles : ", coups)
        # Demander le coup au joueur
        coup = None
        while coup not in coups:
            try:
                i = int(input("Ligne : "))
                j = int(input("Colonne : "))
                coup = (i, j)
            except ValueError:
                print("Entrée invalide, veuillez réessayer.")
        # Appliquer le coup
        appliquer_coup(coup, joueur)
    # Sinon, si le joueur est O, calculer le coup avec l'IA
    else:
        print("À moi de jouer, O !")
        # Appeler l'algorithme alpha_beta
        _, coup = alpha_beta(joueur, -math.inf, math.inf)
        # Appliquer le coup
        appliquer_coup(coup, joueur)
        # Afficher le coup
        print("J'ai joué : ", coup)

# Commencer le jeu
def commencer():
    # Afficher le plateau initial
    afficher_plateau()
    # Initialiser le joueur courant
    joueur = X
    # Tant que le jeu n'est pas terminé
    while not plateau_plein() and not gagnant(X) and not gagnant(O):
        # Jouer un tour
        jouer(joueur)
        # Afficher le plateau
        afficher_plateau()
        # Changer de joueur
        joueur = adversaire(joueur)
    # Afficher le résultat
    if gagnant(X):
        print("X a gagné !")
    elif gagnant(O):
        print("O a gagné !")
    else:
        print("Match nul !")

# Appeler la fonction commencer
commencer()