Python, jeu de memory

Jeu
Python

Mattd50 - 14 avril 2010 à 14:35
Jean Airienafoutre - 10 avril 2013 à 15:45

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

Afficher la suite

A voir également:

Jeu memory python
Windows memory cleaner - Télécharger - Optimisation
Citizen code python avis - Accueil - Outils
94 jeu - Télécharger - Puzzle & Réflexion
Windows memory diagnostic - Télécharger - Optimisation
94 degrés jeu - Télécharger - Divers Jeux

5 réponses

Réponse 1 / 5

6ril
Modifié par 6ril le 14/04/2010 à 16:22

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

6ril
Modifié par 6ril le 14/04/2010 à 16:36

je viens de le tester et apparemment ça fonctionne mais sans le paramètre qu'une même lettre n'apparait que 2 fois), voilà le résultat

>>> remplissage_matrice() 
[['B', 'Q', 'K', 'B', 'C', 'A'], ['M', 'F', 'M', 'E', 'K', 'A'], ['L', 'I', 'P', 'J', 'C', 'Q'], ['N', 'F', 'P', 'L', 'P', 'O'], ['O', 'H', 'J', 'K', 'A', 'C'], ['L', 'H', 'I', 'D', 'D', 'P']]

Mattd50
14 avril 2010 à 16:43

Merci pour ta solution cependant, il y a plusieurs fois la lettre 'K' par exemple, or il me la faut seuleument 2 fois c'est pour cela que j'avais noté :

 
for b in range(6):  
      c=lettres[randrange(17)]
      dicoLettres[c]=dicoLettres[c]-1
      if dicoLettres[c]>=0:  
        matrice[a][b]=c
      else:

mais en réessayant, avec cette ligne, j'ai pu constater que j'avais des blancs dans mes sous-listes.

>>> remplissage_matrice()
[['A', 'F', 'D', 'A', 'P', 'H'], ['N', 'B', '', 'P', 'L', 'D'], ['', 'N', '', 'L', 'M', ''], ['C', 'E', 'J', 'H', 'I', 'J'], ['', 'F', 'M', 'K', '', 'K'], ['', 'I', 'O', '', 'Q', '']]

6ril
Modifié par 6ril le 14/04/2010 à 17:35

oui j'avais vu mais je n'avais pas le temps de complètement finir ;)
pour les '' c'est normal car si tu te trouve dans le cas d'un else, ben il fait rien et passe à la case suivante

je regarde ça plus tard

Edit: Voilà normalement ça doit fonctionner maintenant:

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(len(lettres))]
			dicoLettres[c]=dicoLettres[c]-1
			# la première fois que la lettre est trouvée: Insertion dans matrice
			if dicoLettres[c]>0:
				matrice[a][b]=c
			# la seconde fois, la lettre est ajoutee dans la matrice et supprimee de lettres
			elif dicoLettres[c] == 0:	
				matrice[a][b]=c
				lettres.remove(c)
	return matrice

Mattd50
14 avril 2010 à 19:22

Merci beaucoup, je n'avais pas pensais à lettres.remove(c). =) Si jamais je rencontre d'autre problème pourrais-je revenir te poser quelques questions, parce que je parviens à trouver la solution ( à peu près) mais il y a toujours des détails qui m'échappent ?

Réponse 2 / 5

heyquem Messages postés 759 Date d'inscription mercredi 17 juin 2009 Statut Membre Dernière intervention 29 décembre 2013 131
Modifié par heyquem le 14/04/2010 à 18:37

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 !

Mattd50
14 avril 2010 à 18:39

Merci pour ta réponse, je vais essayer de "transformer" cela se soir, en ce qui concerne ta suspicion, je tiens à préciser que je suis en vacances et que j'essai réellement de trouver une solution à cette première question, j'espère pouvoir parvenir aux suivantes sans trop d'aide IRL.
J'essaierais de te dire si j'ai réussi à mettre en place tes solutions.

Réponse 3 / 5

heyquem Messages postés 759 Date d'inscription mercredi 17 juin 2009 Statut Membre Dernière intervention 29 décembre 2013 131
Modifié par heyquem le 14/04/2010 à 19:37

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

Réponse 4 / 5

Mattd50
18 avril 2010 à 10:17

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.

Réponse 5 / 5

6ril
19 avril 2010 à 11:50

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

Mattd50
19 avril 2010 à 12:42

Bah en faite j'ai pris p et c parce que je ne voyait pas comment représenter les 2 élements cliqués dans cette fonction, pour ce qui est la fonction fini, je devrais donc mettre comme argument une matrice directement ? J'avoue que pour ce point là je suis complétement à la "ramasse".

Mattd50
19 avril 2010 à 15:21

Je suis encore en train de plancher deçu et je reste coinçé avec la seconde partie de la question :

"Lorsque deux cartes
identiques seront retournées, les deux cases correspondantes de decouvert seront mises à True."

je ne vois pas comment "réinterpréter" ça en python .

6ril
20 avril 2010 à 11:27

je sais pas trop mais si tu fais quelque chose du genre
au moment où tu regardes ce qu'à choisi le joueur, tu fais la vérif si c'est une paire ou non:
- si oui, tu remplaces False par True dans l'autre matrice
- si non, tu retournes les cases et le jeu continue

if matrice_avec_chiffres_a_chercher[a1][b1] == _avec_chiffres_a_chercher[a2][b2]:
     matrice_True_False[a][b] = True
     matrice_True_False[a][b] = True
else:
     renvoi à la fonction de choix des cases

Mattd50
20 avril 2010 à 11:53

Donc à ton avis, il faudrait que j'écrive une fonction de choix de case ?

6ril
20 avril 2010 à 12:13

ben je sais pas tu pensais faire comment pour que le joueur choisisse les cases à comparer?

Fais-tu une interface graphique ou en ligne de commande?
car si c'est la deuxième solution (même si je pense pas que ce soit la plus adaptée) un simple raw_input() avec une entrée du genre A1 B2 où A correspond à [a] et 1 à [b]

Discussions similaires

ti 83+ installer des jeux ion

Projet python jeu de carte

Programme du jeu de la roulette

Programme Pendu Python-Tkinter

Création de Jeux Video 3D

Programmation jeu de carte

Votre réponse

Discussions similaires