Aide pour créer grille Python Shell

Version imprimable

Alors voila je planche depuis un bout de temps mais je ne parviens pas à atteindre le resultat voulu.
Je dois créer une grille ressemblant à ceci
Code:

1 2 3 4 5 6 7 X 1 2 3 4 5 6 7 8 9 A * * * * * * * * * B * * * * * * * * * C * * * * * * * * * D * * * * * * * * * E * * * * * * * * * F * * * * * * * * *
Sous python Shell
Dans le but de créer un jeux de memory
le probléme est qu'etant bloquer a ce niveau pour le remplissage de case etc j'avance pas des masses

voici ce que j'avais fait
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Paire=input() Case=Paire*2 colonne=case/10 Lol=Lot[1:colonne+1] Lot=[[".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."], [".",".",".",".",".",".",".",".",".","."]] def init(): print "Saisissez le nombre de Paires" Paire=input() colonne=Paire/10
Mais il faut que le joueur choisisse un nombre de paire qu'il souhaite et non pas un multiple de 10
Or aprés j'arrive pas à obtenir un tableau de forme rectangle (niveau presentation) seul les matrices carrés fonctionnent et ont un aspect correct
mais des lors que c'est une matrice non carré ça ne fonctionne
si par exemple je dois avoir 42 cases il en faudrait 6 en ligne 7 en colonnes ou inversement et non pas qu'il cherche à faire une matrice carée avec 42 car ceci fait des cases vides dans le tableau et au final ne ressemble à rien

Si quelqu'un peut m'aider ça serait sympa

Cordialement

Bonjour nedjed
bon je suis un débutant mais voila ce que je propose pour avoir un tableau ajustable:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
def fonction(a=42):
    a=a #nombre de case au début
    b=0.0
    difference=100#le 100 c'est juste un chiffre élevé pour le départ
    while b<12:#j'ai mis 12 au hasard c'est juste une limite
        b=b+1    
        c=a/b
        if (c-b)*(c-b)<= difference and c%1==0:
            difference =(c-b)*(c-b)
            x,y=c,b#les valeur choisies
    print """finallement c'est le couple:""",x,y

bon j'espère que c'était ça ton problème.

Merci je vais essayer ta solution
je venais de plancher sur cette solution
Code:

1 2 3 4 5 6 7 8 9 Paires=input() NbCase=Paires*2 Ligne =(NbCase**0,5)//1 def grille(): Colonne=NbCase//Ligne Horizontal=Ligne*["*"] for i in range(len(Horizontal)): Horizontal[i] = Colonne*["*"]
Ce qui permettrait de definir la colonne en fonction des lignes, mais il me renvoit toujours une erreure suite à la ligne Colonne = Nbcase//Ligne
" TypeError: unsupported operand type(s) for //: 'tuple' and 'int'"

Je vais m'y remettre en testant ta solution, si certains savent comment empecher l'erreur que je reçois sur ce nouvelle essai merci de m'en faire part

Il faut que le nombre soit un arrondi d'ou le // mais ça ne change rien a mes tests

Cordialement Ned'

Edit : ça fonctionne avec ton programme je vais pouvoir definir ligne et colonne merci beaucoup ça me debloque la :D

Si certains on la solution pour le code dans ce message, histoire de comprendre mon erreur, bien que je n'en ai plus utilité

31/03/2011, 18h09
honosstoa

