Discussion :

[Isamaria]

Bonjour,

Je suis en T et en Spé INS. Pour mon bac blanc de mardi je dois réaliser un jeu de vie un peu particulier.
En effet, même si le principe reste le même, une partie du programme reste différent.
Je dois tout d'abord rester sur l'IDLE de python sans jamais me racrocher à une interface graphique et utiliser une sorte de "liste dans une liste" afin d'obtenir un tableau / une grille. Je dois aussi à chaque tour faire naitre un nombre aléatoirede cellures dans dans des cases choisies aléatoirement. Jusque là je ne rencontre aucune difficulté.
Cependant, il met aussi demandé de faire naitre une cellule lorsque deux cellules se retrouvent adjacentes, que ce soit en horizontalement ou verticalement. La nouvelle cellule ne peut naitre que dans une des 4 cases de façon aléatoire dans les 2 situées à droite ou à gauche pour un couple vertical et au dessus et en dessous pour l'horizontal.
De même qu'une cellule doit disparaitre lorsque 6 cellules se retrouvent jointes en un bloc de 3x2 ou 2x3. La cellule qui meurt est encore une fois aléatoire.
Le problème n'est pas que tout soit aléatoire mais comment identifier les cellules adjacentes que ce soit pour les naissances ou les décès ? Je n'arrive pas à comprendre comment les "localiser" pour les utiliser ensuite.

Voici le début de mon algorithme :

#################### Algorithme : Jeu de la vie ################################################

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
from random import *
global g
global g_bis
 
                 ### Présentation jeu vide ###
def GrilleVide(nombreLignes, nombreColonnes):
    grille = [[]] * nombreLignes
    for ligne in range(nombreLignes):
        grille[ligne] = ['-'] * nombreColonnes
        print(grille[ligne])
    return grille
 
 
                ### Initialisation de la grille ###
def InitGrille (nombreLignes, nombreColonnes):
    Nb_O=int(random()*10)
    print("Nombre de cellule pour le terrain initial (par tirage aléatoire) : ",Nb_O)
    for O in range (Nb_O):
        L=int(random()*10)
        C=int(random()*10)
        g[L-1][C-1]='O'
        g_bis=[]
        g_bis.append(g)
 
    print(g_bis)
 
 
                ### Naissance de cellules ###
def NaissanceSUP (nombreLignes, nombreColonnes):
    Nb_O=int(random()*10)
    print("Nombre de naissance à ce tour (par tirage aléatoire) : ",Nb_O)
    for O in range (Nb_O):
        L=int(random()*10)
        C=int(random()*10)
        g[L-1][C-1]='O'
        g_bis=[]
        g_bis.append(g)
 
    print(g_bis)
 
 
                ### Naissance par couple/duo de cellules ###
 
def NaissanceDUO (nombreLignes, nombreColonnes):
 
 
 
                ### Décès par bloc de 1 sur 3x2 ou 2x3 ###
 
 
 
 
 
 
###################  Corps de l'algorithme  ###################################################
 
 
print("Bienvenue au jeu de la vie. \nVoici votre terrain de jeu :")
print()
nbL=10
nbC=20
g=GrilleVide(nbL,nbC)
print()
 
print ("Voici maintenant votre terrain de jeu initial :")
print()
i=InitGrille (nbL,nbC)
print()
 
Nb_tours=int(input("Combien de tours souhaitez-vous réaliser ? "))
for n in range (Nb_tours):
    typ1_O=NaissanceSUP (nbL,nbC)

#####################################################################################


Si vous avez des pistes de recherches à me conseiller, des astuces, des choses que je peux modifier et qui peuvent m'aider à sortir de cette impasse je vous en serai très reconnaissant puisque c'est pour mon bac blanc que je passe la semaine prochaine.

Merci d'avance.

[wiztricks]

Salut,

Si vous avez des pistes de recherches à me conseiller, des astuces

Soit une case (i, j), les cellules adjacentes sont (i-1, j), (i+1, j), (i, j-1), (i, j+1) modulo le traitement des bords.
Pour commencer, prenez une feuille de papier quadrillée et matérialisez 2 tableaux de 10 lignes x 20 colonnes.
Le premier sera l'état courant, le second l'état suivant à calculer.
Puis vous essayer de visualiser ce qu'il se passe dans les différents cas proposés.

- W

[Isamaria]

Bonjour,

Merci d'avoir répondu à mon message de la veille.
Je me suis penchée sur le question des deux tableaux et ai défini des "ensembles" de nombre dans lesquels une naissance se peut se produire ou mourir.
J'ai constater des ensemble de nombres tel que :




Seulement, je ne vois pas bien où cela me mène. Pouvez-vous m'en dire plus ?

[wiztricks]

Seulement, je ne vois pas bien où cela me mène. Pouvez-vous m'en dire plus ?

Ben maintenant, il va vous falloir décrire une méthode qui balaie votre grille pour y reconnaître les différents cas de figures. Commencez par 2 cellules adjacentes horizontalement ou verticalement.
Quelque part, il va falloir balayer l'ensemble des colonnes de chaque ligne et définir que faire lorsqu'on rencontre une cellule en (i, j). A la base, il faut regarder ce qu'il y a dans son voisinage et vérifier qu'il n'y a qu'une cellule en (i+1, j) ou (i, j+1) et que cette cellule là n'est voisine que de la cellule en (i, j).
note: (i+1, j) ou (i, j+1) car comme vous balayez le tableau suivant des indices croissants, il y a matière à simplifier lorsqu'on arrive sur une cellule qui fait déjà partie d'une figure identifiée dans les itérations précédentes.
Si c'est un couple vertical, vous choisissez une case au hasard dans (i, j-1), (i, j+1), (i+1, j-1), (i +1, j+1).

- W

[Isamaria]

"décrire une méthode qui balaie votre grille pour y reconnaître les différents cas de figures"

Justement, c'est de cette méthode dont fait l'objet ma question en réalité.
Je n'arrive pas à déterminer comment, en langage python, je peux réaliser une telle chose.
Comme je vient de débuter Python, j'ai fait plusieurs recherches dans des livres et sur d'autres ou des leçons sur YouTube.
Cependant, rien ni personne ne parle d'une méthode de ce type et je m'avoue quelque peu perdue.
Pouvez-vous me donner quelques pistes ? Des fonctions à utiliser ?

[wiztricks]

Cependant, rien ni personne ne parle d'une méthode de ce type et je m'avoue quelque peu perdue.
Pouvez-vous me donner quelques pistes ? Des fonctions à utiliser ?

Quelque part, c'est une double boucle "for":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for j in len(tableau):
     for i in len(line):
          #et on travaille sur tableau[i][j]

Puis vous aurez à écrire des "helpers" (à déterminer) pour par exemple trouver les indices des cases voisines de (i, j) (ou d'une paire (i, j), (i, j+1)) pour vérifier qu'il n'y a rien "autour".

Enfin, il va falloir "tester" que votre code "fonctionne" comme vous l'attendez.
Pour cela, vous pouvez fabriquer des tableaux de chaînes de caractères, genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
sample ='''00000
0X000
0X000
00000
00000
'''

et vérifier que çà sort bien les indices de la paire verticale qu'on voit.

- W

[Isamaria]

Merci pour ces pistes, je vais m'y mettre de suite.