Discussion :

[joel.drigo]

C'est pour cela que je ne comprenais pas comment faire il faut donc si que j'avance depuis le début pour trouver mon premier 1 et depuis la fin de mon code pour trouver mon dernier 1 et remplacer l'emsemble des 0 entre par des 1.

Voilà !

[hoturi]

Bonjour

j'utilise ce code pour trouver la position du premier 1 dans ma ligne mais je n'arrive pas a trouver la position du dernier 1 comment puis je faire cela.

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
 int [] nombreZeros = new int[carte.length];
 
		//Comptabe
		for(int i = 0; i < carte.length;i++) {
			int count = 0;
			int [] sequences = carte[i];
			for(int bit : sequences) {
				if(bit == 1) {
					break;
				}
				++count;
			}
			nombreZeros[i] = count;
		}
 
		//Affichage
		for(int i = 0; i < nombreZeros.length; i++) {
			System.out.println("nb0(ligne " + (i + 1) + ") = " +  nombreZeros[i] );
 
		}

Existe il un code simple qui pourrait me donner la première et derniére postion d'un chiffre ou lettre dans un tableau?

Merci d'avance

[joel.drigo]

Que fais-tu pour trouver le premier 1 ? Tu parcours depuis le début, vers la fin, les éléments du tableau jusqu'à en trouver un qui vaut 1 (et là l'index que tu as c'est la position du 1), n'est-ce pas ?
Et si, par exemple, tu faisais la même chose, mais en partant de la fin du tableau en parcourant les éléments vers le début ?

[hoturi]

Que fais-tu pour trouver le premier 1 ? Tu parcours depuis le début, vers la fin, les éléments du tableau jusqu'à en trouver un qui vaut 1 (et là l'index que tu as c'est la position du 1), n'est-ce pas ?
Et si, par exemple, tu faisais la même chose, mais en partant de la fin du tableau en parcourant les éléments vers le début ?

C'est bien ce q ue j'essaye de faire mais depuis presque 2 heure je bloque dessus, et je ne comprend pas pourquoi, soit mon code ne fonctionne pas soit j'obtient juste une inversion des résultat comme ceci :

premier 1 ligne 1 = 3
premier 1 ligne 2 = 0
premier 1 ligne 3 = 4

dernier 1 ligne 1 = 4
dernier 1 ligne 2 = 0
dernier 1 ligne 3 = 3

Du coup je commence a perdre patience.

[joel.drigo]

Et c'est quoi ce code ?

EDIT: sinon, au lieu de faire :

Code :

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

1
2
3
4
5
6
7
8
9
 
int count = 0;
			int [] sequences = carte[i];
			for(int bit : sequences) {
				if(bit == 1) {
					break;
				}
				++count;
			}

tu faisais :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int count = -1;
int [] sequences = carte[i];
 
for(int index = 0; index<sequences.length; index++) {
    if(sequences[index] == 1) {
        count = index;
        break;
    } 
}

ou, encore :

Code :

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

1
2
3
4
5
6
7
8
9
 
int count = -1;
int [] sequences = carte[i];
 
for(int index = 0; count==-1 && index<sequences.length; index++) {
    if(sequences[index] == 1) {
        count = index; 
    } 
}

ça te devrais être plus facile pour toi pour voir comment obtenir le dernier 1 (soit le premier en partant de la fin...).

[hoturi]

DSL je n'arrive plus a le retrouver, a force de changer mon code je l'ai perdue.

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
int [] nombreZeros = new int[carte.length];
 
		//Comptabe
		for(int i = 0; i < carte.length;i++) { //----------> cette ligne ne sert que pour avancer sur les lignes du tableau et non sur les colonnes, je ne dois pas y toucher, non?
			int count = 0;
			int [] sequences = carte[i]; // -------------> C'est donc cette ligne qui doit être modifié.
			for(int bit : sequences) {
				if(bit == 1) {
					break;
				}
				++count;
			}
			nombreZeros[i] = count;
		}
 
		//Affichage
		for(int i = 0; i < nombreZeros.length; i++) {
			System.out.println("nb0(ligne " + (i + 1) + ") = " +  nombreZeros[i] );
 
		}

[hoturi]

