Discussion :

[Skogou]

Bonjour à tous,

Je me permets de poster ici, je pense avoir plus de chances d'être vue, que sur la forum d'aide au nouveaux :

Dans le cadre de ma première année en biologie, nous suivons des cours d'algorithme, et de code.
Par code, c'est très simplifié, nous utilisons Algoscript (http://www.algoscript.info), un Javascript simplifié, et francisé de ce que j'ai compris.

J'ai un projet à rendre pour dimanche, je bloque sur de nombreux points, pourriez-vous m'orienter, me débloquer ? Malgré mes demandes cordiales, ma professeur n'a pas voulu nous aider, arguant qu'elle n'est pas en charge des projets.. bon !
Je fais appel à votre générosité, en espérant que le projet soit assez facile, basique, pour qu'il ne vous prenne pas trop de temps à comprendre (ce dont je ne doute pas).

Sujet : Le jeu de la vie

Le principe du jeu de la vie a été introduit par John H. Conway en 1970. Ce "jeu" a donné naissance plus tard à toute une théorie mathématique dite des automates cellulaires. Ce jeu a trouvé des applications dans l'étude de quelques modes de développement de populations. Malgré des règles simples de reproduction et de décès, le mimétisme avec des processus "réels" est frappant.

Grossièrement, le jeu de la vie se compose d'une grille sur laquelle évolue des cellules.
Chaque point de la grille peut-être occupé par au plus une cellule. À chaque étape du jeu, des cellules peuvent apparaître ou disparaître selon la règle suivante :

- si une case vide est entourée d'exactement trois cases pleines, alors une cellule nait dans cette case à la génération suivante;
- si une cellule vivante est entourée de deux ou trois cellules vivantes alors elle le reste, sinon elle meurt.

1) Comment représenter une génération du jeu. Ok

2) Écrire la fonction AppliquerRegle(génération) qui calcule une génération en fonction de la précédente. Pas encore au point

