# Q1 : Changer ici par votre Prenom/Nom groupe:
prenom = "Joseph" # à remplacer
nom = "Salmon" # à remplacer
extension = ".ipynb"
tp = "TP_note_HMLA310_group"
group = "A"
# Q2:
# Q3:
ma_graine = # à remplir
print(ma_graine)
Le jeu de la vie est un automate cellulaire mis au point par le mathématicien britannique John Horton Conway en 1970. Il constitue l'exemple le plus connu d'un automate cellulaire. Le "jeu" est en fait un jeu à zéro joueur, ce qui signifie que son évolution est déterminée par son état initial et ne nécessite aucune intervention de la part de joueurs. On interagit avec le jeu de la vie en créant une configuration initiale; il ne reste plus alors qu'à observer son évolution.
L'univers du jeu de la vie est une grille orthogonale bidimensionnelle infinie (dans la suite on la supposera finie pour éviter toute difficulté) de cellules carrées, chacune d'entre elles se trouvant dans l'un des deux états possibles:
Chaque cellule interagit avec ses huit voisins, qui sont les cellules directement adjacentes horizontalement, verticalement ou en diagonale. A chaque pas dans le temps, les transitions suivantes se produisent:
Le modèle initial constitue la "graine" du système. La première génération est créée en appliquant les règles ci-dessus simultanément à chaque cellule de la graine - les naissances et les décès se produisent simultanément, et le moment discret auquel cela se produit est parfois appelé une tique. (En d'autres termes, chaque génération est une fonction pure de la précédente.) Les règles continuent d'être appliquées de manière répétée pour créer d'autres générations.
Plus de détails pour les curieux: https://fr.wikipedia.org/wiki/Jeu_de_la_vie
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
import time
import matplotlib.animation as animation
from IPython.display import HTML
plt.set_cmap("gray_r")
# Q4
def calcul_nb_voisins(Z):
forme = len(Z), len(Z[0])
N = [[0, ] * (forme[0]) for i in range(forme[1])]
for x in range(1, forme[0] - 1):
for y in range(1, forme[1] - 1):
N[x][y] = Z[x-1][y-1]+Z[x][y-1]+Z[x+1][y-1] \
+ Z[x-1][y] + +Z[x+1][y] \
+ Z[x-1][y+1]+Z[x][y+1]+Z[x+1][y+1]
return N
Z = [[0,0,0,0,0,0],
[0,0,0,1,0,0],
[0,1,0,1,0,0],
[0,0,1,1,0,0],
[0,0,0,0,0,0],
[0,0,0,0,0,0]]
def iteration_jeu(Z):
forme = len(Z), len(Z[0])
N = calcul_nb_voisins(Z)
for x in range(1,forme[0]-1):
for y in range(1,forme[1]-1):
if Z[x][y] == 1 and (N[x][y] < 2 or N[x][y] > 3):
Z[x][y] = 0
elif Z[x][y] == 0 and N[x][y] == 3:
Z[x][y] = 1
return Z
# Q5
Rem: se rappeler que l'on utilise une bordure de largeur unitaire, qui vaut tout le temps zero tout autour de la carte.
# Q6:
# Q7
vect = np.array([0,1,0,0,1,1])
# Q8
def calcul_nb_voisins_np(Z_np):
N_np = np.zeros(Z_np.shape)
N_np[1:-1, 1:-1] += # à remplir avec les 8 valeurs utiles
return N_np
# Q9
def iteration_jeu_np(Z_np):
# à remplir
return Z_out
# Q10
def jeu_np(mat_in,nb_iter):
# à remplir
return mat_out
# Q11
%matplotlib notebook
fig_film1 = plt.figure()
#Q12
# Q13
# Q14 Bonus: Pac man version.