first commit
This commit is contained in:
BIN
TP01/JeuNim.pdf
Normal file
BIN
TP01/JeuNim.pdf
Normal file
Binary file not shown.
496
TP01/Nim.ipynb
Normal file
496
TP01/Nim.ipynb
Normal file
@@ -0,0 +1,496 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# Implémentation du jeu de Nim"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 12,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"etat_jeu = [3, 4, 5] # Trois tas contenant respectivement 3, 4 et 5 objets.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 1 "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 13,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[3, 4, 5]\n",
|
||||
"[0, 0, 0]\n",
|
||||
"[1, 0, 2]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# A.\n",
|
||||
"def afficher_etat(etat_jeu) :\n",
|
||||
" print(etat_jeu)\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"# B.\n",
|
||||
"test1 = [3, 4, 5]\n",
|
||||
"test2 = [0, 0, 0]\n",
|
||||
"test3 = [1, 0, 2]\n",
|
||||
"\n",
|
||||
"afficher_etat(test1)\n",
|
||||
"afficher_etat(test2)\n",
|
||||
"afficher_etat(test3)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 2 : "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 14,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[(0, 1), (0, 2), (0, 3), (1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (2, 3), (2, 4), (2, 5)]\n",
|
||||
"[]\n",
|
||||
"[(0, 1), (2, 1), (2, 2)]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# A.\n",
|
||||
"\n",
|
||||
"def generer_mouvement(etat_jeu) : \n",
|
||||
" mouvements = []\n",
|
||||
" for i in range(len(etat_jeu)) : # On parcourt les tas\n",
|
||||
" for j in range(etat_jeu[i]) : # On tire le nombre d'objets dans le tas\n",
|
||||
" if etat_jeu[i] > 0 :\n",
|
||||
" mouvements.append((i, j+1)) # On ajoute le mouvement à la liste\n",
|
||||
" return mouvements\n",
|
||||
"\n",
|
||||
"# B.\n",
|
||||
"print(generer_mouvement(test1))\n",
|
||||
"print(generer_mouvement(test2))\n",
|
||||
"print(generer_mouvement(test3))"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 3 : "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 15,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"# A et B\n",
|
||||
"def appliquer_mouvement(etat_jeu, tas_index, nombre_objets) :\n",
|
||||
" if nombre_objets > etat_jeu[tas_index] :\n",
|
||||
" print(\"Erreur : nombre d'objets à retirer supérieur au nombre d'objets dans le tas.\")\n",
|
||||
" return etat_jeu\n",
|
||||
" else : \n",
|
||||
" etat_jeu[tas_index] -= nombre_objets\n",
|
||||
" return etat_jeu\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 4 :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 16,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"\" étant donné que heuristique est égale à la somme des objets dans les tas, \\nc'est donc un calcul simple qui ne dépend pas de l'ordre des tas. \""
|
||||
]
|
||||
},
|
||||
"execution_count": 16,
|
||||
"metadata": {},
|
||||
"output_type": "execute_result"
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# A.\n",
|
||||
"'''\n",
|
||||
"def heuristique(etat_jeu) :\n",
|
||||
" return sum(etat_jeu)\n",
|
||||
"\n",
|
||||
"print(heuristique(test1))\n",
|
||||
"print(heuristique(test2))\n",
|
||||
"print(heuristique(test3))'''\n",
|
||||
"\n",
|
||||
"# B.\n",
|
||||
"''' étant donné que heuristique est égale à la somme des objets dans les tas, \n",
|
||||
"c'est donc un calcul simple qui ne dépend pas de l'ordre des tas. '''\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 5 :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 17,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"1\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# A.\n",
|
||||
"def est_etat_final(etat_jeu) :\n",
|
||||
" return sum(etat_jeu) == 0\n",
|
||||
"\n",
|
||||
"# B.\n",
|
||||
"def cout_transition(etat_courant, etat_suivant):\n",
|
||||
" return 1\n",
|
||||
"\n",
|
||||
"# Exemple d'utilisation\n",
|
||||
"etat_courant = [3, 4, 5]\n",
|
||||
"etat_suivant = appliquer_mouvement(etat_courant, 0, 1) # Devrait retourner [2, 4, 5]\n",
|
||||
"print(cout_transition(etat_courant, etat_suivant)) # Devrait retourner 1"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 6 : "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 18,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[[4, 8, 5], [4, 0, 5], [0, 0, 5], [0, 0, 0]]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"import heapq\n",
|
||||
"\n",
|
||||
"class Noeud:\n",
|
||||
" def __init__(self, etat, parent, cout, heuristique):\n",
|
||||
" self.etat = etat\n",
|
||||
" self.parent = parent\n",
|
||||
" self.cout = cout\n",
|
||||
" self.heuristique = heuristique\n",
|
||||
"\n",
|
||||
" def __lt__(self, other):\n",
|
||||
" return self.cout + self.heuristique < other.cout + other.heuristique\n",
|
||||
"\n",
|
||||
" def __eq__(self, other):\n",
|
||||
" return self.etat == other.etat\n",
|
||||
"\n",
|
||||
" def __hash__(self):\n",
|
||||
" return hash(tuple(self.etat))\n",
|
||||
"\n",
|
||||
" def __str__(self):\n",
|
||||
" return str(self.etat)\n",
|
||||
" \n",
|
||||
"def xor_etat(etat_jeu):\n",
|
||||
" xor_total = 0\n",
|
||||
" for nb_objets in etat_jeu:\n",
|
||||
" xor_total ^= nb_objets\n",
|
||||
" return xor_total\n",
|
||||
"\n",
|
||||
"def heuristique(etat_jeu):\n",
|
||||
" xor_valeur = xor_etat(etat_jeu)\n",
|
||||
" if xor_valeur == 0:\n",
|
||||
" # Position désavantageuse (perdante)\n",
|
||||
" return 100 + sum(etat_jeu) # Pénalité\n",
|
||||
" else:\n",
|
||||
" # Position avantageuse (gagnante)\n",
|
||||
" return sum(etat_jeu) # Heuristique standard\n",
|
||||
"\n",
|
||||
"def est_etat_final(etat):\n",
|
||||
" return all(pile == 0 for pile in etat)\n",
|
||||
"\n",
|
||||
"def generer_successeurs(etat):\n",
|
||||
" successeurs = []\n",
|
||||
" for i in range(len(etat)):\n",
|
||||
" if etat[i] > 0:\n",
|
||||
" for j in range(1, etat[i] + 1):\n",
|
||||
" nouvel_etat = etat[:]\n",
|
||||
" nouvel_etat[i] -= j\n",
|
||||
" successeurs.append(nouvel_etat)\n",
|
||||
" return successeurs\n",
|
||||
"\n",
|
||||
"def algorithme_a_star(etat_initial):\n",
|
||||
" noeud_initial = Noeud(etat_initial, None, 0, heuristique(etat_initial))\n",
|
||||
" frontiere = []\n",
|
||||
" heapq.heappush(frontiere, noeud_initial)\n",
|
||||
" visites = set()\n",
|
||||
"\n",
|
||||
" while frontiere:\n",
|
||||
" noeud_courant = heapq.heappop(frontiere)\n",
|
||||
"\n",
|
||||
" if est_etat_final(noeud_courant.etat):\n",
|
||||
" chemin = []\n",
|
||||
" while noeud_courant:\n",
|
||||
" chemin.append(noeud_courant.etat)\n",
|
||||
" noeud_courant = noeud_courant.parent\n",
|
||||
" return chemin[::-1]\n",
|
||||
"\n",
|
||||
" visites.add(tuple(noeud_courant.etat))\n",
|
||||
"\n",
|
||||
" for successeur in generer_successeurs(noeud_courant.etat):\n",
|
||||
" if tuple(successeur) not in visites:\n",
|
||||
" cout = noeud_courant.cout + cout_transition(noeud_courant.etat, successeur)\n",
|
||||
" heur = heuristique(successeur)\n",
|
||||
" noeud_successeur = Noeud(successeur, noeud_courant, cout, heur)\n",
|
||||
" heapq.heappush(frontiere, noeud_successeur)\n",
|
||||
"\n",
|
||||
" return None\n",
|
||||
"\n",
|
||||
"# Exemple d'utilisation\n",
|
||||
"etat_initial = [4, 8, 5]\n",
|
||||
"chemin_optimal = algorithme_a_star(etat_initial)\n",
|
||||
"print(chemin_optimal)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 7 :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"(voir cellule précédante)\n",
|
||||
"\n",
|
||||
"A. \n",
|
||||
"- Initialisation:\n",
|
||||
" - Crée un nœud initial avec l'état initial du jeu.\n",
|
||||
" - Utilise une file de priorité (heap) pour gérer les nœuds à explorer.\n",
|
||||
" - Utilise un ensemble (set) pour stocker les états déjà visités.\n",
|
||||
"- Boucle principale:\n",
|
||||
" - Tant que la file de priorité n'est pas vide, extraire le nœud avec le coût total (coût + heuristique) le plus bas.\n",
|
||||
" - Si l'état du nœud courant est un état final, reconstruire et retourner le chemin depuis l'état initial jusqu'à l'état final.\n",
|
||||
" - Ajouter l'état courant à l'ensemble des états visités.\n",
|
||||
" - Générer les états successeurs et les ajouter à la file de priorité s'ils n'ont pas été visités.\n",
|
||||
"- Retour: Si aucun chemin n'est trouvé, retourner None.\n",
|
||||
"\n",
|
||||
"B.\n",
|
||||
"- Vérification des états visités, avant d'ajouter un successeur à la file de priorité, on vérifie si ils ont été visité.\n",
|
||||
"- Une fois qu'un successeur est ajouté, il est ajouté à la file de priorité et marqué comme visité.\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 8 : "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"A. \n",
|
||||
"Une représentation de son parent est crée dans la classe noeud. Lorsque qu'un successeur est crée, le noeud courant est défini comme parent\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 19,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[[3, 4, 5], [3, 4, 4], [3, 4, 0]]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"# B.\n",
|
||||
"\n",
|
||||
"def reconstruire_chemin(noeud_final):\n",
|
||||
" \"\"\"\n",
|
||||
" Reconstruit la séquence de mouvements depuis l’état initial jusqu’à l’état final.\n",
|
||||
" \n",
|
||||
" :param noeud_final: Le nœud final de l'algorithme A*.\n",
|
||||
" :return: Une liste des états représentant le chemin de l'état initial à l'état final.\n",
|
||||
" \"\"\"\n",
|
||||
" chemin = []\n",
|
||||
" noeud_courant = noeud_final\n",
|
||||
" while noeud_courant:\n",
|
||||
" chemin.append(noeud_courant.etat)\n",
|
||||
" noeud_courant = noeud_courant.parent\n",
|
||||
" return chemin[::-1]\n",
|
||||
"\n",
|
||||
"# Création d'un chemin d'exemple pour tester la fonction\n",
|
||||
"etat_initial = [3, 4, 5]\n",
|
||||
"etat_intermediaire = [3, 4, 4]\n",
|
||||
"etat_final = [3, 4, 0]\n",
|
||||
"\n",
|
||||
"noeud_final = Noeud(etat_final, Noeud(etat_intermediaire, Noeud(etat_initial, None, 0, 0), 1, 0), 2, 0)\n",
|
||||
"chemin = reconstruire_chemin(noeud_final)\n",
|
||||
"print(chemin) # Devrait retourner [[3, 4, 5], [3, 4, 4], [3, 4, 0]]\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 9 : "
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 22,
|
||||
"metadata": {},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[3, 4, 5]\n",
|
||||
"[3, 4, 5]\n",
|
||||
"\n",
|
||||
"L'IA joue...\n",
|
||||
"[3, 4, 0]\n",
|
||||
"[0, 4, 0]\n",
|
||||
"\n",
|
||||
"L'IA joue...\n",
|
||||
"\n",
|
||||
" L'IA a gagné !\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"def jeu_nim(etat_initial):\n",
|
||||
" etat = etat_initial[:]\n",
|
||||
" while not est_etat_final(etat):\n",
|
||||
" afficher_etat(etat)\n",
|
||||
" try:\n",
|
||||
" pile = int(input(\"Entrez le numéro de la pile (1, 2, 3, ...): \")) - 1\n",
|
||||
" nb_objets = int(input(\"Entrez le nombre d'objets à retirer: \"))\n",
|
||||
" appliquer_mouvement(etat, pile, nb_objets)\n",
|
||||
" afficher_etat(etat)\n",
|
||||
" except ValueError:\n",
|
||||
" print(\"Entrée invalide. Veuillez entrer des nombres entiers.\")\n",
|
||||
" continue\n",
|
||||
"\n",
|
||||
" if est_etat_final(etat):\n",
|
||||
" print(\"\\nFélicitations ! Vous avez gagné !\")\n",
|
||||
" break\n",
|
||||
"\n",
|
||||
" # Tour de l'IA\n",
|
||||
" chemin_optimal = algorithme_a_star(etat)\n",
|
||||
" if chemin_optimal and len(chemin_optimal) > 1:\n",
|
||||
" etat_ia = chemin_optimal[1]\n",
|
||||
" print(\"\\nL'IA joue...\")\n",
|
||||
" etat = etat_ia\n",
|
||||
"\n",
|
||||
" if est_etat_final(etat):\n",
|
||||
" print(\"\\n L'IA a gagné !\")\n",
|
||||
" break\n",
|
||||
"\n",
|
||||
"# Exemple d'utilisation\n",
|
||||
"etat_initial = [3, 4, 5]\n",
|
||||
"jeu_nim(etat_initial)"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### Exercice 10 :"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 21,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"def xor_etat(etat_jeu):\n",
|
||||
" xor_total = 0\n",
|
||||
" for nb_objets in etat_jeu:\n",
|
||||
" xor_total ^= nb_objets\n",
|
||||
" return xor_total\n",
|
||||
"\n",
|
||||
"def heuristique_amelioree(etat_jeu):\n",
|
||||
" xor_valeur = xor_etat(etat_jeu)\n",
|
||||
" if xor_valeur == 0:\n",
|
||||
" # Position désavantageuse (perdante)\n",
|
||||
" return 100 + sum(etat_jeu) # Pénalité\n",
|
||||
" else:\n",
|
||||
" # Position avantageuse (gagnante)\n",
|
||||
" return sum(etat_jeu) # Heuristique standard"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python 3",
|
||||
"language": "python",
|
||||
"name": "python3"
|
||||
},
|
||||
"language_info": {
|
||||
"codemirror_mode": {
|
||||
"name": "ipython",
|
||||
"version": 3
|
||||
},
|
||||
"file_extension": ".py",
|
||||
"mimetype": "text/x-python",
|
||||
"name": "python",
|
||||
"nbconvert_exporter": "python",
|
||||
"pygments_lexer": "ipython3",
|
||||
"version": "3.10.6"
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 2
|
||||
}
|
||||
197
TP01/code.py
Normal file
197
TP01/code.py
Normal file
@@ -0,0 +1,197 @@
|
||||
import heapq
|
||||
import random
|
||||
|
||||
class Noeud:
|
||||
def __init__(self, etat, parent, cout, heuristique):
|
||||
self.etat = etat
|
||||
self.parent = parent
|
||||
self.cout = cout
|
||||
self.heuristique = heuristique
|
||||
|
||||
def __lt__(self, other):
|
||||
return self.cout + self.heuristique < other.cout + other.heuristique
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.etat == other.etat
|
||||
|
||||
def __hash__(self):
|
||||
return hash(tuple(self.etat))
|
||||
|
||||
def __str__(self):
|
||||
return str(self.etat)
|
||||
|
||||
def afficher_etat(etat_jeu) :
|
||||
print(etat_jeu)
|
||||
|
||||
def xor_etat(etat_jeu):
|
||||
xor_total = 0
|
||||
for nb_objets in etat_jeu:
|
||||
xor_total ^= nb_objets
|
||||
return xor_total
|
||||
|
||||
def heuristique(etat_jeu):
|
||||
xor_valeur = xor_etat(etat_jeu)
|
||||
if xor_valeur == 0:
|
||||
# Position désavantageuse (perdante)
|
||||
return 100 + sum(etat_jeu) # Pénalité
|
||||
else:
|
||||
# Position avantageuse (gagnante)
|
||||
return sum(etat_jeu) # Heuristique standard
|
||||
|
||||
def appliquer_mouvement(etat_jeu, tas_index, nombre_objets) :
|
||||
if nombre_objets > etat_jeu[tas_index] :
|
||||
print("Erreur : nombre d'objets à retirer supérieur au nombre d'objets dans le tas.")
|
||||
return etat_jeu
|
||||
else :
|
||||
etat_jeu[tas_index] -= nombre_objets
|
||||
return etat_jeu
|
||||
|
||||
def cout_transition(etat_courant, etat_suivant):
|
||||
return 1
|
||||
|
||||
|
||||
def est_etat_final(etat):
|
||||
return all(pile == 0 for pile in etat)
|
||||
|
||||
def generer_successeurs(etat):
|
||||
successeurs = []
|
||||
for i in range(len(etat)):
|
||||
if etat[i] > 0:
|
||||
for j in range(1, etat[i] + 1):
|
||||
nouvel_etat = etat[:]
|
||||
nouvel_etat[i] -= j
|
||||
successeurs.append(nouvel_etat)
|
||||
return successeurs
|
||||
|
||||
def algorithme_a_star(etat_initial):
|
||||
noeud_initial = Noeud(etat_initial, None, 0, heuristique(etat_initial))
|
||||
frontiere = []
|
||||
heapq.heappush(frontiere, noeud_initial)
|
||||
visites = set()
|
||||
|
||||
while frontiere:
|
||||
noeud_courant = heapq.heappop(frontiere)
|
||||
|
||||
if est_etat_final(noeud_courant.etat):
|
||||
chemin = []
|
||||
while noeud_courant:
|
||||
chemin.append(noeud_courant.etat)
|
||||
noeud_courant = noeud_courant.parent
|
||||
return chemin[::-1]
|
||||
|
||||
visites.add(tuple(noeud_courant.etat))
|
||||
|
||||
for successeur in generer_successeurs(noeud_courant.etat):
|
||||
if tuple(successeur) not in visites:
|
||||
cout = noeud_courant.cout + cout_transition(noeud_courant.etat, successeur)
|
||||
heur = heuristique(successeur)
|
||||
noeud_successeur = Noeud(successeur, noeud_courant, cout, heur)
|
||||
heapq.heappush(frontiere, noeud_successeur)
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def reconstruire_chemin(noeud_final):
|
||||
"""
|
||||
Reconstruit la séquence de mouvements depuis l’état initial jusqu’à l’état final.
|
||||
|
||||
:param noeud_final: Le nœud final de l'algorithme A*.
|
||||
:return: Une liste des états représentant le chemin de l'état initial à l'état final.
|
||||
"""
|
||||
chemin = []
|
||||
noeud_courant = noeud_final
|
||||
while noeud_courant:
|
||||
chemin.append(noeud_courant.etat)
|
||||
noeud_courant = noeud_courant.parent
|
||||
return chemin[::-1]
|
||||
|
||||
def sauvegarder_partie(historique, fichier="historique_parties.txt"):
|
||||
"""
|
||||
Sauvegarde l'historique de la partie dans un fichier.
|
||||
|
||||
:param historique: Liste des coups effectués pendant la partie.
|
||||
:param fichier: Nom du fichier où sauvegarder l'historique.
|
||||
"""
|
||||
with open(fichier, "a") as f:
|
||||
f.write("Nouvelle partie\n")
|
||||
for coup in historique:
|
||||
f.write(f"{coup}\n")
|
||||
f.write("\n")
|
||||
|
||||
|
||||
def jeu_nim(etat_initial):
|
||||
etat = etat_initial[:]
|
||||
historique = []
|
||||
while not est_etat_final(etat):
|
||||
afficher_etat(etat)
|
||||
try:
|
||||
pile = int(input("Entrez le numéro de la pile (1, 2, 3, ...): ")) - 1
|
||||
nb_objets = int(input("Entrez le nombre d'objets à retirer: "))
|
||||
historique.append(f"Joueur: Pile {pile + 1}, Objets retirés: {nb_objets}")
|
||||
appliquer_mouvement(etat, pile, nb_objets)
|
||||
afficher_etat(etat)
|
||||
except ValueError:
|
||||
print("Entrée invalide. Veuillez entrer des nombres entiers.")
|
||||
continue
|
||||
|
||||
if est_etat_final(etat):
|
||||
print("\nFélicitations ! Vous avez gagné !")
|
||||
break
|
||||
|
||||
# Tour de l'IA
|
||||
chemin_optimal = algorithme_a_star(etat)
|
||||
if chemin_optimal and len(chemin_optimal) > 1:
|
||||
etat_ia = chemin_optimal[1]
|
||||
historique.append(f"IA: Pile {pile + 1}, Objets retirés: {nb_objets}")
|
||||
print("\nL'IA joue...")
|
||||
etat = etat_ia
|
||||
|
||||
if est_etat_final(etat):
|
||||
print("\n L'IA a gagné !")
|
||||
break
|
||||
sauvegarder_partie(historique)
|
||||
|
||||
def pile_random(etat) :
|
||||
piles_non_vides = [i for i, pile in enumerate(etat) if pile > 0]
|
||||
return random.choice(piles_non_vides)
|
||||
|
||||
|
||||
def nb_objets_random(etat, pile):
|
||||
return random.randint(1, etat[pile])
|
||||
|
||||
|
||||
def jeu_nim_random(etat_initial):
|
||||
etat = etat_initial[:]
|
||||
historique = []
|
||||
while not est_etat_final(etat):
|
||||
afficher_etat(etat)
|
||||
try:
|
||||
pile = pile_random(etat)
|
||||
nb_objets = nb_objets_random(etat, pile)
|
||||
historique.append(f"Joueur: Pile {pile + 1}, Objets retirés: {nb_objets}")
|
||||
appliquer_mouvement(etat, pile, nb_objets)
|
||||
afficher_etat(etat)
|
||||
except ValueError:
|
||||
print("Entrée invalide. Veuillez entrer des nombres entiers.")
|
||||
continue
|
||||
|
||||
if est_etat_final(etat):
|
||||
print("\nFélicitations ! Vous avez gagné !")
|
||||
break
|
||||
|
||||
# Tour de l'IA
|
||||
chemin_optimal = algorithme_a_star(etat)
|
||||
if chemin_optimal and len(chemin_optimal) > 1:
|
||||
etat_ia = chemin_optimal[1]
|
||||
historique.append(f"IA: Pile {pile + 1}, Objets retirés: {nb_objets}")
|
||||
print("\nL'IA joue...")
|
||||
etat = etat_ia
|
||||
|
||||
if est_etat_final(etat):
|
||||
print("\n L'IA a gagné !")
|
||||
break
|
||||
sauvegarder_partie(historique)
|
||||
|
||||
|
||||
etat_initial = [3, 4, 5]
|
||||
jeu_nim_random(etat_initial)
|
||||
Reference in New Issue
Block a user