Discussion :

[Akurasu]

Bonjour,

Ma prof de programmation python, nous a donné en exercice à l'examen un automate cellulaire à faire mais le problème c'est qu'il doit être en 2 dimension. En cour , on avais vu les automate cellulaire de dimension 1, et cela ne m'a pas posé de problème de compréhension mais là j'arrive pas a comprendre le passage à la dimension 2.

Je comprend les règles de l’automate, l'état excité (0) et réfracter (1) deviennent réfracté et l'autre l'autre morte (2) au pas suivent et une cellule morte devient existé si elle a 2 voisin excitée, en tout elle a 8 voisins.

Mais J'arrive pas a faire la grille pour appliquer ces règle en python, la prof nous a conseiller de créer une matrice.

J'ai commencer par utiliser :

M = [[0 for j in range(0,n)] for i in range(0,m)]
print (M)

Mais j'ai comme résultat: [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]], mais j'arrive pas a afficher la matrice en vertical et je sais pas comment pour qu'une cellule morte deviennent excité en examinant ces voisine proche autour d'elle.

J'ai chercher toute la journée sur google et j'ai rien trouvé.

Pouvez- vous m'aider à résoudre ce problème.

Merci

[VinsS]

Salu,

Ça tombe bien, je viens de faire un démineur ...

Pour créer une grille avec une liste comprehesion, tu peux faire comme ça:

Code :

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

1
2
 
a = [[0] *5 for i in range(4)]

Ce qui donne 4 lignes et cinq colonnes.

Pour la recherche de voisinage d'une cellule, je copie le code tel quel avec des commentaires qui devraient te permettre de comprendre ce qui se passe

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
 
ADJACENTS = ((0, -1), (-1, -1), (-1, 0), (-1, 1), 
                (0, 1), (1, 1), (1, 0), (1, -1))
 
...
 
    def on_user_click(self, cell):
        # cell est la cellule que nous examinons, cet objet possède, divers 
        # attributs
        self.check_current(cell)
        self.check_stack()
        self.update_infos()
 
    def check_current(self, curr):
        # On examine la cellule courante et son attribut value
        if curr.value == 10:
            # La cellule est minée
            curr.show_value()
            self.main.game_over()
 
        else:
            self.set_visible(curr)
 
    def check_stack(self):
        # On examine la pile 
        while self.stack:
            # Tant que la pile n'est pas vide, on en extrait le premier objet
            btn = self.stack.pop(0)
            self.get_neighbourhood(btn)
 
    def get_neighbourhood(self, square):
        # On vérifie le voisinnage d'une cellule, ici l'argument square,
        # les cellules ont les arguments posx et posy qui sont simplement
        # les coordonnées horizontale et verticale
        pos = (square.posx, square.posy)
        for adj in ADJACENTS:
            # La constante ADJACENTS représente les huit décalage x et y des 
            # huit voisines d'une cellule
            cell = self.get_neighbour(pos, adj)
            if not cell or cell.value > 8 or cell.state in ['show', 'flag']:
                # Out of gameboard (False), mined (10) or is already open
                continue
 
            self.set_visible(cell)            
 
    def get_neighbour(self, pos, offset):
        # On examine chaque voisine, pos est la position (x, y) de la cellule 
        # examinée et offset le décalage de la voisine
        x, y = pos[0] + offset[0], pos[1] + offset[1]
        # self.limits est un tuple contenant les limites exterieures de la 
        # grille, donc ((-1, maximum x +1), (-1, maximum y +1))
        if x in self.limits[0] or y in self.limits[1]:
            # Nous sommes hors limites
            return False
 
        # on retourne la cellule
        return self.squares[y][x]
 
 
    def set_visible(self, cell):
        # cell est la cellule examinée
        if cell.value == 0:
            # La cellule est vide, elle est ajoutée à la pile, en fait tout le
            # mécanise repose sur cette pile
            self.stack.append(cell)
 
        cell.show_value()

Si tu n'utilises pas de classe et que, donc, tes cellules ne sont pas des objets cela ne change rien, tu devras simplement transmettre les coordonnées et état des cellules aux fonctions, mais le principe reste le même.

[Akurasu]

Merci pour ton code et pour les commentaires, j'ai compris son fonctionnement, mais hier soir j'ai trouver une partie de la réponse pour les voisin de la cellule mais le problème c'est que j'arrive pas le lancer , sa m'indique "invalid syntax" mais je vois pas ce qui n'est pas bon dans la syntax. La méthode que j'ai utilisé est-elle bonne?

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
 
def affiche_etat(n,cell):
    for i in range (1,n):
        for j in range (1,n):
            if cell[i][j] == 0:
                print("*",end="")
            elif cell[i][j] == 1:
                print(".",end="")
            else :
                print(" ",end="")
 
def etat_initial(n):
    cell=[]
    for i in range (1,n):
        for j in range (1,n):
            cell.append(0)
        #placer une graine excité au centre du treillis
        if n%2 == 0:
                cell[int(n/2)] = 0
        else:
                cell[int(n/2 + 1)] = 0
 
def etat_suivant(n,A):
    i=0
    j=0
    B = [[0 for j in range(0,n)] for i in range(0,m)]
    B.append(0)
    S=0
    for i in range (1,n):
        for j in range (1,n):
            S=A[x-1][y]+A[x+1][y]+A[x-1][y+1]+A[x-1][y-1]+A[x+1][y+1]+A[x+1][y-1]+[x][y+1]+[x][y-1]
            if S <= 6:
                B[i][j]=0
            if B[i][j] == 0:
                B[i][j]=1
            if B[i][j] == 1:
                B[i][j]=2
 
