jeu ricosheep en python

problème de solveur

a marqué ce sujet comme résolu.

Bonjour, je fais un solveur qui doit déterminer s’il est possible.

De gagner à partir d’un état du jeu donné. En cas de réponse positive, le solveur doit aussi fournir.

Une solution à la grille, c’est-à-dire une liste des coups à jouer pour arriver à la victoire.

Et voici l’algorithme que l’on m’a donné (qui ressemble à l’algorithme de recherche en profondeur)

Mais mon code à plusieurs soucis visite un (dictionnaire) n’enregistre pas la position des moutons (car la variable moutons est une liste de tuple) et je n’arrive pas à vérifier, si la position des moutons est déjà dans le dictionnaire.

Et j’aimerais savoir si mon code reprend le principe du algorithme du sac à dos ?

Je vous remercie d’avance.

def solveur(plateau,moutons,visite,nombre_herbe):
    """
    Le rôle du solveur est de déterminer s’il est possible
    de gagner à partir d’un état du jeu donné. En cas de réponse positive, le solveur doit aussi fournir
    une solution à la grille, c’est-à-dire une liste des coups à jouer pour arriver à la victoire.
    param: plateau : list
    param: moutons : list de tuple
    param: visite : dico
    """
    moutons_tuples = moutons[0]
    if victoire(plateau,moutons,nombre_herbe) :
        return []
    if moutons_tuples in visite :
        if plateau == visite[moutons_tuples] :
            return None
    else :
        visite[moutons_tuples] = plateau
        if solveur(jouer(plateau,moutons,'Left'),moutons,nombre_herbe,visite) == [] :
            return ['Left'] + solveur(jouer(plateau,moutons,'Left'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Right'),moutons,nombre_herbe,visite) == [] :
            return ['Right'] + solveur(jouer(plateau,moutons,'Right'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Up'),moutons,nombre_herbe,visite) == [] :
            return ['Up'] + solveur(jouer(plateau,moutons,'Up'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Down'),moutons,nombre_herbe,visite) == [] :
            return ['Down'] + solveur(jouer(plateau,moutons,'Down'),moutons,nombre_herbe,visite)
        return None
+0 -0

Tu écris "voici l’algorithme qu’on m’a donné", mais on ne le voit pas.

Le code que tu nous donne n’est pas complet.
Il serait plus lisible si tu utilisais la balise python.

Nous ne savons pas comment tu as défini plateau, moutons, visite…. et autres fonctions.

Tu défini
def solveur(plateau,moutons,visite,nombre_herbe):
mais tu écris plus loin un appel à solver :
solveur(jouer(plateau,moutons,’Left’),moutons[1:],nombre_herbe,visite)
où les deux derniers paramètres ne sont pas dans le bon ordre.
Quoi qu’il en soit, tu as des messages d’erreur, il convient de le lire et de les comprendre.

+0 -0

mon code est très long mais bon je vais tout envoyer et je n’arrive pas à corriger mes erreurs je ne sais pas comment faire 

def init_plateau(plateau):
    plateau_jeu = []
    tmp = []
    for i in range(len(plateau)):
        tmp = []
        for j in range(len(plateau)):
            tmp.append(plateau[i][j])
        plateau_jeu.append(tmp)
    return(plateau_jeu)  




def premiere_case_vide(plateau,pos,i):
    ''' Retourne la 1ere case adjacente à 'pos' vide'''

    liste_dir = [[0,1],[0,-1],[1,0],[-1,0]]
    case_vide = [pos[0],pos[1]]

    
    case = plateau[pos[0]+liste_dir[i][0]][pos[1]+liste_dir[i][1]]
    if(case == None) or (case == 'G'):
        case_vide = [pos[0]+liste_dir[i][0],pos[1]+liste_dir[i][1]]
    return(case_vide)
    


def jouer(plateau,moutons,direction):
    plateau_jeu = init_plateau(plateau)
    droite = len(moutons) - 1
    gauche = 0
    bas = len(moutons) - 1
    haut = 0
    compteur_droite = moutons[droite][1]
    compteur_gauche = moutons[gauche][1]
    compteur_haut = moutons[haut][0]
    compteur_bas = moutons[bas][0]

    if (direction == 'Right') :
        while droite >= 0 :
            if compteur_droite == len(plateau[0])-1 :
                plateau_jeu[moutons[droite][0]][moutons[droite][1]] = 'S'
                droite -= 1
                compteur_droite = moutons[droite][1]
            if droite >= 0 and compteur_droite < len(plateau)-1 :  
                moutons[droite] = premiere_case_vide(plateau_jeu,moutons[droite],0)
                compteur_droite += 1
                
    if (direction == 'Left') :
        while gauche <= len(moutons) - 1:    
            if  compteur_gauche > 0:  
                moutons[gauche] = premiere_case_vide(plateau_jeu,moutons[gauche],1)
                compteur_gauche -= 1
            else:
                plateau_jeu[moutons[gauche][0]][moutons[gauche][1]] ='S'
                gauche += 1
                if gauche < len(moutons):
                    compteur_gauche = moutons[gauche][1]

    if (direction == 'Down') :
        while bas >= 0:
            if compteur_bas == len(plateau[0])-1:
                plateau_jeu[moutons[bas][0]][moutons[bas][1]] = 'S'
                bas -= 1
                compteur_bas = moutons[bas][0]
            if bas >= 0 and compteur_bas < len(plateau)-1 :  
                moutons[bas] = premiere_case_vide(plateau_jeu,moutons[bas],2)
                compteur_bas += 1
        
    if (direction == 'Up'):
        while haut <= len(moutons) - 1:    
            if  compteur_haut > 0 :  
                moutons[haut] = premiere_case_vide(plateau_jeu,moutons[haut],3)
                compteur_haut -= 1
            else:
                plateau_jeu[moutons[haut][0]][moutons[haut][1]] ='S'
                haut += 1
                if haut < len(moutons):
                    compteur_haut = moutons[haut][0]
    return moutons
                   
                        
    


def victoire(plateau,moutons,nombre_herbe):
    """
    la victoire sera détectée par une fonction victoire(plateau,
    moutons) renvoyant True si la partie est actuellement gagnée (chaque touffe d’herbe est couverte
    par un mouton) et False sinon.
    param: plateau : list
    param: moutons : list de tuple
    return boolean
    """
    moutons_sur_herbe = []

    for ligne in range(len(plateau)):
        for colonne in range(len(plateau)):
            for mouton_actuel in moutons :
                if ligne == mouton_actuel[0] and colonne == mouton_actuel[1] :
                    if plateau[ligne][colonne] == 'G' :
                        moutons_sur_herbe.append('présent')
    if len(moutons_sur_herbe) == nombre_herbe :
        return True
    return False


def solveur(plateau,moutons,visite,nombre_herbe):
    """
    Le rôle du solveur est de déterminer s’il est possible
    de gagner à partir d’un état du jeu donné. En cas de réponse positive, le solveur doit aussi fournir
    une solution à la grille, c’est-à-dire une liste des coups à jouer pour arriver à la victoire.
    param: plateau : list
    param: moutons : list de tuple
    param: visite : dico
    """
    moutons_tuples = moutons[0]
    if victoire(plateau,moutons,nombre_herbe) :
        return []
    if moutons_tuples in visite :
        if plateau == visite[moutons_tuples] :
            return None
    else :
        visite[moutons_tuples] = plateau
        if solveur(jouer(plateau,moutons,'Left'),moutons,nombre_herbe,visite) == [] :
            return ['Left'] + solveur(jouer(plateau,moutons,'Left'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Right'),moutons,nombre_herbe,visite) == [] :
            return ['Right'] + solveur(jouer(plateau,moutons,'Right'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Up'),moutons,nombre_herbe,visite) == [] :
            return ['Up'] + solveur(jouer(plateau,moutons,'Up'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Down'),moutons,nombre_herbe,visite) == [] :
            return ['Down'] + solveur(jouer(plateau,moutons,'Down'),moutons,nombre_herbe,visite)
        return None

plateau =[[None, 'B', None, 'B', None], 
        ['B', 'B', None, None, None], 
        [None, 'G', 'B', 'B', None],
        [None, 'B', 'G', None, None],
        [None, None, None, 'B', None]]
moutons = [(2,4), (1,3),(0,4),(4,4)]

>>> solveur(plateau,moutons,{},2)
+0 -0

Regarde donc les messages d’erreur, et vois comment y remédier.

Ton code manque de commentaires qui indiqueraient ce qu’on cherche à faire.

+0 -0

Dans ta fonction solveur, tu as ces quelques lignes :

  if solveur(jouer(plateau,moutons,'Left'),moutons,nombre_herbe,visite) == [] :
            return ['Left'] + solveur(jouer(plateau,moutons,'Left'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Right'),moutons,nombre_herbe,visite) == [] :
            return ['Right'] + solveur(jouer(plateau,moutons,'Right'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Up'),moutons,nombre_herbe,visite) == [] :
            return ['Up'] + solveur(jouer(plateau,moutons,'Up'),moutons[1:],nombre_herbe,visite)
        if solveur(jouer(plateau,moutons,'Down'),moutons,nombre_herbe,visite) == [] :
            return ['Down'] + solveur(jouer(plateau,moutons,'Down'),moutons,nombre_herbe,visite)
        return None

Dans les 3 premiers cas, tu utilises moutons[1:], mais dans le 4ème, tu utilises moutons. Bizarre.

+1 -0

D’accord, j’en mettrais plus de commentaire, merci, j’ai rectifié (j’ai enlevé moutons[1:] et je l’ai remplacer par fonction jouer qui renvoie moutons) , mais j’ai une erreur que je n’arrive pas à corriger. Sur le terminal, il me renvoie ça comme erreur :

if moutons_tuples in visite :
TypeError: unhashable type: 'list'

def solveur(plateau,moutons,visite,nombre_herbe):
    """
    Le rôle du solveur est de déterminer s’il est possible
    de gagner à partir d’un état du jeu donné. En cas de réponse positive, le solveur doit aussi fournir
    une solution à la grille, c’est-à-dire une liste des coups à jouer pour arriver à la victoire.
    param: plateau : list
    param: moutons : list de tuple
    param: visite : dico
    """
    moutons_tuples = moutons[0]
    if victoire(plateau,moutons,nombre_herbe) :
        return []
    if moutons_tuples in visite :
        if plateau == visite[moutons_tuples] :
            return None
    else :
        print(visite)
        visite[moutons_tuples] = plateau
        if solveur(plateau,jouer(plateau,moutons,'Left'),nombre_herbe,visite) != [] :
            return ['Left'] + solveur(plateau,jouer(plateau,moutons,'Left'),visite,nombre_herbe)
        if solveur(plateau,jouer(plateau,moutons,'Left'),nombre_herbe,visite) == [] :   
            return solveur(plateau,jouer(plateau,moutons,'Left'),visite,nombre_herbe)

        if solveur(plateau,jouer(plateau,moutons,'Right'),nombre_herbe,visite) != [] :
            return ['Right'] + solveur(plateau,jouer(plateau,moutons,'Right'),visite,nombre_herbe)
        if solveur(plateau,jouer(plateau,moutons,'Right'),nombre_herbe,visite) == [] :
            return  solveur(plateau,jouer(plateau,moutons,'Right'),visite,nombre_herbe)

        if solveur(plateau,jouer(plateau,moutons,'Up'),nombre_herbe,visite) != [] :
            return ['Up'] + solveur(plateau,jouer(plateau,moutons,'Up'),visite,nombre_herbe)
        if solveur(plateau,jouer(plateau,moutons,'Up'),nombre_herbe,visite) == [] :
            return solveur(plateau,jouer(plateau,moutons,'Up'),visite,nombre_herbe)

        if solveur(plateau,jouer(plateau,moutons,'Down'),visite,nombre_herbe) == [] :
            return solveur(plateau,jouer(plateau,moutons,'Down'),visite,nombre_herbe)
        if solveur(plateau,jouer(plateau,moutons,'Down'),visite,nombre_herbe) != [] :
            return ['Down'] + solveur(plateau,jouer(plateau,moutons,'Down'),visite,nombre_herbe)
        return None
#je cherche à obtenir ça comme résultat ['Down', 'Left', 'Down', 'Left', 'Down', 'Left', 'Right', 'Left', 'Up', 'Right', 'Up'] c'est la liste de direction qui me permettra de gagné.
+0 -0

Le changement que tu as fait est forcément mauvais.

Même si solveur() renvoie None, le test de la ligne 19 est vérifié.

Ligne 19, tu testes si un certain truc vaut [], et si oui, on sort de la procédure par la ligne 20.

En ligne 21, tu fais le test contraire, donc ce test est forcément vérifié. Et on sort de la procédure par la ligne 22.

Et les lignes 23 à 38 ne sont jamais exécutées.

+2 -0

Il faut rechercher

unhashable type: 'list'

et tu devrais trouver une explication.

etherpin

Je ne suis pas sûr que donner une explication du bout des lèvres sur un point relativement obscur de Python à un débutant soit très productif… :-°

j’ai une erreur que je n’arrive pas à corriger. Sur le terminal, il me renvoie ça comme erreur : if moutons_tuples in visite : TypeError: unhashable type: 'list'

Les dictionnaires en Python sont une structure de données un peu particulière (un truc qu’on appelle une hashmap en informatique) qui associe des clés à des valeurs. Pour faire ça de façon efficace, les clés (qui peuvent être des valeurs arbitraires) sont hashées : en gros Python calcule une clé intermédiaire (simplement un nombre) qui est plus facile/efficace à manipuler pour retrouver la valeur. Par exemple, si tu fais

a = {}
a["ma_cle"] = "valeur"

le dictionnaire va d’abord calculer hash("ma_cle") (tu peux taper ça directement dans un interpréteur Python, ça va typiquement renvoyer un nombre avec plein de chiffres) puis s’en servir comme adresse pour stocker la "valeur".

Le problème que tu rencontres est que pour une raison assez arbitraire, Python ne sait pas comment calculer le hash d’une liste (si tu tapes hash([1, 2]) dans un interpréteur, il te renverra la même erreur). La conséquence directe est que tu ne peux pas utiliser une liste comme clé d’un dictionnaire. Il te faut utiliser par exemple un tuple à la place de ta liste, qui lui est hashable (Python sait calculer hash((1, 2)).

+1 -0

Il faut rechercher

unhashable type: 'list'

et tu devrais trouver une explication.

etherpin

Je ne suis pas sûr que donner une explication du bout des lèvres sur un point relativement obscur de Python à un débutant soit très productif… :-°

Dans le cas présent il y a visiblement des lacunes dans l’approche de la programmation. Il convient à mon avis de donner des pistes pour avoir plus d’autonomie. C’est pourquoi j’incite à chercher soi-même le sens des messages d’erreur. Si ensuite on ne comprend pas de quoi ça parle, il faut donner une bonne explication comme tu le fais.

Il s’agissait dans un premier temps d’inciter à lire les messages d’erreur et non pâs se contenter d’écrire "j’ai un message d’erreur". Cela a été fait. Dans un deuxième temps, il faut chercher à les comprendre, ce qui n’a pas été fait.
Je suis d’accord que c’est un point relativement obscur, je suis d’accord avec ton explication.

+0 -1

J’ai encore corrigé mon code. visite n’est plus un dictionnaire, mais un ensemble, j’ai rajouté liste_direction dans le paramètre de la fonction (elle contient toutes les directions.) et j’ai enlevé les lignes inutiles maintenant, j’ai un souci ???? J’obtiens cette erreur (à cause de la ligne 21) : if moutons_tuples in visite : TypeError: argument of type 'int' is not iterable

def solveur(moutons,plateau,visite,nombre_herbe,liste_direction):
    """
    Le rôle du solveur est de déterminer s’il est possible
    de gagner à partir d’un état du jeu donné. En cas de réponse positive, le solveur doit aussi fournir
    une solution à la grille, c’est-à-dire une liste des coups à jouer pour arriver à la victoire.
    param: plateau : list
    param: liste_direction : list
    param: moutons : list de tuple
    param: visite : set 
    """
    moutons_tuples = tuple(moutons)
    if victoire(plateau,moutons,nombre_herbe) :
        return []
    if moutons_tuples in visite :
        if plateau == visite[moutons_tuples]:
            return None
    else :
        
        visite.add(moutons_tuples)
        dir = liste_direction[0]
        sol = solveur(jouer(plateau,moutons,dir),plateau,nombre_herbe,visite,liste_direction)
        print('valeur :' , sol)
    
        if sol != [] and dir == 'Left':
            return ['Left'] + sol
        
        if sol != [] and dir == 'Right':
            return ['Right'] + sol
        
        if sol != [] and dir == 'Up':
            return ['Up'] + sol
        if sol != [] and dir == 'Down':
            return ['Down'] + sol
        else : 
          return solveur(jouer(plateau,moutons,dir),plateau,nombre_herbe,visite,liste_direction[1:])

# liste_direction = ['Left','Right','Up','Down']

#print(solveur(moutons,plateau,set(),nombre_herbe,liste_direction)
+0 -0

J’ai encore corrigé mon code. visite n’est plus un dictionnaire, mais un ensemble

Ak_j

Note que les dictionnaires et les ensembles fonctionnent sur le même principe.
Comme expliqué par adri1, afin de minimiser les temps d’accès ces structures de données ont besoin de pouvoir calculer un nombre à partir des données entrées (les valeurs pour les ensembles, les clés pour les dictionnaires), ce calcul est appelé le hash.

Ainsi, les listes ne peuvent pas non plus être stockées dans des ensembles (une liste ne pouvant pas être hashée puisque sa valeur peut varier avec le temps).

>>> mylist = [1, 2, 3]
>>> {mylist}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
+0 -0

visite et nombre_herbe ne sont pas dans le même ordre entre l’appel et la définition de solveur. Pour rendre ton code plus lisible, n’hésite pas à insérer des espaces et des retours à la ligne.

# difficile à lire (et donc à débugger)
solveur(jouer(plateau,moutons,dir),plateau,nombre_herbe,visite,liste_direction)

# mieux
solveur(jouer(plateau, moutons, dir), plateau, nombre_herbe,
        visite, liste_direction)
+1 -0

Il y a 2 'challenges’ :

  • avoir un algorithme qui fonctionne

  • puis traduire cet algorithme en Python.

Là, tu fais des essais 'aléatoires’ sur l’algorithme, et en plus, tu as des problèmes de syntaxe de Python.

Deux problèmes à résoudre en même temps. C’est un problème de trop.

Sur le côté algorithme … tu avais 4 appels à une fonction solveur(). Dans ta dernière version, tu n’en as plus qu’un. Pourquoi ?

Tu ne testes plus que les déplacements vers la gauche, tu as peu de chances d’arriver à la solution.

En principe, on écrit un algorithme, très détaillé, on s’assure que l’algorithme marche, puis on le traduit dans le langage de son choix.

Là, tu fais les 2 choses en même temps. Quand on maitrise parfaitement l’aspect langage-de-programmation, pourquoi pas. Quand on n’est pas à l’aise, ni sur l’aspect algorithme, ni sur l’aspect langage-de-programmation, c’est une très mauvaise méthode.

+0 -0

L’algorithme procède comme suit, à partir de l’état du jeu donné par plateau et moutons et de l’ensemble initialement vide visite :

  1. Si l’état du jeu est actuellement gagné, répondre [] : il n’y a rien à faire de plus.
  2. Si l’état du jeu est déjà dans visite, répondre None. Cet état à déjà été considéré, on interrompt la recherche.
  3. Sinon, on commence par ajouter l’état du jeu dans visite. Puis, pour chaque direction dans ['Left’, 'Right’, 'Up’, 'Down'] :
  • On calcule l’état atteint en jouant direction.
  • On lance la recherche récursivement à partir de cet état.
  • Si la recherche renvoie une solution S, on renvoie [direction] + S.
  • Sinon, on annule le coup joué et on passe à la direction suivante.
  1. Si aucune direction ne permet d’arriver à une solution, on déduit qu’il n’y a pas de solution à partir de l’état donné, et on renvoie None.

(PS : j’ai pensé qui serais plus judicieux d’utiliser une liste de directions. En utilisant le premier coup, on regarde s’il y a des solutions ou s’il n’y en a pas de passer à une autre direction. Il est clair que cette solution n’a pas marché et je suis complètement perdu .)

def solveur(moutons,plateau,visite,nombre_herbe,liste_direction):
    """
    Le rôle du solveur est de déterminer s’il est possible
    de gagner à partir d’un état du jeu donné. En cas de réponse positive, le solveur doit aussi fournir
    une solution à la grille, c’est-à-dire une liste des coups à jouer pour arriver à la victoire.
    param: plateau : list
    param: liste_direction : list
    param: moutons : list de tuple
    param: visite : set 
    """
    plateau,plateau_jeu = init_plateau(plateau)
    plateau_jeu = tuple(plateau_jeu)
    moutons_tuples = tuple(moutons)
    if victoire(plateau,moutons,nombre_herbe) :
        return []

    if moutons_tuples in visite :
            if plateau_jeu in visite:
                return None   
                
    else :
        
        visite.add(tuple(plateau_jeu))
        visite.add(moutons_tuples)
        dir = tuple(liste_direction[0])
        sol = solveur(jouer(plateau_jeu,moutons,dir),
            plateau_jeu,visite,nombre_herbe,liste_direction)
        
        
        
    
        if sol != [] and dir[0] == 'L':
            return ['Left'] + [sol]
        
        if sol != [] and dir[0] == 'R':
            return ['Right'] + [sol]
        
        if sol != [] and dir[0] == 'U':
            return ['Up'] + [sol]

        if sol != [] and dir[0] == 'D':
            return ['Down'] + [sol]
        else : 
            return solveur(moutons,plateau_jeu,visite,
            nombre_herbe,liste_direction[1:])
+0 -0

Je serais incapable de programmer ce jeu avec tes indications. Les règles de déplacement ne sont pas données, par exemple qu’est-ce qui se passe si un mouton arrive sur un buisson ou de l’herbe ? Et c’est quoi une "solution" au juste ?

A ta place, je commencerais par un problème bien plus simple : une fonction qui calcule le résultat du mouvement d’un seul mouton.
Pour cela, j’utiliserais un tableau de dimension 2 dont les cellules décrivent le plateau de jeu. Par exemple, 0 pour une cellule vide, 1 pour une herbe, 2 pour un buisson, 3 pour un autre mouton.

On peut décider d’entourer le plateau de cellules qui valent 4 pour un bord. Ainsi; c’est facile de voir que le mouvement projeté ferait sortir du plateau.

Si j’ai bien compris, tu compte mémoriser la position du mouton dans un tuple qui contient ses coordonnées (mais je peux me tromper, car tu n’as pas expliqué ce qu’il y a dans ce tuple).
Ce n’est pas une très bonne idée, car un tuple ne peut pas être modifié une fois créé. Du coup, ce serait bien de coder aussi chaque mouvement dans un tuple : Nord serait 0,-1, Sud 0,1 Ouest -1,0 et Est 1,0. Il suffit d’additionner les contenus des tuple pour obtenir un nouveau tuple résultat du mouvement projeté (faire aussi une fonction pour cela). C’est peut être plus simple d’utiliser des listes. On pourrait aussi utiliser l’arithmétique des nombres complexes.

Le résultat de la fonction est la valeur de la cellule atteinte.

A partir de là, je pourrais ensuite voir si le mouvement est possible et si il est possible, décider ce qu’il faut faire.

Je testerais soigneusement cette fonction qui sera très utile par la suite.

Ensuite, on peut essayer de promener un mouton en évitant les bords. Bien tester ce qui se passe si le mouton est dans un coin. On peut alors ajouter les buissons.

Ensuite, je tenterais de trouver une "solution" pour un seul mouton. Pareil, il faut tester cela dans tous les sens.

Seulement là, je tenterais le cas avec plusieurs moutons.

+3 -0

Le solveur nous renvoie une liste de directions qui nous permet de gagner, il faut qui le fasse automatiquement. Pour gagner, il faut que chaque mouton soit sur une touffe d’herbe qui est représentée par un 'G’. Les moutons sont bloqués par un buisson « B » ou un moutons « S ». Tout ce que je peux vous dire ligne 26 n’est pas bon vu que je teste si le coup que je viens de jouer me fait gagner alors que je dois tester s’il y a une série de coups après celui-ci qui mène à la victoire. Après, je n’ai pas plus de précision sur la solution.

+0 -0

Bon, je reviens vers ce post après avoir regardé des problèmes similaires.
J’ai trouvé un problème très voisin : comment sortir d’un labyrinthe.

image.png

C’est un cas particulier de ton jeu, avec un seul mouton et une seule herbe.
Il n’y a pas de tuple , ni de dictionnaire (encore moins une dictionnaire de tuple).
Tout bêtement un tableau à 2 dimensions.

Si ça t’intéresse, va voir ici : Python 3 : objectif jeux.

Ce ne serait pas une mauvaise idée de tout parcourir. Le labyrinthe dont je te parle est au chapitre 13.

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte