Python, jeu de memory Fermé

Question

Bonjour, je suis en train de plancher sur un jeu de mémory sur python ( pour un partiel :/ ) , donc je suis en train de suivre les instructions, à savoir :

Question 1 . Définissez les variables globales n que vous initialiserez à 6 et la matrice
matriceLettres qui contient n lignes et n colonnes, chacune des cases de la matrice contiendra
la chaîne vide "".
Définissez une fonction remplissage matrice qui va remplir matriceLettres avec les lettres de
A à R. Pour cela, définissez (dans la fonction) une liste lettres qui contiendra toutes les lettres.
Construisez un dictionnaire dicoLettres où les clefs sont les lettres de A à R et la valeur est 2
pour chaque clef. Remplissez toutes les cases de la matrice en tirant à chaque fois aléatoirement
une lettre dans le dictionnaire. N'oubliez pas de mettre à chaque fois à jour le dictionnaire.

donc pour le coup j'ai fais ça :

def matriceLettres():
    n=6
    matrice=n*[0]
    for i in range(len(matrice)):
        matrice[i] = n*[0]    

from random import*
def remplissage_matrice(matrix):
    dicoLettres={}
    lettres=["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R"]
    matrix=matriceLettres()
    for i in lettres:
        dicoLettres[i]=2
    for a in range(6):
        for b in range(6):
            c=lettres[randrange(17)]
            dicoLettres[c]=dicoLettres[c]-1
            if dicoLettres[c]>=0:
                matrix[a][b]=c
    return matrix

