Discussion :

[Vivian Pennel]

Bonjour tout le monde,
J'ai un petit soucis algorithmique pour mon exo en JAVA.
Je vous explique le problème
J'ai une matrice carré de N * N, dedans il y a deux types de cellules : des vivantes ou des mortes
mon but c'est à partir de 2 paramètre (ligne,colonne) de compter les voisins (c'est à dire les cellules vivantes voisines de la case [ligne,colonne]) de la case repérée par ces paramètres .

Mon idée que je ne trouve pas terrible est (pour pas tester une case hors matrice) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
Si je peux regarder la case   // exemple la ligne d'avant meme colonne
     Alors je teste si la case comporte une cellule vivante
            Si oui Alors nbvoisin++;
 
Si je peux regarder la case
    Alors ...                      // et ainsi dessuite

Le hic c'est que ca fait quand même 16 test à chaque fois
Je suis donc a la recherche d'une meilleur idée

[souviron34]

algo classique de traitement d'images ou autre :

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
Pour tout i dans ligne
 
   Si i = 0
       limite_i inf = 0
   Sinon
       limite_i inf = i - 1
   Fin si
 
   Si i = nb_lignes
       limite_i sup = nb_lignes
   Sinon
       limite_i sup = i + 1
   Fin Si
 
   Pour tout j dans colonne
 
        Si j = 0
            limite_j inf = 0
        Sinon
            limite_j inf = j - 1
        Fin si
 
        Si j = nb_colonnes
             limite_j sup = nb_colonnes
        Sinon
             limite_j sup = j + 1
        Fin Si
 
        Nb = 0
 
        Pour ii = limite_i inf  à ii = limite_i sup
            Pour jj = limite_j inf à jj = limite_j sup
                   Si cellule (ii,jj) vivante
                         Nb = Nb + 1
                   Fin Si
            Fin Pour
        Fin Pour
 
        Si cellule(i,j) vivante
             Nb = Nb - 1    /* pour avoir les VOISINS seulement */
        Fin si
 
   Fin Pour
Fin Pour

[Vivian Pennel]

Merci beaucoup je vais regarder ca

[pseudocode]

bonjour,

Le hic c'est que ca fait quand même 16 test à chaque fois
Je suis donc a la recherche d'une meilleur idée

16 tests c'est pas énorme... j'ai fait des algos qui font bien pire que ca ! ()

Enfin, si ca te chagrine tant que ca, voila une idée: tu prends une matrice (K) qui fait (N+2)x(N+2), et tu mets les données de ta matrice (M) NxN au milieu. Et sur les bords tu mets une valeur qui t'arrange (cellule morte).

Ensuite dans ton algo, quand tu dois acceder a un element tu ajoute (1,1) au coordonnées: M[i][j] --> K[i+1][j+1]. Donc plus besoin de tester les bords de la matrice car tu ne sera jamais sur un bord de la matrice K.