Hey!

Je dois faire un jeu de la vie(http://fr.wikipedia.org/wiki/Jeu_de_la_vie) pour la fac et j'ai un souci que je n'arrive pas à expliquer.

En effet, sachant que mon premier tableau de booléens représentant les cellules (tableau d'int 0 et 1 en fait, mais je chipote pas)donne "naissance" correctement à un second tableau, logiquement issu du premier en suivant les règles du jeu de la vie, je ne comprends pas pourquoi il n'en est pas de même quand je passe du tableau 2 au tableau 3.
En gros :
tableau 1-->tableau 2 : correct et logique
tableau 2-->tableau 3 : Echec

L'erreur ne se situe donc à priori ni dans la fonction qui permet de passer d'un tableau à un autre, sans quoi je n'aurais pas un bon tableau 2; ni dans le tableau 2, source du tableau 3.

Voici le code :
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
# -*- coding: cp1252 -*-
import numpy as N
import math as M
from pylab import *
from random import randrange
 
#fonction qui permet de savoir si un indice est dans le tableau
def Inb(IND, dim):
        return ((IND>=0)and(IND<dim))
#Fonction qui 'convertit' une valeur du tableau en booleen
def BOL(tab, i, j):
        if (tab[i, j]==1):
                return True
        else:
                return False
 
#fonction qui calcule le nombre de cellules autour d'une cellule donnee.
def Somme(tab, i, j):
        Som=0
        dim=4
        ##On verifie tout au long de la fonction qu'on "regarde" bien dans le tableau
        ##et pas en dehors. La fonction agit comme si l'exterieur du tableau ne 
        ##contenait que des zeros.
        Bi=N.arange(i-1, i+2, 1)
        Bj=N.arange(j-1, j+2, 1)
 
        for I in Bi:
                for J in Bj:
                        if((Inb(I, dim))and(Inb(J, dim))and(BOL(tab, I, J))):
                            Som+=1
 
        if(BOL(tab, i, j)) :
                Som-=1
        return Som
 
##On cree un tableau de booleens 4x4
dim=4
a=N.zeros((dim,dim), dtype=int)
 
b=N.arange(0, dim, 1)
 
##Je me sers des trois methodes suivantes pour creer le tableau initial
##et le tester.
 
##Creation aleatoire du tableau carre de booleens
 
##for i in b:
##	for j in b:
##		if (round(N.random.random(1)*100))>100:
##			a[i][j]=0
##		else:
##			a[i][j]=1
 
## Creation aleatoire avec choix du nombre de cellules initial.
##Nbcel=input('Nbcel?\n')
##IND=0
##while IND<Nbcel:
##
##        i=randrange(0, dim)
##        j=randrange(0, dim)
##        a[i][j]=1
##        IND+=1
 
##Creation specifique de cellules dans le tableau initial.
 
a[0][0]=1        
a[0][1]=1
a[0][2]=1
a[2][1]=1
a[3][1]=1
a[2][2]=1
a[1][3]=1
 
 
print ("Tableau de cellules initial:\n")
print a
print
 
 
 
c=N.zeros((dim, dim), dtype=int)
SOMME=N.zeros((dim, dim), dtype=int)
 
#Fonction qui effectue un tour, ou cycle de vie
 
def tour(A):
 
        for i in b:
                for j in b:
 
                        ##La ligne suivante ne sers qu'a pouvoir afficher
                        ##si besoin est un tableau representant pour chaque
                        ##case la somme du nombre de cellules avoisinantes.
 
                        SOMME[i][j]=Somme(A, i, j)
 
                        ##Si la case ne contient pas de cellule...
                        if (A[i][j]==0):
                                ##Et qu'il y a exactement 3 cellules autour
                                if(Somme(A, i, j)==3):
                                        ##Alors une cellule sera cree a cet
                                        ##endroit dans le tableau representant
                                        ##le cycle suivant
                                        c[i][j]=1
                                ##Sinon, si il n'y a pas 3 cellules autour:
                                else:
                                        c[i][j]=0
 
                        ##Sinon, si la case contient une cellule...                
                        else:
                                ##et qu'il n'y a ni 2 ni 3 cellules autour...
                                if ((Somme(A, i, j)!=2)and(Somme(A, i, j)!=3)):
                                        ##Alors la cellule mourra.
                                        c[i][j]=0
                                ##Sinon, elle reste en vie.
                                else:
                                        c[i][j]=1
 
        return c                                
 
#debut du premier tour
Nbiter=input("Nombre d'iterations?\n")
iter=0
c=tour(a)
##La boucle tournera autant de fois qu'il y a d'iterations
while iter<Nbiter:
        ##On affiche d'abord c, donc tour(a)
        print c
        print
        print ("SOMME:")
        print SOMME
        print
        ##Puis on stocke tour(c), soit tour(tour(a)) dans c pour le prochain cycle.
        c=tour(c)
 
        iter+=1
 
##DEBUG : Tour 1 parfait, tour 2 mauvais. Boucle correcte normalement.