3) Écrire une fonction JoliAffichageLettres(génération) qui retourne une chaîne de caractères où tous les 0 de génération sont remplacés par des espaces et tous les 1 par des 'X'. Pas de soucis particulier, je vais m'en occuper
4) Améliorez deux choses à ce programme : ajoutez une création de génération aléatoire (de longueur saisie par l'utilisateur) - Là ça coince - et un affichage dans l'interface graphique des différentes générations - Ok

Je vous laisse regarder mon code avant, vous pouvez le c/c sur le lien algoscript plus haut, faire dérouler le menu déroulant (Code JS, jusqu'à Graphic Output) puis le lancer, chaque clique calcule une génération.
J'ai donc deux points où je bloque :

Question 2 :

J'ai crée un tableau "2D" où je stocke mes données (1 = une cellule, 0 = pas de cellule). La première génération est générée aléatoirement, pas de soucis.
Le problème survient lors du calcul de toutes les autres générations et tient à pas grand chose :

La génération suivante n'est pas calculée en fonction de la génération précédente, mais en fonction de la génération en cours. J'ai beaucoup de mal à expliquer..

Hum.. chaque cellule a des coordonnées en x,y. Le code commence à calculer les cellules pour x= 1 à 13 et y = 1 par exemple. Du coup la suite est biaisée, car il calcule les cellules pour x = 1 à 13 et y = 2 en fonction non pas de la génération 1, mais de ce qu'il a déjà calculé (génération 2) + de la génération 1 qu'il n'a pas encore calculé.
En lançant le "graphic output" on se rend compte très bien que les cellules ne suivent pas correctement les règles énoncées.

J'ai pensé à créer un second tableau où stocker la génération précédente, afin qu'il calcule en fonction du second tableau, et qu'il attribue au premier. Mais le résultat est le même...
Des idées ?

Question 4-1 :

La création de génération aléatoire de longueur saisie par l'utilisateur me pose grand soucis. Cependant cela devrait être simple pour vous :
Je suis obligé de créer un tableau de base, de longueur saisie, remplie.
Comment puis-je arriver à créer un "tableau 2D" de longueur choisie, préremplie avec des 0, afin que je puisse attribuer par la suite un 0 ou un 1 aléatoirement ?

C'est un pavé, je m'en excuse, j'ai essayé d'être le plus concis.

Je vous remercie grandement d'avance,

Je joints une petite feuille explicative, enfin de mes recherches, un peu brouillon, mais cela permet de comprendre le code plus rapidement :
Et maintenant le code (j'espère que vous ne hurlerez pas au massacre haha) :

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
// Population
var v, h, x, y;
 
h = 25; // Var qui sert à rien pour l'instant
tour = 1; 
generation = 0;
 
 
do {
  h = h + 25;
  RectanglePlein(h, 25, 1, 125, 'black'); //  Que de l'esthétique, pour mettre une grille par la suite
} while (h != 125);
 
v = 25;
do {
  v = v + 25;
  RectanglePlein(25, v, 125, 1, 'black'); // De même, pas d’importance pour l’instant
} while (v != 125);
 
var T = [      // Var T -> le tableau dans lequel on stocke les coordonnées des cellules
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // Cette ligne : y = 0 et x compris entre 0 et 13
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] // cette ligne : y = 13 et x compris entre 0 et 13
//x=0 1  2  3  4  5  6  7  8  9  10 11 12 13
];
 
for (x = 0; x < 14; x = x + 1) { // Pour x allant de 0 à 13 et x toujours < 14
  for (y = 0; y < 14; y = y + 1) { // pour y allant de 0 à 13 et y toujours < 14
    T[y][x] = Hasard(2); // On donne à chaque 0 du tableau soit 0, soit 1 par hasard pour la première génération
    T[0][x] = 0; // 4 lignes suivantes très importantes -> il faut que chaque extrémité reste tout le temps = à 0, cf + bas **
    T[13][x] = 0;
    T[y][0] = 0; 
    T[y][13]=0;
 
    if (T[y][x] == 1) { // Si un point de la coordonnée y,x = 1 (1 veut dire qu'il y a une cellule , 0 -> case vide)
      CerclePlein(y * 20 + 20, x * 20 + 20, 10, 'red'); // Cellules sont rouges - pour première génération
    } else {
      CerclePlein(y * 20 + 20, x * 20 + 20, 10, 'black'); // cases vides sont noires - pour première génération
    }
  }
}
 
function MouseClick(x, y) { // Très important, permet à chaque clique de calculer une nouvelle génération, moyen le plus simple trouvé pour calculer plusieurs générations. 1 clique = génération + 1. Une autre idée ?
  for (x = 0; x < 14; x = x + 1) { // Même chose que là-haut, on affecte à une cellule du rouge, à une case vide du noir, mais pour génération + 1
    for (y = 0; y < 14; y = y + 1) { 
      if (T[y][x] == 1) {
        CerclePlein(y * 20 + 20, x * 20 + 20, 10, 'red');
      } else {
        CerclePlein(y * 20 + 20, x * 20 + 20, 10, 'black');
      }
    }
  }
 
  for (y = 1; y <= 13; y = y + 1) { // 0 < y < 14 car comme dit, il ne faut pas calculer pour les extrémités
    for (x = 1; x <= 13; x = x + 1) { // pareil pour x
      if (T[y][x] == 0) {
        if ((T[y - 1][x] == 1) && (T[y][x + 1] == 1) && (T[y + 1][x]) == 1) { // ** voilà ici plus bas, on calcule par rapport à cellule case haut, case droite, case bas - cf scan
          T[y][x] = 1;
          CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'red'); // scan -> jaune
        } else {
          if ((T[y - 1][x] == 1) && (T[y][x - 1] == 1) && (T[y][x + 1] == 1)) { // cf scan
            T[y][x] = 1;
            CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'red'); // scan -> marron
          } else {
            if ((T[y - 1][x] == 1) && (T[y][x - 1] == 1) && (T[y + 1][x] == 1)) { // cf scan
              T[y][x] = 1;
              CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'red'); // scan -> noir
            } else {
              if ((T[y][x - 1] == 1) && (T[y + 1][x] == 1) && (T[y][x + 1] == 1)) { // cf scan
                T[y][x] = 1;
                CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'red'); // scan -> rose 
              }
            }
          }
        }
      } else {
        if (T[y][x] == 1) {
          if ((T[y][x - 1] + T[y - 1][x] + T[y + 1][x] + T[y][x + 1]) == 3) {// Si une cellule vivante est entourée de 3 cellules, elle le reste (Txy = 1)
            T[y][x] = 1;
            RectanglePlein(x * 20 + 20, y * 20 + 20 + 7, 7, 'red'); 
 
          } else {
            if ((T[y][x - 1] + T[y - 1][x] + T[y + 1][x] + T[y][x + 1]) == 2) { // Si une cellule vivante est entourée de 2 cellules, elle le reste (Txy = 1)
              T[y][x] = 1;
              RectanglePlein(x * 20 + 20, y * 20 + 20 + 7, 7, 'red');
            } else { // si aucun de ces deux cas -> cellule entourée de 0,1 ou 4 cellules, elle meurt -> tyx = 0
              T[y][x] = 0;
              CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'black');
            }
          }
        }
      }
    }
  }
}
 
 
 
 
 
 
 
 
// 4 lignes suivantes cf scan ac quadrillage partie droite
// ROSE (T[y][x-1])
// ROUGE (T[y-1][x])
// ORANGE (T[y+1][x])
// VERT (T[y][x+1])

[mathieu]

J'ai déjà modifié un peu votre code pour mieux afficher la grille pour que ça soit plus clair.

En ce qui concerne la génération de l'étape suivante, je pense aussi qu'il faille calculer les valeur dans un tableau temporaire et ensuite remplacer T par ce tableau temporaire. quand vous avez fait cela, vous avez bien régénéré tous l'affichage avec les nouvelles valeurs ?

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
// Population
var v, h, x, y;
 
 
tour = 1; 
generation = 0;
 
