Python, jeu de memory

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.

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()

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 !

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