Discussion :

[radouane_bne]

Si on a une matrice M[i][j] pour i variant de 0 jusqu'à n-1 et j variant de 1 jusqu'à m-1,s'il y a plus de qautre case qui ont la même valeur, (horizontalement ou vericalement) on met à leurs place la valeur 0.

par exemple:

on considére la matrice suivante:

0 0 0 0 0 0 0 0
0 0 3 0 1 0 4 5
1 5 3 6 4 8 5 9
1 5 3 3 9 8 7 2
9 8 3 4 2 6 8 2
9 5 3 2 1 9 8 2

il devient aprés compilation:

0 0 0 0 0 0 0 0
0 0 0 0 1 0 4 5
1 5 0 6 4 8 5 9
1 5 0 3 9 8 7 2
9 8 0 4 2 6 8 2
9 5 0 2 1 9 8 2

[diogene]

Et alors ?
Quelle est la question ?

[radouane_bne]

désolé j'étais pas claire.

ma question est d'écrire un programme qui fait cela,c'est-à-dire s'il existe plus de quatres coefficients d'une matrice qui sont voisins,soit horizontalement soit verticalement,on remplace leurs valeurs par 0.L'exemple de matrice que j'ai donné en est une illustration.

[diogene]

ma question est d'écrire un programme qui fait cela...

J'avais bien compris mais c'est toi qui dois faire l'exercice. Nous pouvons seulement t'aider à comprendre les points qui te posent problèmes.

Poste le code que tu as déjà écrit et pose tes questions sur les difficultés que tu rencontres.

[radouane_bne]

la seule difficulté que je trouve c'est de varier le nombre de case où il y la même valeur.
par exemple pour 4.pour faire cela sur un ligne horizontale.

Code :

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

1
2
3
4
5
6
7
for(i=0;i<n;i++)
for(j=0;j<m;j++)
if(A[i][j]=A[i][j+2]=A[i][j+3]=A[i][j+4]
A[i][j]=0;
A[i][j+1]=0;
A[i][j+2]=0;
A[i][j+3]=0;

et j'ai fait la même chose ne variant maintenant i de i jusqu'à i+4.

Donc y'a-t-il une façon de varier même le nombre de case,et de rassembler à la fois la vertical et l'horizontale en seule fonction.

j'ai pensé à faire une autre fonction qui calcule le nombre de case voisins qui ont la même valeur,et puis si cette somme est supérieur par exemple à 4,je met tt les cases en 0,mais j'ai pas pu la faire.

merci d'avance pour vous

[jeroman]

1) Attention à bien vérifier de ne pas déborder de ton tableau. Dans tes conditions if, tu débordes.

2) Tu confonds les opérateurs = et ==.

[radouane_bne]

oui,oui pour une matrice A[m][n] le bon code pour la detection de 4 cases horizontales le bon code est:

Code :

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

1
2
3
4
5
6
7
8
9
10
for(i=0;i<n;i++)
{
     for(j=0;j<m;j++)
         {if(A[i][j]==A[i][j+2]==A[i][j+3]==A[i][j+4])
                 A[i][j]=0;
                 A[i][j+1]=0;
                 A[i][j+2]=0;
                 A[i][j+3]=0;
          }
}

Y'en a pas des propositions pour le cas général

[Invité(e)]

Bonjour,

Au lieu d'écrire des suites de tests ou d'affectation, on peut utiliser des boucles for :

Au lieu de

Code :

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

1
2
3
4
A[i][j]=0;
A[i][j+1]=0;
A[i][j+2]=0;
A[i][j+3]=0;

on écrira

Code :

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

1
2
3
for(k = 0; k < 4; ++k) {
    A[i][j+k] = 0;
}

A peu près la même chose pour

Code :

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

if(A[i][j]==A[i][j+2]==A[i][j+3]==A[i][j+4])

: on compare dans la boucle A[i][j] à A[i][j+k].

[diogene]

- Ceci est faux

Code :

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

if(A[i][j]==A[i][j+2]==A[i][j+3]==A[i][j+4])

Code :

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

if(A[i][j]==A[i][j+2] && A[i][j]==A[i][j+3]&& A[i][j]==A[i][j+4])