#programme principal#
n=11
A=etat_initial(n)
affiche_etat(n,A)
for t in range(0,n):
    B=etat_suivant(n,A)
    affiche_etat(n,B)
    A=B

[VinsS]

L'erreur de syntaxe est due au fait que tu lances ton script avec Python 2 alors qu'il est écrit pour Python 3.

Je vois un problème avec ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
def etat_initial(n):
    cell=[]
    for i in range (1,n):
        for j in range (1,n):
            cell.append(0)  # ceci ne produit pas un tableau mais une longue liste
        # Ce qui suit n'est pas correctement indenté
        if n%2 == 0:
                cell[int(n/2)] = 0 # Il y a déjà un 0
        else:
                cell[int(n/2 + 1)] = 0 # Pareil
 
    # Ici la fonction retourne None !

Je pense que ton intention est ceci:

Code :

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

1
2
3
4
5
6
7
8
 
def etat_initial(n):
    cell = [[0] * n for i in range(n)]
    if n%2 == 0:
        cell[int(n/2)][int(n/2)] = 1
    else:
        cell[int(n/2 + 1)][int(n/2) + 1] = 1
    return cell

Si c'est bon on regardera la suite.

Pour les messages d'erreur, il est bien de faire un copier coller, que l'on voie le contexte de l'erreur.

[VinsS]

C'est pareil pour l'affichage:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
def affiche_etat(n,cell):
    for i in range (1,n):
        for j in range (1,n):
            if cell[i][j] == 0:
                print("*",end="")
            elif cell[i][j] == 1:
                print(".",end="")
            else :
                print(" ",end="")

qui donne ça:

Code :

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

1
2
 
*******************************************************.********************************************

de cette façon:

Code :

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

1
2
3
4
5
6
7
 
def affiche_etat(cell):
    symbols = ['*', '.']
    for i in cell:
        for j in i:
            print(symbols[j], end='')
        print()

qui donne ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
***********
***********
***********
***********
***********
***********
******.****
***********
***********
***********
***********

Donc, il faut penser à enlever l'argument n.

[Akurasu]

Merci pour ton code pour l'état initial et affiche état, sa ma enlevé des erreurs lorsque je lancé. J'ai fait un code et apres une aprem a le modifier:
import random

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
 
N = 10
def neighbors_num(grid, x, y):
    count = 0
    for i, j in ((x-1, y), (x, y-1), (x+1, y+1), (x-1, y-1), \
                 (x+1, y), (x, y+1), (x+1, y-1), (x-1, y+1)):
        if grid[int(i%N)][int(j%N)] == 0:
            count += 1
    return count
 
def display(grid):
    for i in range(N):
        for j in range(N):
            if grid[i][j]==0:
                print("*",end="")
            elif grid[i][j]==1:
                print(".",end="")
            else:
                print("=",end="")
        print()
 
def init_state(N):
    grid = [[random.randint(0,2)] * N for i in range(N)]
    grid.append(random.randint(0,1))
    if N%2 == 0:
        grid[int(N/2)][int(N/2)] = 1
    else:
        grid[int(N/2 + 1)][int(N/2) + 1] = 1
    return grid
    grid[0]=grid[N]
    grid[N+1]=grid[1]
 
 
def next_grid(grid,N):
    new_grid=grid
    for i in range(N):
        for j in range(N):
            count = neighbors_num(grid, i, j)
            if grid[i][j] == 0:
                new_grid[i][j] = 1
            elif grid[i][j] == 1:
                new_grid[i][j] = 2
            elif grid[i][j] == 2 and count == 2:
                new_grid[i][j] = 0
    grid[:] = new_grid
    return new_grid
#condition aux bords#
    grid[0]=grid[N]
    grid[N+1]=grid[1]
 
#programme#
N=11
A=init_state(N)
print (A)
display(A)
for t in range(1,6):
    B= next_grid(A,N)
    print("étape n°",t)
    display(B)

ce qui me donne comme resultat:

...........
===========
===========
***********
***********
***********
======.====
***********
===========
***********
***********
étape n° 1
===========
===========
===========
...........
...........
...........
===========
...........
===========
...........
...........
étape n° 2
===========
===========
===========
===========
===========
===========
===========
===========
===========
===========
===========
étape n° 3
===========
===========
===========
===========
===========
===========
===========
===========
===========
===========
===========
étape n° 4
===========
===========
===========
===========
===========
===========
===========
===========
===========
===========
===========
étape n° 5
===========
===========
===========
===========
===========
===========
===========
===========
===========
===========

J'arrive a afficher un debut du jeu de la vie mais sa finie toujours par avoir que des cellules morte, j'ai reussit a faire remplit ma grille de façon aléatoire entre 0 et 2 mais sa le fait que pour les ligne vertical et pas horizontal, je sait pas comment faire. J'ai essayer de mettre les condition aux bors mais je sais pas si c'est bon.

[VinsS]

Ben ça a l'air de fonctionner.

Les conditions de départ sont probablement la cause du résultat. Si tu veux placer plus de cellules activées au départ de façon aléatoire, le module random est là pour ça.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
def get_values(n):
    values = set([])
    while len(values) < 20: # Teste avec d'autres valeurs que 20
        x = random.randrange(n)
        y = random.randrange(n)
        values.add((x, y))
 
    return values
 
>>> {(7, 3), (10, 5), (6, 8), (10, 8), (3, 0), (6, 6), (3, 2), (8, 2), (2, 10), (4, 8), (2, 0), (6, 2), (1, 6), (8, 7), (0, 4), (3, 3), (8, 9), (4, 1), (1, 1), (8, 4)}