bonjour nedjed
il me semble que zéro virgule cinq s'écrit '0.5' et pas '0,5' (ligne 3)

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 Paires=input() NbCase=Paires*2 Ligne=int(NbCase**0.5//1) if Paires%2==0: Colonne=NbCase//(Ligne-1) else: Colonne=NbCase//(Ligne-1) def grille(): if Paires%2==0: Horizontal=(Ligne)*["*"] for i in range(len(Horizontal)): Horizontal[i] = Colonne*["*"] return Horizontal else: Horizontal=(Ligne-1)*["*"] for i in range(len(Horizontal)): Horizontal[i] =Colonne*["*"] return Horizontal def remplir_grille(): Possib={} StockPaire=["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"] Horizontal=grille() for i in StockPaire: Possib[i]=2 for a in range(Ligne): for b in range(Colonne): c=Possib[randrange(len(StockPaire))] Possib[c]=Possib[c]-1 if Possib[c]>0: Horizontal[a][b]=c elif StockPaire[c] == 0: Horizontal[a][b]=c StockPaire.remove(c) return Horizontal
Bon et bien ça progresse, merci pour la virgule j'étais con sur ce coup la :D
Le tableau s'affiche, bon manque le /n pour la forme mais ça fonctionne lorsque je lance grille avec ce procédé
Mtn il me faut placer les lettres dedans, me suis inspiré d'un truc trouvé sur le net, mais ça n'est pas trop brillant au final, Key Error 17
Me suis renseigné , c'est que je demande des ints au lieu de string, du moins cette erreur serait celle ci, je vois pas trop ou en fait, si quelqu'un pourrait me montrer vers ou ça foire, Il faut aussi que j'ajoute une fonction qui empeche a l'utilisateur d'entrer plus que 26 paires, n'ayant pas assez de lettre et ça prendra forme ^^

Si quelqu'un à la solution niveau du placement

Cdt

03/04/2011, 18h32
honosstoa

bonsoir
euh en fait je lirai attentivement plus tard mais deja :
Pourquoi mettre une condition a la ligne 4 ? en fait qu'elle soit vraie ou fausse c'est la même chose qui se passe.
Ensuite je ne suis pas sur que le calcul du nombre de cases soit Ok .
Un exemple :tu tape 10 paires (ce qui fait 20 cases) et tu obtient 6 colonne sur 4 lignes.
Ce qui ne fait pas 20 cases.
03/04/2011, 20h43
nedjed

A la base je les avais fini dans la fonction grille, mais par la suite il ne conaissait pas la variable Colonne dans la fonction de remplissage, donc je l'ai mis plus haut, J'avais pas fait gaf pour 10, j'ai fait exemple avec quelques nombres mais pas tout

re
alors dans ton code :
1)"Possib={}" ici Possib est une liste il faut donc écrire Possib [ ]
2)"for i in StockPaire: " ici i va prendre un à un la valeur de chaque membre de StockPaire (qui sont des lettres)
Mais le problème c'est que après tu utilise i comme indice :"Possib[i]=2"
et un indice est un chiffre pas une lettre de l'alphabet donc problème
3)ensuite dans "c=Possib[randrange(len(StockPaire))]" tu n' as pas importé le module
il faut mettre "from random import randrange"
(je trouve que ton identation est bizard (moi je met toujours 4 espaces) )
je me suis arreté la parce que je suis pas sur de bien comprendre ce que tu as voulu faire après.

Bon alors je te propose une autre méthode :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 def fonction(a=42):#a est le nombre de cases liste=["A","B","C","D","E","F","G","H","I","J",\ "K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"] dliste=["1"," 2"," 3"," 4"," 5"," 6"," 7"," 8"," 9"] a=a #nombre de case au début b=0.0#ne pas oublier de l'avoir au format float difference=100#le 100 c'est juste un chiffre élevé pour le départ while b<27:#il y a 26 lettres dans l'alphabet b=b+1 c=a/b if (c-b)*(c-b)< difference and c%1==0:#il sufit de mettre '<'ou '<='pour inverser #x et y difference =(c-b)*(c-b) x,y=int(c),int(b)#les valeur choisies print 'x:',x,'y:',y e=" "+",".join(dliste[0:x]) #transformation de dliste en chaine et c'est ici qu'on choisit #la position des chiffres sur la ligne print e d=-1 while d<y-1: d=d+1 print liste[d],x*' * '
Si je me trompe quelque part merci de me le dire.

03/04/2011, 22h48
nedjed

J'essaierais d'associer ça à mon programme des demain matin, manque de temps ce soir, merci beaucoup pour l'aide ^^
05/04/2011, 09h03
nedjed

Je n'ai pas réussi à associer ton programme à ma grille afin de la remplir, pour mon autre methode mes amis m'ont dit que je me compliquais la vie, et que la fonction choice était plus adéquat, si tu pourrais m'éclairer pour associer le remplissage à la grille Cdt