- Pourquoi y a t-il un A[i][j+4] et pas de A[i][j+1]

- Qu'est ce qui garantit que A[i][j+2], A[i][j+3] ou A[i][j+4] ne débordent pas du tableau ?

[radouane_bne]

merci pour vos réponses et votre aide.

mon objectif est à chaque fois je trouve une alignement d'au moins 4 coefficients d'une matrice ayant la même valeur verticalement ou horizontalement,je leur affecte la valeur 0.

ce que j'ai fait est le suivant:

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
int i,j,k,l,zero;
     zero=0;
 
     for(j=0;j<m;j++){
         for (i=0; i<(n-3); i++){
             if ( (A[i][j]==A[i+1][j]) && (A[i+1][j]==A[i+2][j]) && (A[i+2][j]==A[i+3][j]) ){
                  A[i][j]=0;
                  A[i+1][j]=0;
                  A[i+2][j]=0;
                  A[i+3][j]=0;
                  zero=zero+4;
 
               }
         }
     }
 
     for(i=0;i<n;i++){
         for (j=0;j<(m-3);j++){
             if ( (A[i][j]==A[i][j+1]) && (A[i][j+1]==A[i][j+2]) && (A[i][j+2]==A[i][j+3]) ){
                 A[i][j]=0;
                 A[i][j+1]=0;
                 A[i][j+2]=0;
                 A[i][j+3]=0;
                 zero=zero+4;
 
                }
         }
     }
return(zero);
}

toutefois ce que j'ai fait n'est valable que pour un alignement de quatre coefficients,je sais pas comment faire pour un alignement de plus de 4.En fait c'est un jeu que je veux programmer qui consiste à supprimer tout alignement vertical ou horizontale de billes,ou à la fois.

merci encore une fois

[jeroman]

toutefois ce que j'ai fait n'est valable que pour un alignement de quatre coefficients,je sais pas comment faire pour un alignement de plus de 4.En fait c'est un jeu que je veux programmer qui consiste à supprimer tout alignement vertical ou horizontale de billes,ou à la fois.

Si tu as X nombres à vérifier, il n'y a rien de miraculeux : il faut passer par un système de boucle.

Toute cette partie est donc à modifier :

Code :

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

1
2
3
4
5
6
7
if ( (A[i][j]==A[i+1][j]) && (A[i+1][j]==A[i+2][j]) && (A[i+2][j]==A[i+3][j]) )
{
   A[i][j]=0;
   A[i+1][j]=0;
   A[i+2][j]=0;
   A[i+3][j]=0;
}

Et la condition du for le plus imbriqué doit aussi être modifiée, elle aussi, pour qu'aucun débordement ne se produise.

Après, il faudra coder pour vérifier ton tableau horizontalement. Le principe est le même.

[diogene]

Je crains que ce ne soit un peu plus compliqué que de traiter séparément les cases verticales et les cases horizontales. Prenons cet exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
                           - Traitement des -
     origine         horizontales      Verticales
0 0 0 0 0 0 0 0    0 0 0 0 0 0 0 0   0 0 0 0 0 0 0 0 
0 3 3 3 3 3 4 5    0 0 0 0 0 0 4 5   0 3 0 3 3 3 4 5 
1 5 3 6 4 8 5 9    1 5 3 6 4 8 5 9   1 5 0 6 4 8 5 9 
1 5 3 3 9 8 7 2    1 5 3 3 9 8 7 2   1 5 0 3 9 8 7 2 
9 8 3 4 2 6 8 2    9 8 3 4 2 6 8 2   9 8 0 4 2 6 8 2 
9 5 3 2 1 9 8 2    9 5 3 2 1 9 8 2   9 5 0 2 1 9 8 2
                         - Et c'est terminé -

Le but n'est t-il pas d'avoir ?

Code :

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

1
2
3
4
5
6
7
0 0 0 0 0 0 0 0 
0 0 0 0 0 0 4 5 
1 5 0 6 4 8 5 9 
1 5 0 3 9 8 7 2 
9 8 0 4 2 6 8 2 
9 5 0 2 1 9 8 2