h = -11;
do {
  h = h + 20;
  RectanglePlein(h, 9, 1, 20 * 14, 'black'); //  Que de l'esthétique, pour mettre une grille par la suite
} while (h < 20 * 14);
 
v = -11;
do {
  v = v + 20;
  RectanglePlein(9, v, 20 * 14, 1, 'black'); // De même, pas d’importance pour l’instant
} while (v < 20 * 14);
 
var T = [      // Var T -> le tableau dans lequel on stocke les coordonnées des cellules
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], // Cette ligne : y = 0 et x compris entre 0 et 13
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] // cette ligne : y = 13 et x compris entre 0 et 13
//x=0 1  2  3  4  5  6  7  8  9  10 11 12 13
];
 
// quelques valeurs
T[6][1] = 1;
T[6][3] = 1;
T[6][4] = 1;
T[7][3] = 1;
T[7][4] = 1;
T[7][5] = 1;
 
 
for (x = 0; x < 14; x = x + 1) { // Pour x allant de 0 à 13 et x toujours < 14
  for (y = 0; y < 14; y = y + 1) { // pour y allant de 0 à 13 et y toujours < 14
    //T[y][x] = Hasard(2); // On donne à chaque 0 du tableau soit 0, soit 1 par hasard pour la première génération
    T[0][x] = 0; // 4 lignes suivantes très importantes -> il faut que chaque extrémité reste tout le temps = à 0, cf + bas **
    T[13][x] = 0;
    T[y][0] = 0; 
    T[y][13]=0;
 
    if (T[y][x] == 1) { // Si un point de la coordonnée y,x = 1 (1 veut dire qu'il y a une cellule , 0 -> case vide)
      CerclePlein(y * 20 + 20, x * 20 + 20, 10, 'red'); // Cellules sont rouges - pour première génération
    } else {
      CerclePlein(y * 20 + 20, x * 20 + 20, 10, 'black'); // cases vides sont noires - pour première génération
    }
  }
}
 
function MouseClick(x, y) { // Très important, permet à chaque clique de calculer une nouvelle génération, moyen le plus simple trouvé pour calculer plusieurs générations. 1 clique = génération + 1. Une autre idée ?
  for (x = 0; x < 14; x = x + 1) { // Même chose que là-haut, on affecte à une cellule du rouge, à une case vide du noir, mais pour génération + 1
    for (y = 0; y < 14; y = y + 1) { 
      if (T[y][x] == 1) {
        CerclePlein(y * 20 + 20, x * 20 + 20, 10, 'red');
      } else {
        CerclePlein(y * 20 + 20, x * 20 + 20, 10, 'black');
      }
    }
  }
 
  for (y = 1; y <= 13; y = y + 1) { // 0 < y < 14 car comme dit, il ne faut pas calculer pour les extrémités
    for (x = 1; x <= 13; x = x + 1) { // pareil pour x
      if (T[y][x] == 0) {
        if ((T[y - 1][x] == 1) && (T[y][x + 1] == 1) && (T[y + 1][x]) == 1) { // ** voilà ici plus bas, on calcule par rapport à cellule case haut, case droite, case bas - cf scan
          T[y][x] = 1;
          CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'red'); // scan -> jaune
        } else {
          if ((T[y - 1][x] == 1) && (T[y][x - 1] == 1) && (T[y][x + 1] == 1)) { // cf scan
            T[y][x] = 1;
            CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'red'); // scan -> marron
          } else {
            if ((T[y - 1][x] == 1) && (T[y][x - 1] == 1) && (T[y + 1][x] == 1)) { // cf scan
              T[y][x] = 1;
              CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'red'); // scan -> noir
            } else {
              if ((T[y][x - 1] == 1) && (T[y + 1][x] == 1) && (T[y][x + 1] == 1)) { // cf scan
                T[y][x] = 1;
                CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'red'); // scan -> rose 
              }
            }
          }
        }
      } else {
        if (T[y][x] == 1) {
          if ((T[y][x - 1] + T[y - 1][x] + T[y + 1][x] + T[y][x + 1]) == 3) {// Si une cellule vivante est entourée de 3 cellules, elle le reste (Txy = 1)
            T[y][x] = 1;
            RectanglePlein(x * 20 + 20, y * 20 + 20 + 7, 7, 'red'); 
 
          } else {
            if ((T[y][x - 1] + T[y - 1][x] + T[y + 1][x] + T[y][x + 1]) == 2) { // Si une cellule vivante est entourée de 2 cellules, elle le reste (Txy = 1)
              T[y][x] = 1;
              RectanglePlein(x * 20 + 20, y * 20 + 20 + 7, 7, 'red');
            } else { // si aucun de ces deux cas -> cellule entourée de 0,1 ou 4 cellules, elle meurt -> tyx = 0
              T[y][x] = 0;
              CerclePlein(x * 20 + 20, y * 20 + 20, 10, 'black');
            }
          }
        }
      }
    }
  }
}
 
 
 
