Jeu de la vie

Le Jeu de la vie (ou Game of Life) est un automate cellulaire inventé par le mathématicien britannique John Horton Conway en 1970. C'est un modèle mathématique qui simule l'évolution de cellules sur une grille en fonction de règles simples. Chaque cellule peut être vivante ou morte, et son état évolue à chaque génération selon le nombre de voisins vivants. Pour plus de détails, vous pouvez consulter la page Wikipedia du Jeu de la vie.

Une cellule qui a 3 voisins peut naitre, ou rester en vie.

Une cellule qui a 2 voisins reste dans le mĂŞme Ă©tat (morte ou vivante).

Dans les autres acs, la cellule meurt.

Le code permet d'insctancier des populations aléatoire et une population avec 7 cellules en U pour obsever l'apparition du clown.

Code à compléter

Python
 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
73
74
75
76
77
78
79
80
81
import random

DIM = 70

# Création du u
pop_u = [False] * (DIM ** 2)
pop_u[2485] = pop_u[2487] = True
pop_u[2555] = pop_u[2557] =True
pop_u[2625] = pop_u[2626] = pop_u[2627] = True

class Cell:
    def __init__(self, life = True):
        self.life = ...

    def status(self):
        '''Retourne True si la cellules est en vie, False sinon'''
        return ...

    def kill(self):
        '''tue la cellule'''
        ...

    def alive(self):
        ...

    def __str__(self):
        '''* si la cellule vit, sinon un espace''' 
        ...

class Population:
    def __init__(self, status=[]):
        self.cells = []
        for i in range(DIM * DIM):
            life = random.choice([True,False,False]) if i >= len(status) else status[i]
            # ajout d'une cellule instanciée à la liste cells
            self.cells.append()

    def neighbours(self, i: int):
        ''' Retourne le nombre de voisins'''
        deltas = [ (l,c) for l in [-1,0,1] for c in [-1,0,1] if abs(l) or abs(c)]
        count = 0
        for ...:
            ...
        return count

    def evolution(self):
        to_kill = [] # indice des cellules Ă  tuer
        to_alive = [] # indice des cellule a naitre
        for i in range(len(self.cells)):
            if self...:
                ...
            elif self.neighbours(i) < 2 or self.neighbours(i) > 3:
                ...
        for i in to_kill:
            ...
        for i in to_alive:
            ...


    def __str__(self):
        str = ""
        for line in range(DIM):
            for col in range(DIM):
                str += self.cells[line * DIM + col].__str__()
            str += "\n"
        return str


# lors du lancement du script Python
if __name__ == "__main__":
    # instanciation de la population
    pop = Population(pop_u)
    print(pop)
    c = input("taper sur une touche, q pour quitter")
    i = 1
    while c  != "q":
        print(f"Génération {i}")
        i += 1
        pop.evolution()
        print(pop)
        c = input("taper sur une touche, q pour quitter")

Cette implémentation crée un jeu de la vie avec une grille de cellules, où chaque cellule évolue selon les règles définies. La méthode __str__ permet d'afficher la grille de manière lisible, et la méthode evolution applique les règles de vie à chaque cellule.

code corrigé