mais il semblerait que cela ne fonctionne pas ... Si quelqu'un pouvait m'éclairer assez rapidement, je lui en serais gré. ( Pour info, j'utilise Python2.6 sur conseil de la prof.)

6ril · Answer

tu pourrais SVP mettre ton code sous la forme "code" pour voir ton indentation   
et si tu pouvais mettre le message d'erreur que ça te génère ça pourrait aider   

essaies comme ça, je pense que ça doit mieux fonctionner car:   
   - tu appelais la fonction matriceLettres() mais elle ne retournais rien  
   - tu remplissais matrix qui venait de je ne sais où alors que tu voulais remplir matrice que tu venit de créer non?  


def matriceLettres():  
  n=6  
  matrice=n*[""]  
  for i in range(len(matrice)):  
     matrice[i] = n*[""]  
  return matrice  


def remplissage_matrice():  
  dicoLettres={}  
  lettres=["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R"]  
  matrice=matriceLettres()  
  for i in lettres:  
    dicoLettres[i]=2  
  for a in range(6):  
    for b in range(6):  
      c=lettres[randrange(17)]  
      if dicoLettres[c]>=0:  
        matrice[a][b]=c  
  return matrice

heyquem · Answer

Eh oui, comme dit 6ril, quand dicoLettres[c] vaut 0, cela veut dire que la lettre considérée a déjà été placée deux fois dans la liste de listes et qu'on ne la place pas une 3ième fois. Mais si tu ne fais rien faire à ton programme à la place, cela veut dire qu'arrivé au bout des 16 itérations sur a et b, il y a une affectation de lettre qui n'aura pas été faite.   

J'ai l'air de baratiner, mais mettre ainsi le problème en mots permet de faire naître des idées. C'est ainsi que j'ai trouvé 3 façons de corriger le problème:   



- on peut intégrer les lignes    
                c=lettres[randrange(17)]    
                dicoLettres[c]=dicoLettres[c]-1    
                if dicoLettres[c]>=0:    
                    matrix[a][b]=c
dans une boucle while dont on ne sortira que si dicoLettres[c]>=0   



- dans    

            for b in range(6):    
                c=lettres[randrange(17)]    
                dicoLettres[c]=dicoLettres[c]-1    
                if dicoLettres[c]>=0:    
                    matrix[a][b]=c
tu testes si tu peux mettre c dans une case après avoir fixé la valeur de c (cette valeur est une des lettres A à R). Pour éviter de se retrouver coincé avec une valeur de c  qu'on ne peut pas ajouter dans une case, il y a la solution de ne prélever dans le dictionnaire qu'une lettre encore autorisée, donc d'éliminer du dictionnaire les lettres après leur deuxième tirage. Cela implique que le nombre délivré par randrange(17) ne sera plus nécessairement parmi les clés du dictionnaire -> il faut prévoir un test, ou un choix de nombre parmi l'ensemble des clés restantes, donc une autre fonction du module random   



- on peut aussi imaginer de ne pas se contraindre à faire seulement 16 itérations, mais autant qu'il le faudra pour trouver des clés non déjà utilisées 2 fois, en prenant les instructions dans une boucle while d'un autre genre.   

Remplacer deux boucles en a et b par une seule boucle while n'est pas aussi dur qu'il semble au premier abord: il suffit de mettre un peu de mathématique dans le parcours des cases:   

0 c'est 6*0 + 0   

1 = 6*0 + 1   

2 = 6*0 + 2   

...   

5 = 6*0 + 5   

6 = 6*1 + 0   

7 = 6*1 + 1   

...   

12 = 6*2 + 0   

...   

...   

6*5 + 0   

...   

35 = 6*5 + 5   

d'où : quand i parcourt xange(36) , divmod(i,6) parcourt [ (0,0),(0,1),(0,2),.....(0,5),(1,0),....(2,0),....(5,5) ]   

Donc on peut faire une boucle    

i = 0   
while i<16:    

avec i partant de 0 et incrémenté de 1 seulement si on a tiré dans le dictionnaire une lettre non déjà utilisée deux fois.   



Je te laisse coder l'une des solutions, car il faut bien que tu révises  ;)   



J'ai vu que 6ril a mis une solution. Je vais la regarder, mais il ne faudrait pas trop lui mâcher le travail. D'autant qu'il y a des malins: il présente ça comme une révision pour un partiel, mais c'est peut être un devoir à faire pour demain !

heyquem · Answer

Ce n'est pas un problème de répondre, quand on aide vraiment. Mais il y en a qui exagèrent, il leur faut du tout cuit, ce n'est pas la meilleure façon d'apprendre. On ne peut pas savoir a priori, excuse.  


-----------------------  


La solution de 6ril correspond à ma deuxième proposition: il enlève une lettre de la liste. Mais dans mon post je parle d'enlever du dictionnaire, parce que l'énoncé dit :  
tirant à chaque fois aléatoirement une lettre dans le dictionnaire
Son code est juste un peu redondant: en enlevant une lettre de la liste dès qu'elle a été utilisée deux fois, on est sûr que c=lettres[randrange(len(lettres))] ne donne qu'une lettre n'ayant été utilisée que 0 ou 1 fois, 
donc qu'on peut faire matrice[a][b]=c à coup sûr. D'où simplifier:  
 for a in range(6):  
  for b in range(6):    
   c=lettres[randrange(len(lettres))]  
   dicoLettres[c]=dicoLettres[c]-1  
   matrice[a][b]=c  
   # la seconde fois, la lettre est supprimee de lettres  
   if dicoLettres[c] == 0:   
    lettres.remove(c)






En fait l'énoncé est mauvais:  



- à ma connaissance, il n'y a pas en Python de structure de données permettant de représenter une matrice au sens mathématique du terme, c'est à dire dont la référence à une case serait notée matrice(2,7) et non pas matrice[2][7] , et douée des propriétés de calculs particulières aux matrices mathématiques.  

Aucune structure de donnée ne permet non plus de représenter un tableau, avec des références aux cases du genre tab(4,8)  

On est donc obligé de représenter un tableau par une liste de listes. Mais c'est uniquement une liste de listes, pas un tableau, ni une matrice.  

- il existe des structures de données qui s'appellent array en Python, ce sont des listes à éléments d'un seul type  

- il existe aussi des structures de données utilisables en Python qui portent le nom de tableau et d'autres qui sont des matrices, mais c'est uniquement dans le cadre de l'utilisation de la bibliothèque numpy  


- on n'est pas obligé de se trainer une liste pour créer le dictionnaire, on peut créer le dictionnaire sur la base d'un chaîne des lettres créée à la volée et disparaissant dès que son utilisation est finie:  
voir pour cela la fonction fromkeys()ou une simple itération for lettre in 'ABCDEFGHIJKLMNOPQR':  


- il n'y a pas de variables en Python, il n'y a que des références, c'est à dire des pointeurs vers des objets  



Dernière chose:  

l'énoncé demande que n soit une "variable" globale. Il ne faut donc pas la définir dans la fonction matriceLettres() mais en dehors, et passer cette référence comme argument à matriceLettres()

Mattd50 · Answer

Bonjour, me revoilà, après avec travailler sur mon jeu de memory, je suis parvenu à répondre aux questions 3-4 mais la question numéro 2 me pose problème, j'espère que vous pourrez m'aider :

Définissez la variable globale decouvert qui est une matrice de n lignes et
n colonnes où chacune des cases contient au départ la valeur False. Lorsque deux cartes
identiques seront retournées, les deux cases correspondantes de decouvert seront mises à True.
Ecrivez une fonction ni qui renvoie True si la partie est terminée (toutes les cases de
decouvert sont à True) et False sinon. 


Donc je me suis dis que j'allais partir sur une fonction à 3 arguments et cela donne cela pour le moment :

def decouvert(n,p,c):
    matrice=matriceLettres(n)
    matriceAlea=remplissage_matrice(n)
    for a in range(n):
        for b in range(n):
            matrice[a][b]=False
    
            
    return matrice

def fini():
    matrice=decouvert(n)
    for a in range(n):
        for b in range(n):
            if matrice[a][b]==False:
                return False
    return True

Mon problème est que je ne parviens pas à tester efficacement ce que j'ai nommé 'p' et 'c'. MOn problème vient essentiellement du fait qu'il s'agit d'un élément de sous-liste.

Je remercie dès a présent l'âme charitable qui poura m'aider n_n.

6ril · Answer

tout d'abord je ne pense pas que ton code fonctionne car:

- ta fonction decouvert() n'a pas les même arguments (une fois p,n et c et l'autre que n)
- pourquoi mettre p et c en arguments de decouvert() alors que tu t'en sers pas?
- n ne dois pas être considéré comme défini dans la fonction fini()

heu dis moi si je me trompe mais ta fonction decouvert(n,p,c) crée un matrice initialiser à False et que tu modifies quand le joueurs à trouvé des paires et fini() parcours cette matrice pour voir si il reste au moins 1 False sinon Partie finie

Si j'ai bien compris le problème alors tu ne termineras jamais ton jeu car à chaque fois que tu exécutes fini()tu appelles decouvert() qui crée une nouvelle matrice de jeu et une initialisée à False

Python, jeu de memory

5 réponses

Discussions similaires