// 4 lignes suivantes cf scan ac quadrillage partie droite
// ROSE (T[y][x-1])
// ROUGE (T[y-1][x])
// ORANGE (T[y+1][x])
// VERT (T[y][x+1])

[Chatanga]

Un tel message n'a pas sa place ici (il ne s'agit pas d'une question sur le forum même) et devrait plutôt être dans ce coin. Ceci étant posé, je m'en fous un peu. Pour une fois que je vois une demande d'aide honnête, bien rédigée où l'auteure s'est tiré les doigts du cul, j'en pleurerais presque. On est loin des torchons du type https://www.developpez.net/forums/d1...l/#post9809356.

Jetons maintenant un œil aux obstacles que tu rencontres.

Question 2 :

Ton idée d'utiliser 2 tableau est la bonne, soit en jongleant entre les deux, soit en utilisant une copie. Il n'y a pas de raison que ça ne fonctionne pas (cf. plus bas).

Question 4-1 :

Comment puis-je arriver à créer un "tableau 2D" de longueur choisie, préremplie avec des 0, afin que je puisse attribuer par la suite un 0 ou un 1 aléatoirement ?

En jetant un œil à l'onglet Memento et en particulier aux fonctions Tableau et InitialiserTableau. RTFM comme dirait feue ma grand-mère australienne.

C'est un pavé, je m'en excuse, j'ai essayé d'être le plus concis.