En retravaillant tout ça j'affiche ma grille de maniere plus belle, et j'arrive à ressortir une paire de chaque, mais je 'narrive pas à intégrer ces paires dans la grille, comme voici:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
 
from random import *
StockPaire=["A","A","B","B","C","C","D","D","E","E","F","F","G","G","H","H","I","I","J","J","K","K","L","L","M","M","N","N","O","O","P","P","Q","Q","R","R","S","S","T","T","U","U","V","V","W","W","X","X","Y","Y","Z","Z"]
Paires=input("nb depaire")
NbCase=Paires*2
Ligne=int(NbCase**0.5//1)
if Paires%2==0:
  Colonne=NbCase//(Ligne)
else:
  Colonne=NbCase//(Ligne-1)
def grille():
  if Paires%2==0:
    Horizontal=(Ligne)*["?"]
    for i in range(len(Horizontal)):
      Horizontal[i] = Colonne*["?"]
    return Horizontal
  else:
    Horizontal=(Ligne-1)*["?"]
    for i in range(len(Horizontal)):
      Horizontal[i] =Colonne*["?"]
    return Horizontal
 
def affich_grille():
  Horizontal=grille()
  for i in Horizontal:
    for j in i:
      print j+ " ",
    print ""
 
def remplir_grille():
  Possib=[]
  Possib=StockPaire[0:2*Paires]
  shuffle(Possib)
 
  return Possib
def formepaire():
  Possib=[]
  Possib=StockPaire[0:2*Paires]
  shuffle(Possib)
  if Paires%2==0:
    Horizontal=(Possib[0:Ligne])
    for i in range(len(Horizontal)):
      Horizontal[i] = Possib[0:Colonne]
    return Horizontal
  else:
    Horizontal=(Ligne-1)*["?"]
    for i in range(len(Horizontal)):
      Horizontal[i] =Colonne*["?"]
    return Horizontal
 
def affich_Paires():
  Horizontal=remplir_grille()
  for i in Horizontal:
    for j in i:
      print j+" ",
    print ""

Le probléme est à la fonction formepaire, j'essaye qu'elle affiche les elements de remplir_grille, dans ma grille affich_grille, du moins sous la même forme, en conservant le shuffle, sans quoi le jeux devient evidemment trop facil

Si quelqu'un à la solution Cdt

05/04/2011, 21h19
honosstoa

bonsoir
bon juste pour être sur de bien comprendre :
En fait tu veux que chaque "?" de ta grille représente une lettre mais que la lettre ne soit pas affichée et qu'il y est un "?" à la place.
Et que bien sur on ne doit pas savoir quelle lettre est sous quel "?" .

En fait pourquoi ma grille ne te convient pas? c'est la même que celle que tu as déssiné dans ton premier message non?
05/04/2011, 21h43
nedjed

Je sais pas trop faut que les deux structures soient sur les même base afin que lorsque je vais rentrer une coordonée(chose dont je ne sais pas encore comment je vais faire) genre D4 ça m'affiche la lettre dans le shell et je dis une autre lettre si c'est la même ça print à la place des deux lettres " " enleve la case en quelque sorte, si tu test affich_grille ça te donne une idée de la grille a quoi elle ressemble actuellement, il faut que j'ai la même forme avec a l'interieur les lettres j'ai réussi a afficher des lettres de manieres a avoir genre pour 9 paires 18 lettres, mais pas les bonnes ça me donne genre [A A B C] et ceux 4 fois si c'est une grille de 4/4
donc la je patine, encore beaucoup de chose à faire et ce remplissage me bloque
06/04/2011, 07h32
nedjed

J'ai passé un bon bout de temps à fignoler ça, j'arrive à afficher mes listes de lettre de la maniere souhaitée, le probléme est mtn de recuperer la lettre dans la case ou elle se trouve, et de ne pas modifier la grille au fur et à mesure que je jou, j'ai mis un systeme de A B C D sur le coté qui permet de choisir la ligne, en prenant par exemple
if lig =="A "
Horiz = Possib[0:ligne]
if lig =="B"
Horiz= Possib[ligne:ligne*2]

pour ainsi récuperer les lignes que je souhaite et prendre un element a l'interieur de cette liste avec lig = raw_input()
Mais ça me ressort une lettre qui ne correspond a vrai dire jamais à la lettre de la grille, je pense que la grille se renouvelle entre chaque fonction ou je ne sais pas, si quelqu'un a une solution

Cdt

je pense y passer un bon moment cette aprés midi
On verra :D

salut,

après un rapide survol, il semble que tu utilise au final une grille carrée, ne respectant pas forcément le nombre de paires données, voici donc une fonction qui se base sur un principe de ratio minimum/maximum/idéal, et où c'est seulement ceux-ci qui sont arbitraires :

Code:

1
2
3
4
5
6
7
8
9
10
11
def size(cases,ratio_min=1.0,ratio_max=2.0, ratio_ideal=16/9.):
	challenger=()
	for x in xrange(cases/2,0,-1):
		di,mo = divmod(cases,x)
		ratio = float(x)/di
		if not mo and ratio_min <= ratio <= ratio_max :
			if not challenger:
				challenger = ((x,di),ratio)
			elif abs(ratio_ideal-ratio)<abs(ratio_ideal,challenger[1]):
				challenger = ((x,di),ratio)
	return challenger

Le principe est de trouver toutes les tailles de grilles possibles respectant le nombre de cases donné (donc paires*2), d'ignorer les tailles inférieures/suppérieures aux ratio minimal/maximal et de retourner la taille s'approchant le plus du ratio idéal.

En ce qui concerne le remplissage, voici le début d'une classe Grid qui est censée gérer une grille. Il y manque une grille "cachée", et puis toutes les fonctions de gameplay, bref, faudra la developper :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Grid(object):
	def __init__(s,w,h,default='~'):
		s.data   = [[default]*w for x in range(h)]
		s.width  = w
		s.height = h
		s.pairs  = None
	def __setitem__(s,k,v):
		if type(k)==tuple :
			s.data[k[0]][k[1]] = v
		else :
			s.data[k]          = v
	def __getitem__(s,k):
		if type(k)==tuple :
			y,x = k
			return s.data[y][x]
		else :
			return s.data[k]
	def pairs_set(s,it):
		s.pairs  = it
	def populate(s):
		coords   = [(y,x) for x in xrange(s.width) for y in xrange(s.height)]
		pairs    = s.pairs[:]
		for i in xrange(len(pairs)):
			p = random.choice(pairs)
			pairs.remove(p)
			for j in range(2):
				c    = random.choice(coords)
				coords.remove(c)
				s[c] = p
	def __str__(s):
		return '\n'.join([''.join(s.data[x]) for x in range(s.height)])

ex d'utilisation :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
>>> #on veut 69 paires
>>> size(69*2,ratio_max=4.0)
((23, 6), 3.8333333333333335)
>>> grille = Grid(23,6)
>>> #maintenant que la grille est crée aux dimensions voulues, il faut crer la liste de paires
>>> #on a pas besoin d'avoir deux fois un élément, l'algorithme sort deux coordonnées de cases pour chaque éléments de la liste de paires
>>> # On a donc besoin de créer une liste de 69 éléments
>>> it = ([chr(x) for x in xrange(ord('A'),ord('Z')+1)]*3)[:69]
>>> it
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q']
>>> # j'ai répéter plusieur fois l'alphabet juqu'a ce qu'il y ait 69 éléments... il y aura donc jusqu'a 6 exemplaires de certaines lettres (3x2)
>>> #il faut maintenant indiquer cette liste à l'objet Grid
>>> grille.pairs_set(it)
>>> # puis la "populer"
>>> grille.populate()
>>> print grille
AMHIJBTARWTMEHICGWVOMTA
FNBKLJEJLLVCUFSOQIXSHNK
ZGMHWCJDDONKYPCQLFXAQNZ
CGQPYOYJCILBHEQKGDKZIKP
NLREUVDUTDMMGEVBPBIFREU
FOPQXOBZRADFPGJWXSYSHNA