Voila mon 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
int [] nombreZerosf = new int[carte.length];
	        int i=0;
			//Comptabe
	        for( i = 0; i < carte.length  ;i++) {
				int count = 0;
				int [] sequences = carte[carte.length-i-1];
				for(int bit : sequences) {
					if(bit == 1) {
						break;
					}
					++count;
				}
				nombreZerosf[i] = count;
			}
 
			//Affichage
 
			for( i = 0; i < nombreZeros.length; i++) {
				System.out.println("nb0f(ligne " + (i + 1) + ") = " +  nombreZerosf[i] );

[joel.drigo]

Ton dernier code c'est à peu de chose près celui que tu as déjà montré et qui sert à déterminer la position du premier 1. C'est celui dont tu disais que tu galèrais depuis 2 heures, celui pour déterminer le dernier 1 dont je parlais !


Sinon :

Code :

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

int [] sequences = carte[i]; // -------------> C'est donc cette ligne qui doit être modifié.

Non, pourquoi modifier la ligne qui permet d'obtenir une ligne du tableau. Tu cherches à connaître le premier 1 et le dernier 1 de chaque ligne : tu as donc besoin de la ligne, pour trouver le premier, comme le dernier.

Je t'ai dit que pour trouver le premier tu faisais for(int i=0; i<sequences.length; i++) (i va de 0 à sequence.length-1, soit du début à la fin) : que dois-tu faire pour inverser cette boucle, soit aller de la fin au début ?

[hoturi]

Je comprend ce que tu veux me dire mais si j'utilise se code cela ne fonctionne pas

for( i = carte.length-i; i < carte.length;i++) {

YH'a un truc qui m'échappe je ne suis pas loin je tourne mais je ne trouve pas.

[joel.drigo]

for( i = carte.length-i; i < carte.length;i++) {

forcément, ça ne fonctionne pas, parce que c'est n'importe quoi :

• carte.length c'est le nombre de lignes, pas le nombre d'éléments d'une ligne
• i = carte.length - i : je ne sais pas ce que tu cherches à calculer là

La boucle que tu dois inverser, c'est celle que je t'ai déjà indiquée, c'est la boucle sur une ligne.

Rappel :

1. for(int i=0; i<10; i++) boucle de 0 à 9 inclus
2. for(int i=9; i>=0; i--) boucle de 9 à 0 inclus

[Babou87]

voici une idé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
// Recherche des zeros du bord gauche
		for (int i = 0; i < carte.length; i++)
		{
			for (int j = 0; j < carte.length; j++)
			{
				do { 
					carte [j] [i] = 2;
					j++;
				} while (carte [j] [i]== 0);				
			}
		}
// Recherche des zeros du bord droit		
		for (int i = carte.length; i == 0 ; i++)
		{
			for (int j = carte.length; j == 0 ; j++)
			{
						do {
							carte [j] [i] = 2;
							j++;
						} while (carte [j] [i]== 0);	
			}
		}
// Transformation des étangs en 1
		for (int i = 0; i < carte.length; i++)
		{
			for (int j = 0; j < carte.length; j++)
			{
			if (carte [j] [i] == 0)	
			{
				carte [j] [i] = 1;
			}
			}

[joel.drigo]

voici une idée :

Non, mais alors, pas du tout.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// Recherche des zeros du bord gauche
		for (int i = 0; i < carte.length; i++)
		{
			for (int j = 0; j < carte.length; j++) // ==> pourquoi une double boucle imbriquée sur les lignes ?
			{
				do { 
					carte [j] [i] = 2; // tu modifies la carte !!! avec une valeur (2) hors contexte
					j++;
				} while (carte [j] [i]== 0);				
			}
		}
 
       // ...

int[][] carte, est un tableau de int[], tel que carte.length est le nombre de ces tableaux, qui ont pour taille carte[i].length, avec 0 <= i < carte.length.
Il y a de forts risques de plantage, parce qu'on incrément j sans tester le dépassement de bornes en plus : imaginons que la première ligne ne contiennent que des 1 par exemple !

Et on ne connait pas la position du 1.

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
 
 
      // ... suite...
 
// Recherche des zeros du bord droit		
		for (int i = carte.length; i == 0 ; i++) // => on démarre  à carte.length, on teste si i==0 : faux : on s'arrête donc (sauf si carte.length vaut 0, auquel cas on fait une boucle infinie)
		{
			for (int j = carte.length; j == 0 ; j++)
			{
						do {
							carte [j] [i] = 2;
							j++;
						} while (carte [j] [i]== 0);	
			}
		}
 
 
 
// Transformation des étangs en 1
		for (int i = 0; i < carte.length; i++)
		{
			for (int j = 0; j < carte.length; j++) // => même remarque 
			{
			if (carte [j] [i] == 0)
			{
				carte [j] [i] = 1;
			}
			}

L'idée de remplacer tous les 0 extérieurs par 2 pour ensuite pouvoir remplacer les 0 qui restent (donc ceux des étangs) par 1 n'est pas mauvaise en soit, mais on évite toujours de modifier les données, parce qu'on ne sait pas ce qu'on doit en faire après. Et puis c'est pas comme si on pouvait faire autrement et plus simplement, sans bousiller les données en entrée.

[hoturi]

Bon j'essaye autre chose, pourquoi celui-ci ne marche pas?

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
 
		 int [] nombreZerosf = new int[carte.length];
 
			//Comptabe
	        for( int i = carte[0].length-1; i >= 0 ;i--) {
				int count = 0;
				int [] sequences = carte[carte.length-1];
				for(int bit : sequences) {
					if(bit == 1) {
						break;
					}
					++count;
				}
				nombreZerosf[carte.length-1] = count;
			}

[joel.drigo]

Bon j'essaye autre chose, pourquoi celui-ci ne marche pas?

Parce qu'il suffit de lire le programme pas à pas pour voir que ça ne parcourt pas chaque ligne :

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
 
		 int [] nombreZerosf = new int[carte.length]; // je ne sais pas trop pourquoi tu as besoin d'un tableau, mais admettons
 
			//Comptabe
	        for( int i = carte[0].length-1; i >= 0 ;i--) { // i va de la dernière colonne de la première ligne à la première
				int count = 0;
				int [] sequences = carte[carte.length-1]; // on prend la dernière ligne (pourquoi la dernière ?, alors qu'on veut les débuts et fins de chaque ligne....
				for(int bit : sequences) { // sequences c'est la ligne (la dernière) : on parcourt tous ses éléments
					if(bit == 1) { // quand on en trouve un qui vaut 1 on s'arrête
						break;
					}
					++count; // on compte (donc on compte les != 1, donc les 0, puisqu'on sait qu'il n'y a que des 0 et des 1 ; par ailleurs, count est bien la position du dernier 1, mais de la ligne qu'on traite, donc la dernière
				}
				nombreZerosf[carte.length-1] = count; // on stocke la position du dernier 1 de la dernière ligne dans le dernier élément du tableau
			}

[hoturi]

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
int [] nombreZerosf = new int[carte.length];
 
			//Comptabe
	        for( int i = carte[0].length-1; i >= 0 ;i--) {
				int count = 0;
				int [] sequences = carte[0];
				for(int bit : sequences) {
					if(bit == 1) {
						break;
					}
					++count;
				}
				nombreZerosf[0] = count;
			}
 
			//Affichage
 
			for( int i = 0; i < nombreZeros.length; i++) {
				System.out.println("nb0f(ligne " + (i + 1) + ") = " +  nombreZerosf[0] );

Celui-ci non plus ne marche pas, si j'ai bien compris il afiche seulement la position du dernier 1 de la première ligne?

[joel.drigo]

Celui-ci non plus ne marche pas, si j'ai bien compris il afiche seulement la position du dernier 1 de la première ligne?

Bah, oui, forcément : int [] sequences = carte[0];.

Ensuite, elle sert à quoi cette boucle : for( int i = carte[0].length-1; i >= 0 ;i--) { ? Tu y fais juste varier i de l'index de la colonne de droite (de la première ligne) vers l'index de la colonne de gauche, i que tu n'utilises nulle part. Ce code cherche la position du dernier 1 de la première ligne, autant de fois qu'il y a de colonnes ! Alors que le but est de chercher la position du dernier 1 pour chaque ligne !

Je te remets ton code pour déterminer la position du premier 1 de chaque ligne (message #22) :

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
int [] nombreZeros = new int[carte.length];
 
		//Comptabe
		for(int i = 0; i < carte.length;i++) {
			int count = 0;
			int [] sequences = carte[i];
			for(int bit : sequences) {
				if(bit == 1) {
					break;
				}
				++count;
			}
			nombreZeros[i] = count;
		}
 
		//Affichage
		for(int i = 0; i < nombreZeros.length; i++) {
			System.out.println("nb0(ligne " + (i + 1) + ") = " +  nombreZeros[i] );
 
		}

Pourquoi changer la logique de parcourt des lignes, alors que c'est juste le parcourt de chaque ligne qui doit changer pour déterminer la position du dernier i ? Tu pourrais même faire la recherche des 2 (le premier et le dernier) dans cette boucle (voire même en même temps, mais fais-le en 2 fois pour le moment, ce sera déjà bien).

Imagines :

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
int [] nombreZerosAGauche = new int[carte.length]; //ça c'est ton tableau nombreZeros que j'ai renommé (qui n'est pas utile pour ce que tu dois faire...)
int[] nombreZerosADroite = new int[carte.length];
 
		//Comptabe
		for(int i = 0; i < carte.length;i++) {
 
			int [] sequences = carte[i]; // ça c'est la ligne en cours de traitement
 
                        // on recherche le premier 1 de la ligne (ou exactement on compte les 0 à gauche du premier 1)
			int count = 0;
			for(int bit : sequences) {
				if(bit == 1) {
					break;
				}
				++count;
			}
			nombreZerosAGauche[i] = count;
 
                        // on recherche le dernier 1
                        // là tu mets le même code que pour le premier 1, mais qui parcourt la ligne de la fin au début...
                        // ...
 
                        // ensuite tu as la position du premier 1 et du dernier 1 : tu n'as plus qu'a "effacer" les étangs (les 0) entre les deux !
                        // ...
 
		}
 
		//Affichage des nombres de zéro à gauche
		for(int i = 0; i < nombreZerosAGauche.length; i++) {
			System.out.println("nb0(ligne " + (i + 1) + ") = " +  nombreZerosAGauche[i] );
 
		}
 
                //Affiche des nombres de zéro à droite
                // la même boucle que pour les zéro de gauche mais sur le tableau nombreZerosADroite 
                // ...

les seules choses que tu aies normalement à modifier dans cet extrait, c'est les // ....

[hoturi]

Ok je vais réfléchir a tous cela, je fais un break (haha), je te remercie de ton aide, avec un peu d'acharnement je vais réussir a combler ces fichu étangs c'est la seul chose qui me manque pour finir l'exercice.

[hoturi]

Salut Joel, une question faut il que je fasse mon code avec 2 boucles for imbriquées comme ceci?

Code :

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

1
2
for( int i = 0; i < carte.length ;i++) {------------------------------------> j'avance sur les lignes de la première à la dernière.
			for (int j = carte[i].length-1; j>=carte[i].length-1; j--){----> j'avance sur les colonnes de la dernière vers la première.

[joel.drigo]

Si tu parles de trouver le dernier 1 de la ligne, oui, tout comme c'est le cas pour trouver le premier (attention, dans le code que tu montres, la borne de fin n'est pas bonne : là ta boucle ne fera qu'au plus une itération).

[hoturi]

J'ai repris depuis le début et j'ai enfin trouvé merci Joel plus qu'a remplacer les 0 par des un entre la première et dernière position du 1 de chaque ligne. (En espérant que j'arrive a le faire plus rapidement que cette dernière étape).

Encore merci

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
for (int i = 0; i < carte.length ; i++){
 
	    	int count = 0;	
 
			for (int j = carte[i].length-1; j >= carte.length ; j--){
 
 
 
 
					if(carte[i][j] == 1) {
						break;
					}
					++count;
				}
				nombreZerosD[i] = count;
 
     }
			for( int i = 0; i < nombreZerosD.length; i++) {
				System.out.println("nb0f(ligne " + (i + 1) + ") = " +  nombreZerosD[i] );}
				}