Si l'alternative est un télégramme truffés de fautes d'orthographe, alors non, ne change rien. D'ailleurs, comme c'est bientôt Noël, je t'offre en cadeau un léger refactoring de ton code. Ça n'en change pas la logique, mais le rend plus lisible. La soupe de if / else pourrait encore être grandement améliorée, notamment en généralisant le remplacement des ET logiques par des additions (le fait que ne soit fait qu'à moitié est curieux au demeurant).

Code Javascript :

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
function MouseClick(x, y) { // Très important, permet à chaque clique de calculer une nouvelle génération, moyen le plus simple trouvé pour calculer plusieurs générations. 1 clique = génération + 1. Une autre idée ?
  for (x = 0; x < 14; x = x + 1) { // Même chose que là-haut, on affecte à une cellule du rouge, à une case vide du noir, mais pour génération + 1
    for (y = 0; y < 14; y = y + 1) {
      var couleur;
      if (T[y][x] == 1) {
        couleur = 'red';
      } else {
        couleur = 'black';
      }
      //CerclePlein(y * 20 + 20, x * 20 + 20, 10, couleur);
    }
  }
  nouvelleGeneration(T);
  tour = tour + 1;
}
 
function nouvelleGeneration(grille) {
  var copieGrille = Tableau(14, 14);
  for (x = 0; x < 14; x = x + 1) {
    for (y = 0; y < 14; y = y + 1) {
      copieGrille[y][x] = grille[y][x];
    }
  }
 
  // Note : le code original utilisait une comparaison erronée ('<='ou lieu de '<').
  for (y = 1; y < 13; y = y + 1) { // 0 < y < 14 car comme dit, il ne faut pas calculer pour les extrémités => 
    for (x = 1; x < 13; x = x + 1) { // pareil pour x
      couleur = conway(copieGrille, x, y);
      grille[y][x] = couleur != "black";
      CerclePlein(x * 20 + 20, y * 20 + 20, 10, couleur);
    }
  }
}
 
function conway(grille, x, y) {
/*
   |n|
  -+-+-
  w|.|e
  -+-+-
   |s|
  */
 
  w = grille[y][x - 1];
  e = grille[y][x + 1];
  n = grille[y - 1][x];
  s = grille[y + 1][x];
 
  var couleur;
 
  if (grille[y][x] == 0) {
    if ((n == 1) && (e == 1) && (s) == 1) { // ** voilà ici plus bas, on calcule par rapport à cellule case haut, case droite, case bas - cf scan
      grille[y][x] = 1;
      couleur = "yellow";
    } else {
      if ((n == 1) && (w == 1) && (e == 1)) { // cf scan
        grille[y][x] = 1;
        couleur = "brown";
      } else {
        if ((n == 1) && (w == 1) && (s == 1)) { // cf scan
          grille[y][x] = 1;
          couleur = "black";
        } else {
          if ((w == 1) && (s == 1) && (e == 1)) { // cf scan
            grille[y][x] = 1;
            couleur = "pink";
          }
        }
      }
    }
  } else {
    if (grille[y][x] == 1) {
      if ((w + n + s + e) == 3) { // Si une cellule vivante est entourée de 3 cellules, elle le reste (Txy = 1)
        couleur = "blue";
      } else {
        if ((w + n + s + e) == 2) { // Si une cellule vivante est entourée de 2 cellules, elle le reste (Txy = 1)
          couleur = "magenta";
        } else { // si aucun de ces deux cas -> cellule entourée de 0,1 ou 4 cellules, elle meurt -> tyx = 0
          couleur = "black";
        }
      }
    }
  }
 
  return couleur;
}

[Skogou]

Merci, merci grandement à vous deux pour ces merveilleuses pistes, ces petits conseils qui facilitent grandement l'écriture, je me rends compte que j'aurais pu faire beaucoup plus simple, 'fin bon, c'est comme ça qu'on apprend, tant mieux !
Il ne me reste plus qu'à !
Je reviens vers vous quand toutes les modifications auront été faites, mais ça s'annonce très bien.

[Skogou]

Je reviens vers vous, j'essaye de chercher depuis une heure le moyen de contourner le soucis :
J'ai donc lu le mémo, pour créer un tableau 2D, pas de soucis, merci !
Le problème se pose quant à comment initialiser le tableau.

J'arrive à initialiser la première ligne :





J'ai essayé quelques petits trucs, qui n'auront sûrement pas grand sens pour vous :





Ou bien





J'aurai bien aimé faire ainsi, mais ce n'est pas possible.




J'ai farfouillé sur internet mais le jargon utilisé est décourageant au possible, il faudrait que j'apprenne le Javascript depuis le début, mais je manque de temps.
Auriez-vous une solution pour initialiser le tableau en 2D, afin que je puisse attribuer à chaque ligne un 0 ou un 1 ?

Sinon je ferais autrement, Mathieu m'a donné l'idée, volontairement ou non, de créer un tableau de base (très grand), et ensuite selon des constantes saisies, calculer seulement l'encadrement des constantes dans le tableau. Ce sera du bricolage, mais ça peut marcher.

[mathieu]

dans le code de votre 1er message, vous utilisiez "T[y][x] = Hasard(2);" et ça fonctionnait, que souhaitez vous modifier dans cette génération de valeurs ?

[Skogou]

Bonsoir,

En effet, je pouvais l'utiliser car j'avais déjà affecté au tableau des valeurs - cf le premier code avec des lignes de 0.
Mon problème est que je voudrais pouvoir créer un tableau d'une taille k*m, pour ne pas partir d'un tableau avec une taille prédéfinie et non modifiable (ce qui est le cas dans le premier code).

Chatanga me proposait de créer un tableau d'une grandeur aléatoire : T(X,Y).
Et ensuite de l'initialiser avec une seule valeur, ce dont je n'arrive pas (cf mes essais, et les captures avec), seule la première ligne est initialisée.

Dans la dernière capture d'écran envoyée, je ne peux attribuer un 0 ou un 1 car le tableau n'est pas initialisé, le programme n'arrive pas à trouver T[y][x] car l'emplacement est vide "undefined" (?).

[mathieu]

Je crois que le soucis vient des boucles "for". les indices vont de 0 à X - 1 donc dans la condition de fin pour X il faut mettre par exemple "x < X"

Si vous avez d'autres soucis avec des morceaux de code, coller le code ici au lieu de faire des photos d'écran comme cela nous pouvez tester le code nous même.

[Skogou]

En effet, grand merci !
La création de génération aléatoire est donc effective, génial !

Il me reste deux problèmes, si vous avez une idée (?) :

- J'ai crée un deuxième tableau "B" où je calcule mon tableau "T", seulement cela ne règle pas le souci :

La génération suivante n'est pas calculée en fonction de la génération précédente, mais en fonction de la génération en cours de calcul.

Il y a un problème dans mes lignes de code, je n'arrive pas à trouver où, le tableau B doit se rafraîchir trop rapidement..?

- Je pense que le deuxième problème est lié au premier, il arrive que au bout de 5-6 générations, cela n'évolue plus, alors qu'il y a des cellules vivantes entourées de 4 autres cellules vivantes (ce qui n'est normalement pas possible)...

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
// Population
var x, y, X, Y, mort, naissance, vivant;
 
mort = 0;
naissance = 0;
L = SaisieEntier('Donnez une longueur du tableau comprise entre 5 et 100');
 
 
 
var T = Tableau(L, L); // Tableau T selon les dimensions L
var B = Tableau(L, L); // Tableau B avec les même dimensions que L, donc de T
 
 
for (x = 0; x < L; x = x + 1) { // rien de nouveau
  for (y = 0; y < L; y = y + 1) {
    T[y][x] = Hasard(2);
    T[0][x] = 0;
    T[L - 1][x] = 0;
    T[y][0] = 0;
    T[y][L - 1] = 0;
    B[y][x] = T[y][x];
    B[0][x] = 0;
    B[L - 1][x] = 0;
    B[y][0] = 0;
    B[y][L - 1] = 0;
 
    if (T[y][x] == 1) {
      vivant = vivant + 1; // pour compter le nombre de cellules vivantes
    }
    if (T[y][x] == 1) { // s'il y a une cellule 
      CerclePlein(y * 10, x * 10, 5, 'black'); // cercle noire
    } else { // sinon							
      CerclePlein(y * 10, x * 10, 5, 'white'); // cercle blanc
    }
  }
}
 
function MouseClick(x, y) { // clique de souris
  for (x = 0; x < L; x = x + 1) { // pour x allant de 0 à L
    for (y = 0; y < L; y = y + 1) { // pour y allant de 0 à L
      B[y][x] = T[y][x]; // Le tableau B prend toutes les valeurs de T
      if (B[y][x] == 1) { // si pour x,y un cellule vivante
        CerclePlein(y * 10, x * 10, 5, 'black'); // cercle noire
      } else { // sinon
        CerclePlein(y * 10, x * 10, 5, 'white'); // cercle blanc
      }
    }
  }
 
  for (y = 1; y < L - 1; y = y + 1) { // Pour y allant de 1 à L-1
    for (x = 1; x < L - 1; x = x + 1) { // pour x allant de 1 à L-1
      if (B[y][x] == 0) { // S'il n'y a pas de cellule
        if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) == 3) { // mais que la case est entourée d'exactement 3 cellules
          T[y][x] = 1; // une cellule nait
          CerclePlein(x * 10, y * 10, 5, 'black'); // et une cellule noire est représentée
          naissance = naissance + 1;
        }
      } else {
        if (B[y][x] == 1) { // s'il y a une cellule
          if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) == 3) { // et qu'elle est entourée de 3 cellules 
            T[y][x] = 1; // la cellule reste vivante
            CerclePlein(x * 10, y * 10, 5, 'black');
          } else {
            if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) == 2) { // ou entourée de 2 cellules
              T[y][x] = 1; // la cellule reste vivante
              CerclePlein(x * 10, y * 10, 5, 'black');
            } else {
              T[y][x] = 0; // Dans tous les autres cas, la cellule meurt.
              CerclePlein(x * 10, y * 10, 5, 'white');
              mort = mort + 1;
              vivant = vivant - 1;
            }
 
          }
        }
      }
    }
  }
}

