Lycée Stanislas MPSI - PCSI

Informatique Tronc Commun Anné 2022-2023 evolte@stanislas-cannes.com

DM : jeu de la vie
Devoir à rendre au plus tard le mardi de la rentrée, à l’adresse :
PCSI : https://urlz.fr/jwe6
MPSI : https://urlz.fr/jweT
Mot de passe : jeudelavie

1 Description
Le jeu de la vie (Game of Life) est un modélisation très simple permettant de faire appa-
raître des phénomènes assez complexes proposée par James Conway en 1970.
Le jeu se déroule sur une grille à deux dimensions, théoriquement infinie, dont les cases
sont appelées “cellules”. Chaque cellule peut être dans deux états : “vivante” ou “morte”.
A chaque étape de temps n, l’état de chaque cellule c ne dépend que de son état et de celui
des cellules voisines à l’étape de temps n − 1.

1 2 3
4 c 5
6 7 8

Pour savoir si c sera vivante à l’instant n, on compte le nombre de cellules vivantes parmi
les 8 voisins de cette cellule à l’instant n − 1 (on ne compte pas la cellule elle-même dans ses
voisins).
— si ce nombre est inférieur ou égal à 1, ou supérieur ou égal à 4, alors la cellule sera
morte à l’instant n
— si ce nombre est égal à 3, alors la cellule sera vivante à l’instant n.
— si ce nombre est égal à 2, alors la cellule ne change pas d’état : elle reste vivante si elle
l’était à l’intant n − 1, et elle reste morte si elle l’était déjà.

2 Implémentation
Pour implémenter un jeu de la vie, on fixera un entier n et on travaillera sur un plateau
fini de taille n × n. Cet entier n pourra être affecté en début de programme, et ainsi accessible
dans toutes les fonctions. On pourra d’abord fixer n = 10.
Le plateau sera codé par une liste de listes d’entiers (soit une liste à deux dimensions)
en python, appelée grille . Les cellules vivantes seront codées par la valeur 1, les cellules
mortes par la valeur 0.
Par exemple, pour n = 5, on pourra avoir la grille

[[0,1,1,0,1],
[1,0,1,0,0],
[0,0,1,0,0],
[0,1,0,0,1],
[1,0,1,1,0]]
Lycée Stanislas MPSI - PCSI
Informatique Tronc Commun Anné 2022-2023 evolte@stanislas-cannes.com

Ici grille[0][2] est égal à 1, donc la cellule de coordonnées (0, 2) est vivante. Par contre,
(2, 3) est morte.
On codera successivement :
1. Une fonction creation_grille_vide() -> list .
qui retournera une grille (une liste à deux dimensions de taille n × n) contenant des
zéros.
2. Une fonction affiche_grille(grille: list) -> None qui prendra une grille
en paramètres et réalisera un affichage de cette grille en terminal, tel que les cellules
vivantes seront représentées par des o et les cellules mortes par des -.
Ainsi, la grille précédente donnée pour n = 5 sera représentée par le dessin
-oo-o
o-o--
--o--
-o--o
o-oo-
3. Une fonction initialisation_aleatoire(grille: list) -> None qui prend une
liste d’entiers à deux dimensions de taille n × n et affecte dans chaque case une valeur
aléatoire choisie parmi 0 et 1 équiprobablement.
On pourra utiliser la fonction random.randint(0,1) qui retourne 0 ou 1 équiproba-
blement, après avoir importé le module random par la commande import random en
début de fichier.
4. Une fonction une_etape(grille: list) -> list
qui prend une grille et retourne une nouvelle grille correspondant à l’état du plateau
une étape de temps plus tard.
Cette fonction pourra créer une nouvelle grille avec la fonction creation_grille_vide ,
puis parcourir chaque case de la grille, compter le nombre de voisins pour déterminer
la valeur de la cellule dans la nouvelle grille.
1Attention à ne pas sortir du tableau lors de la visite des voisins !
5. Enfin une procédure jeu_de_la_vie() sans arguments qui utilisera les fonctions pré-
cédentes pour
• initialiser une grille vide,
• la remplir de valeurs aléatoires,
• lancer en boucle infinie la simulation du jeu de la vie ; à chaque itération de la
boucle, on calcule la nouvelle grille une étape de temps plus tard puis on l’affiche.
Il est vivement conseillé de tester chaque fonction avant de passer à la suivante. À chaque
stade, il est possible de tester les fonctions déjà codées, et recommandé de ne pas passer à la
suite tant qu’elles ne marchent pas convenablement.

3 Où les tris peuvent être utiles.

1. Ecrire une fonction entier(grille: list) -> int qui renvoie l’entier dont l’écriture
binaire correspond, de la gauche vers la droite puis de bas en haut à la grille.
Par exemple, pour la grille proposée avec n = 5, on doit trouver l’entier 14291254.
Lycée Stanislas MPSI - PCSI
Informatique Tronc Commun Anné 2022-2023 evolte@stanislas-cannes.com

2. On rappelle la fonction insere(L, x) qui rajoute l’élément x à la liste L qui est

déjà triée, en le faisant glisser, pas à pas, jusqu’à la bonne place. Cette fonction modifie
L par effet de bord mais ne renvoie rien.

def insere (L, x):

L. append (x)
n = len(L)
i = n - 1
while i > 0 and L[i -1] > L[i]:
L[i -1] , L[i] = L[i], L[i -1]
i = i - 1

Modifier cette fonction pour qu’elle renvoie un booléen suivant que x est déjà présent
dans la liste L ( True renvoyé) ou non ( False renvoyé). On ne peut pas utiliser la
commande x in L .
1. Ecrire une fonction jeu_de_la_vie1() semblable à la précedente mais avec une boucle
qui s’arrête à la première répétition de position.

4 Affichage graphique (facultatif, mais ça vaut le coup)

Pour passer à un affichage en fenêtre, on pourra utiliser le module pyplot , sous-module de
matplotlib , avec la commande (en début de fichier) from matplotlib import pyplot as plt
1 matplotlib n’est pas dans la distribution miniconda de base. Elle fait partie de la
distribution anaconda 1
Écrire une fonction jeu_de_la_vie2() ressemblant à la première fonction mais qui com-
porte les modifications suivantes :
Après avoir initialisé la grille (et avant la boucle de la simulation) on pourra lancer l’affi-
chage par la commande
fenetre=plt.imshow(grille)
fenetre est alors un objet graphique, qui traite la grille comme une image, chaque case
étant un pixel. Par défaut, ce module attribue une couleur à chaque nombre (rouge pour 1,
bleu pour 0).
Ensuite, dans la boucle, on peut remplacer l’affichage en terminal par la fonction affiche
par la commande
fenetre . set_data ( grille )
pyplot . pause (0.100)

qui rafraîchit le contenu de l’objet fenetre avec la nouvelle valeur de la grille. La com-
mande plt.pause remplace time.sleep , incompatible avec l’affichage graphique.
Cette solution graphique devrait permettre d’augmenter la taille de la grille (n = 100,
n = 200...)

1. Le module peut être installé individuellement, voir http://matplotlib.org/users/installing.html