[Skogou]

C'est bon en fait, résolu, il fallait simplement que j'enlève les "CerclePlein", et laisser ceux-ci se générer après le clique de la souris.

Un grand merci à vous pour vos bonne idées,

Je vous laisse le produit final, sait-on jamais pour d'autres personnes qui auraient le même sujet (il reste cependant des choses à améliorer).

Bonne continuation, et bonne soirée !

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
// Algorithme : Le jeu de la Vie
 
var x, y, X, Y;
 
L = SaisieEntier('Donnez une longueur du tableau comprise entre 5 et 100'); // On demande à l'utilisateur de saisie un entier
 
 
var T = Tableau(L, L); // Tableau T selon les dimensions L
var B = Tableau(L, L); // Tableau B avec les même dimensions que L, donc de T
 
for (x = 0; x < L; x = x + 1) { // Pour x allant de 0 à L-1
  for (y = 0; y < L; y = y + 1) { // pour y allant de 0 à L-1
    T[y][x] = Hasard(2); // On crée aléatoirement une génération de cellule en attribuant soit un 0 = vide, ou un 1 = une cellule.
    T[0][x] = 0; // On exclue les bordures du tableau 2D, il ne faut pas qu'il y ait de cellules - cf polycopié.
    T[L - 1][x] = 0;
    T[y][0] = 0;
    T[y][L - 1] = 0;
    B[y][x] = T[y][x]; // Le tableau B prend toutes les valeurs de T
    B[0][x] = 0; // de même on exclue les bordures du tableau 2D
    B[L - 1][x] = 0;
    B[y][0] = 0;
    B[y][L - 1] = 0;
 
    if (T[y][x] == 1) { // s'il y a une cellule 
      CerclePlein(y * 10, x * 10, 5, 'black'); // cercle noire
    } else { // SINON							
      CerclePlein(y * 10, x * 10, 5, 'white'); // cercle blanc
    }
  }
}
 
function MouseClick(x, y) { // clique de souris, calcule chaque génération
  for (x = 0; x < L; x = x + 1) { // pour x allant de 0 à L-1
    for (y = 0; y < L; y = y + 1) { // pour y allant de 0 à L-1
      B[y][x] = T[y][x]; // Le tableau B prend toutes les valeurs de T (permet un rafraichissement à chaque clique des nouvelles valeurs de T).
      if (B[y][x] == 1) { // Si une cellule est vivante
        CerclePlein(y * 10, x * 10, 5, 'black'); // cercle noire
      } else { // sinon
        CerclePlein(y * 10, x * 10, 5, 'white'); // cercle blanc
      }
    }
  }
 
  for (y = 1; y < L - 1; y = y + 1) { // Pour y allant de 1 à L-1
    for (x = 1; x < L - 1; x = x + 1) { // pour x allant de 1 à L-1
      if (B[y][x] == 0) { // S'il n'y a pas de cellule
        if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) == 3) { // mais que la case est entourée d'exactement 3 cellules
          T[y][x] = 1; // une cellule nait
 
        }
      } else {
        if (B[y][x] == 1) { // s'il y a une cellule
          if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) == 3) { // et qu'elle est entourée de 3 cellules 
            T[y][x] = 1; // la cellule reste vivante
 
          } else {
            if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) == 2) { // ou entourée de 2 cellules
              T[y][x] = 1; // la cellule reste vivante
 
            } else {
              T[y][x] = 0; // Dans tous les autres cas, la cellule meurt (cellule entourée de 0,1,4 autres cellules).
 
            }
          }
        }
      }
    }
  }
}

[Skogou]

[Edit]

En je n'avais rien compris au principe, par voisin ils entendaient en fait les 8 cellules autour... Et en effet le résultat est complètement différent : Appuyer en continu sur "o" pour afficher les différentes générations sur Algoscript.

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
// Algorithme : Le jeu de la Vie
 
var x, y, X, Y;
 
L = SaisieEntier('Donnez une longueur du tableau comprise entre 5 et 100'); // On demande à l'utilisateur de saisie un entier
 
 
var T = Tableau(L, L); // Tableau T selon les dimensions L
var B = Tableau(L, L); // Tableau B avec les même dimensions que L, donc de T
 
for (x = 0; x < L; x = x + 1) { // Pour x allant de 0 à L-1
  for (y = 0; y < L; y = y + 1) { // pour y allant de 0 à L-1
    T[y][x] = Hasard(2); // On crée aléatoirement une génération de cellule en attribuant soit un 0 = vide, ou un 1 = une cellule.
    T[0][x] = 0; // On exclue les bordures du tableau 2D, il ne faut pas qu'il y ait de cellules - cf polycopié.
    T[L - 1][x] = 0;
    T[y][0] = 0;
    T[y][L - 1] = 0;
    B[y][x] = T[y][x]; // Le tableau B prend toutes les valeurs de T
    B[0][x] = 0; // de même on exclue les bordures du tableau 2D
    B[L - 1][x] = 0;
    B[y][0] = 0;
    B[y][L - 1] = 0;
 
    if (T[y][x] == 1) { // s'il y a une cellule 
      CerclePlein(y * 10, x * 10, 5, 'black'); // cercle noire
    } else { // SINON							
      CerclePlein(y * 10, x * 10, 5, 'white'); // cercle blanc
    }
  }
}
 function Keypressed(o) { // Appuyer en continu sur "o" permet de calculer les différentes générations .
   Loop(1);
 // clique de souris, calcule chaque génération
  for (x = 0; x < L; x = x + 1) { // pour x allant de 0 à L-1
    for (y = 0; y < L; y = y + 1) { // pour y allant de 0 à L-1
      B[y][x] = T[y][x]; // Le tableau B prend toutes les valeurs de T (permet un rafraichissement à chaque clique des nouvelles valeurs de T).
      if (B[y][x] == 1) { // Si une cellule est vivante
        CerclePlein(y * 10, x * 10, 5, 'black'); // cercle noire
      } else { // sinon
        CerclePlein(y * 10, x * 10, 5, 'white'); // cercle blanc
      }
    }
  }
 
  for (y = 1; y < L - 1; y = y + 1) { // Pour y allant de 1 à L-1
    for (x = 1; x < L - 1; x = x + 1) { // pour x allant de 1 à L-1
      if (B[y][x] == 0) { // S'il n'y a pas de cellule
        if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) + (B[y-1][x+1]) + (B[y+1][x+1]) +(B[y+1][x-1])+ (B[y-1][x-1]) == 3) { // mais que la case est entourée d'exactement 3 cellules
          T[y][x] = 1; // une cellule nait
 
        }
      } else {
        if (B[y][x] == 1) { // s'il y a une cellule
          if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) + (B[y-1][x+1]) + (B[y+1][x+1]) +(B[y+1][x-1])+ (B[y-1][x-1]) == 3 ) { // et qu'elle est entourée de 3 cellules 
            T[y][x] = 1; // la cellule reste vivante
 
          } else {
            if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) + (B[y-1][x+1]) + (B[y+1][x+1]) +(B[y+1][x-1])+ (B[y-1][x-1]) == 2) { // ou entourée de 2 cellules
              T[y][x] = 1; // la cellule reste vivante
 
            } else {
              T[y][x] = 0; // Dans tous les autres cas, la cellule meurt (cellule entourée de 0,1,4 autres cellules).
 
            }
          }
        }
      }
    }
  }
 }

[Beginner.]

Je vous laisse le produit final, sait-on jamais pour d'autres personnes qui auraient le même sujet (il reste cependant des choses à améliorer).

Merci mais sans le HTML|CSS on ne peut pas tester...

[Skogou]

Merci mais sans le HTML|CSS on ne peut pas tester...

Il faut aller sur http://www.algoscript.info , copier le code, puis cliquer sur "Code JS", cliquer sur "graphic output", lancer le code en appuyant sur la flèche bleue en haut à droite. Une longueur est demandée. Si votre ordinateur n'est pas très puissant, rester à 50-60, sinon vous pouvez monter à 100 (8Go), voir plus si vraiment vous avez de la rame (15-30 Go).

Cordialement

Ce code-ci est le plus abouti :

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
// Algorithme : Le jeu de la Vie
 
var x, y, X, Y, vivant, mort, naissance,generation,m,n;
vivant = 0;
naissance = 0;
mort = 0;
generation = 0;
L = SaisieEntier('Donnez une longueur du tableau comprise entre 5 et 100'); // On demande à l'utilisateur de saisie un entier
 
 
var T = Tableau(L, L); // Tableau T selon les dimensions L
var B = Tableau(L, L); // Tableau B avec les même dimensions que L, donc de T
 
for (x = 0; x < L; x = x + 1) { // Pour x allant de 0 à L-1
  for (y = 0; y < L; y = y + 1) { // pour y allant de 0 à L-1
    T[y][x] = Hasard(2); // On crée aléatoirement une génération de cellule en attribuant soit un 0 = vide, ou un 1 = une cellule.
    T[0][x] = 0; // On exclue les bordures du tableau 2D, il ne faut pas qu'il y ait de cellules - cf polycopié.
    T[L - 1][x] = 0;
    T[y][0] = 0;
    T[y][L - 1] = 0;
    B[y][x] = T[y][x]; // Le tableau B prend toutes les valeurs de T
    B[0][x] = 0; // de même on exclue les bordures du tableau 2D
    B[L - 1][x] = 0;
    B[y][0] = 0;
    B[y][L - 1] = 0;
 
    if (T[y][x] == 1) { // s'il y a une cellule 
      CerclePlein(y * 10, x * 10, 5, 'black'); // cercle noire
      vivant = vivant + 1;
    } else { // SINON							
      CerclePlein(y * 10, x * 10, 5, 'white'); // cercle blanc
    }
  }
}
 function Keypressed(o) { // Appuyer en continu sur "o" permet de calculer les différentes générations .
   Loop(1);
   RectanglePlein(1050,30,300,300,'white');
   m=0;
   n=0;
 generation = generation + 1;
  for (x = 0; x < L; x = x + 1) { // pour x allant de 0 à L-1
    for (y = 0; y < L; y = y + 1) { // pour y allant de 0 à L-1
      B[y][x] = T[y][x]; // Le tableau B prend toutes les valeurs de T (permet un rafraichissement à chaque clique des nouvelles valeurs de T).
      if (B[y][x] == 1) { // Si une cellule est vivante
        CerclePlein(y * 10, x * 10, 5, 'black'); // cercle noire
      } else { // sinon
        CerclePlein(y * 10, x * 10, 5, 'white'); // cercle blanc
      }
    }
  }
 
  for (y = 1; y < L - 1; y = y + 1) { // Pour y allant de 1 à L-1
    for (x = 1; x < L - 1; x = x + 1) { // pour x allant de 1 à L-1
      if (B[y][x] == 0) { // S'il n'y a pas de cellule
        if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) + (B[y-1][x+1]) + (B[y+1][x+1]) +(B[y+1][x-1])+ (B[y-1][x-1]) == 3) { // mais que la case est entourée d'exactement 3 cellules
          T[y][x] = 1; // une cellule nait
          vivant = vivant + 1;
          naissance = naissance + 1;
          n=n + 1;
 
        }
      } else {
        if (B[y][x] == 1) { // s'il y a une cellule
          if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) + (B[y-1][x+1]) + (B[y+1][x+1]) +(B[y+1][x-1])+ (B[y-1][x-1]) == 3 ) { // et qu'elle est entourée de 3 cellules 
            T[y][x] = 1; // la cellule reste vivante
 
          } else {
            if ((B[y][x + 1]) + (B[y + 1][x]) + (B[y - 1][x]) + (B[y][x - 1]) + (B[y-1][x+1]) + (B[y+1][x+1]) +(B[y+1][x-1])+ (B[y-1][x-1]) == 2) { // ou entourée de 2 cellules
              T[y][x] = 1; // la cellule reste vivante
 
            } else {
              T[y][x] = 0; // Dans tous les autres cas, la cellule meurt (cellule entourée de 0,1,4 autres cellules).
              mort = mort + 1;
              vivant = vivant -1;
              m = m+1;
            }
          }
        }
      }
    }
  }
   Texte (1100,50, 'GÉNÉRATION :       ' + generation, 'black');
   Texte (1100,75, 'Cellules vivantes :       ' + vivant, 'black');
   Texte (1100,100, 'Cellules mortes à génération    ' + generation + ' :     ' +m,'black');
   Texte (1100,125, 'Cellules mortes :       ' + mort, 'black');
   Texte (1100,150, 'Cellules nées à génération    ' + generation + ' :     ' +n,'black');
   Texte (1100,175, 'NAISSANCES :       ' + naissance, 'black'); 
 }