Trouver le nombre valeur 0 avant une valeur définie dans un tableau dynamique

**hoturi** · 15/10/2015, 16h47

Bonjour

A tous je cherche une méthode pour trouve le nombre de 0 qui sont présent dans une ligne avant la valeur 1:

ex :

000011110000 soit nb0(i)=4
000111111000 soit nb0(i+1)=3
000001100000 soit nb0(i+1)= 5

je vous remercie d'avance pour votre aide.

Invité · 15/10/2015, 17h21

Bonjour,

taChaine.charAt(int n) te retournes le n ème caractère de taChaine.

taChaine.indexOf(String motif [, int n ]) te retournes la position de la première occurrence du motif dans taChaine. Si tu ajoutes l'argument n, la recherche commence a partir du n ème caractère de taChaine. (Retourne -1 si le motif n'est pas dans la chaine).

Tu as plusieurs façon de faire pour arriver au résultat attendu.

Soit tu parcours ta chaine, lorsque tu as un 0 tu incrémentes une variable qui représente le nombre de 0, puis dès que tu as un 1, tu t'arrêtes.
En prenant comme hypothèse que tu n'as que des 0 ou des 1, soit tu obtiens la position du premier 1 grace a un indexOf, puis tu fais un taChaine.length - position du premier 1.

Je viens de voir le titre

Tu crées une fonction qui parcours ton tableau, tu incrémentes une variable quand c'est 0 puis dès que c'est 1, tu retournes cette valeur.
Tu peux ajouter un paramètre int n à ta fonction qui représente le point de départ de ton parcours de tableau.
Penses bien à vérifier que le point de départ est >= 0 et < tonTableau.length avant de faire des accès tableau.

A adapter selon tes besoins

**hoturi** · 15/10/2015, 21h43

Voila le code que j'ai créé par contre je ne sais pas comment avoir juste le nombre de 0 avant chaque ligne en gros j'aimerais sortir 3 variables comme cela : nb0(ligne1) = 7, nb0(ligne2)= 8, nb0(ligne3)=1
Pour l'instant je n'ai que le nombre de zéros présent dans mon tableau.

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[][] carte = 
            {0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0},
            {0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0},};
 
int a=0;
int count =0;
 
for (int i = 0 ; i < carte.length; ++i){
	for (int j = 0; j < carte[i].length; ++j ){
	a= carte[i][j];
 
 
		if (a==0){
		++count;}
		else{}
 
	}}	
	System.out.println (count);

Invité · 16/10/2015, 09h59

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
public int nb0(final int[] ligne) {
	int nb0 = 0;
	if(ligne != null) {
		for(int i : ligne) {
			if( i == 0) {
				nb0++;
			}else {
				break;
			}
		}
	}
	return nb0;
}

**hoturi** · 16/10/2015, 13h07

Dsl votre code ne fonctionne pas, je ne sais pas pourquoi

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
import java.util.ArrayList;
 
class exercices {
    public static void main(String[] args) {
        int[][] carte = {
            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0},
            {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0},
            {0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
        };
 
 
 
 
 
	public int nb0(final int[] ligne) {
		int nb0 = 0;
		if(ligne != null) {
			for(int i : ligne) {
				if( i == 0) {
					nb0++;
				}else {
					break;
				}
			}
		}
		return nb0;
		}
	}}

**joel.drigo** · 16/10/2015, 13h27

La méthode que t'as donnée @EyZox est pour faire le calcul pour une ligne : il faut évidemment parcourir les lignes du tableau (à 2 dimensions) et appeler pour chaque ligne cette méthode.

Par ailleurs, une méthode se déclare dans le corps de la classe, pas dans le corps d'une méthode (dans ton code, la méthode nb0() est déclarée dans la méthode main() !

**fiberMan** · 16/10/2015, 13h32

Pour te guider un peu plus , tu peux t'inspirer de ceci

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
 
public class ComptageZero {
 
	public static void main(String[] args) {
		int[][] carte = {
	            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0},
	            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
	            {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	            {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0},
	            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0},
	            {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0},
	            {0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,0},
	            {0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
	            {0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
	            {0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0},
	            {0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0},
	            {0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
	            {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0},
	            {0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
	            {0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
	        };
 
		//Declare un array qui va contenir le nombre de zeros
		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] );
		}
 
	}
 
}

**hoturi** · 16/10/2015, 15h18

Envoyé par joel.drigo

La méthode que t'as donnée @EyZox est pour faire le calcul pour une ligne : il faut évidemment parcourir les lignes du tableau (à 2 dimensions) et appeler pour chaque ligne cette méthode.

Par ailleurs, une méthode se déclare dans le corps de la classe, pas dans le corps d'une méthode (dans ton code, la méthode nb0() est déclarée dans la méthode main() !

Je viens de comprendre en regardant les cours de la semaine suivante, qui explique comment utiliser des méthode, je dois donc résoudre mon exercice sans utiliser de méthode. Je suis donc sur une mauvaise piste.
Franchement je commence a me poser des questions sur la difficultés des exercices proposés par ces cours en ligne.

Je vous poste le sujet de l'exo parce que si vous avez une idée de comment le faire avec des connaissances limité à savoir, itération, boucle , condition, et tableau (fixe et dynamique) je dis bravo:

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
import java.util.ArrayList;
 
class Cloture {
    public static void main(String[] args) {
        int[][] carte = {
            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0},
            {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0},
            {0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
        };
 
        /*******************************************
         * Completez le programme Ã* partir d'ici.
         *******************************************/
 
        System.out.print("Votre carte du terrain n'a pas le bon format :\nvaleur '");
        System.out.print("' trouvÃ©e en position [");
        System.out.print("][");
        System.out.println("]");
 
        System.out.println("Votre carte du terrain n'a pas le bon format :");
        System.out.print("bord extÃ©rieur entrant trouvÃ© en position [");
        System.out.print("][");
        System.out.println("]");
 
        System.out.print("Il vous faut ");
        System.out.println(" mÃ¨tres de clÃ´ture pour votre terrain.");
 
        /*******************************************
         * Ne rien modifier aprÃ¨s cette ligne.
         *******************************************/
    }
}

ET voici la première partie de l’énoncé, la suite est tellement complexe que je n'y songe même pas.

Le propriétaire dispose d'une représentation de ses terrains sous forme digitalisée: un terrain y est représenté par le biais d'un tableau binaire à deux dimensions. Les 1 y représentent des plaques carrées faisant partie du terrain et les 0 celles n'en faisant pas partie.

Il s'agit donc dans cet exercice de calculer le nombre de mètres de clôture nécessaire pour entourer un terrain donné selon ce format. Pour cela, il faudra compter le nombre de 1 constituant le pourtour du terrain. Chaque 1 du pourtour correspond à 2.50 mètres de clôture pour chacun de ses cotés qui sont au bord du terrain.

Par exemple, le terrain

1
(tout seul) qui représente un tout petit terrain carré de 2.5 m de coté, nécessitera 10 (= quatre fois 2.5) mètres de clôture.

Le terrain

0110
0110
aura besoin de 20 m de clôture, et le terrain

0111110
0111110
0111110
de 40 m.

Le problème est un peu compliqué par le fait que le terrain peut contenir des étangs. L'intérieur des étangs est aussi représenté par des 0, mais le pourtour d'un étang ne doit pas être comptabilisé dans le périmètre du terrain.

Exemple de terrain digitalisé avec des étangs à l'intérieur:

00000000000000000000000000000111111100000
00000000000000000000000000011111111111110
00000000000011111111111111111111111111111
00111111111111111111111111111111111111111
01111111111111111111111111111111111111111
11111111111111111111111111111111111111111
11111111111111111111111111111111111111111
11111111111111111111111111111111111111111
01111111111111100111111111111111111111111
01111111111111100111111111111000111111100
01111111111111100111111111110000111111100
00111111111111100111111111100001111111100
00011111111110001111111111100011111110000
00011111111100000011111111111111111110000
00011111111000000000011111111111111110000
00000111110000000000001111111111110000000
00000011111100000000111111111111100000000
00000111111110000001111111111111110000000
00011111111111000011111111111111111000000
00011111111111110111111111111111100000000
00001111111111111011111111111111000000000
00000111111111111101111111111100000000000
00000111111111111111111111110000000000000
00000111111111111111111111100000000000000
00000001111111111111111111110000000000000
00000011111111111111111111100000000000000
00000011111111111111111111100000000000000
00000011111100000000000000000000000000000
00000011000000000000000000000000000000000
qui correspondrait au terrain suivant:

Pour simplifier, on supposera :

que le terrain est « en un seul morceau »: il n'existe pas de zones du terrain déconnectées les unes des autres;

qu'il n'y a pas de ligne ne contenant que des 0;

que le pourtour extérieur du terrain est « convexe par ligne », c'est-à-dire que pour chaque ligne de l'image du terrain (mais on ne fait pas cette hypothèse pour les colonnes! Voir l'exemple ci-dessus.), les seuls 1 du pourtour extérieur sont le premier et le dernier présents sur la ligne (mais il peut n'y en avoir qu'un seul lorsque le premier et le dernier sont le même: « 000010000 ».); on ne peut pas avoir une ligne comme cela : « 0011110001111 » où les 0 du milieu seraient des 0 extérieurs; ce sont dans ce cas forcément des 0 d'un étang.

Tout cela pour garantir qu'un 0 est donc à l'intérieur du terrain (étang) si, sur sa ligne (mais pas forcément sur sa colonne! Voir l'exemple ci-dessus.), il y a au moins un 1 qui le précède et au moins un 1 qui le suit.

3.3 Le code à produire
Le code que vous écrirez commencera par vérifier que le tableau fourni (carte) contient bien uniquement des 0 et des 1. Si tel n'est pas le cas, un message d'erreur respectant strictement le format suivant sera affiché (avec les sauts de ligne):

Votre carte du terrain n'a pas le bon format :
valeur '2' trouvée en position [8][7]
Le programme arrêtera dans ce cas son exécution. Notez que le tableau que nous donnons dans le code fourni sera remplacé par d'autres tableaux pour tester votre code.

Si le tableau carte représentant le terrain est correct, votre programme affichera alors le nombre de mètres de clôture nécessaires en respectant strictement le format d'affichage donné dans les exemples d'exécution donnés plus bas (y compris le saut de ligne en fin de message).

Indications:

Une façon simple de procéder consiste à d'abord « effacer » les étangs (en remplaçant les 0 des étangs par des 1), puis procéder ensuite au comptage des 1 situés sur le pourtour.

Un point du pourtour peut avoir plusieurs 0 comme voisins (par exemple un 0 au dessus et un 0 à gauche). Il doit dans ce cas être comptabilisé autant de fois dans la clôture (deux fois dans l'exemple).

Pour forcer la sortie de la méthode main, si vous estimez que l'exécution doit s'arrêter à un certain point, vous pouvez utiliser l'instruction return;.

**joel.drigo** · 16/10/2015, 15h39

Dans ce cas élimine la méthode et passer son code dans la boucle principale... c'est simple dans ce cas.

Là tu as :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
int nb0(int[] ligne) {
    int nb0=0;
    //if(ligne != null) { // je vire cette condition qui n'a pas d'intérêt dans ton cas (tu as une carte à l'origine, elle existe et elle contient des lignes qui existent...
        for(int i : ligne) {
	     if( i == 0) {
		nb0++;
	     }else {
	        break;
	     }
	}
    //} 
    return nb0;
}

et l'appel serait comme ça :

Code :

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

1
2
3
// boucle sur les lignes du tableau (par exemple <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block"><span style="color: #0000ff;">for</span><span class="br0">(</span><span style="color: #0000ff;">int</span><span class="br0">[</span><span class="br0">]</span> ligne : carte <span class="br0">)</span></span>, ou voir l'exemple de @fiberMan)
int nb0 = nb0(ligne);
... faire le traitement qu'on veut sur nb0

et ben ça devient :

Code :

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

1
2
3
4
5
6
7
8
9
10
// boucle sur les lignes du tableau (par exemple <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block"><span style="color: #0000ff;">for</span><span class="br0">(</span><span style="color: #0000ff;">int</span><span class="br0">[</span><span class="br0">]</span> ligne : carte <span class="br0">)</span></span>, ou voir l'exemple de @fiberMan)
    int nb0 =0; 
    for(int i : ligne) {
       if( i == 0) {
  	  nb0++;
       }else {
          break;
       }
    } 
... faire le traitement qu'on veut sur nb0

Simplement.

**thelvin** · 16/10/2015, 15h54

Il n'y a pas de bravo qui tienne. Trouver la solution ne dépend pas des outils qu'on connaît (classes, méthodes, membres en plus des boucles et tableaux) mais de l'imagination.
Pour ce problème, tableaux et boucles sont largement suffisants, et méthodes des classes n'apportent pas grand-chose.

La difficulté vient de cette oppression, ce manque d'habitude d'exprimer ses idées en code. Quand on a développé l'habitude, cette difficulté n'existe plus, en tout cas pas pour ce problème.
Passer ce stade est une bonne chose, une marque de progrès, et faut savoir être fier de progresser. Mais ça ne force pas l'admiration.

Boucles, conditions et tableaux suffisent pour ce problème.
Mais il faut bien le faire en deux étapes comme expliqué, et il faut bien se rappeler pour la première étape, que le terrain est convexe par ligne. Ça aide beaucoup. On peut traiter chaque ligne indépendamment des autres.

**hoturi** · 16/10/2015, 16h05

Merci Joel c'est ce que j'ai fait mais je me demande si cela est vraiment utile pour résoudre mon exercice.

Je pensé trouver la position du premier 1 et di dernier 1 de chaque ligne et ensuite faire une comparaison d'une ligne à l'autre afin de calculer les mètres de clôtures qui sont nécessaire :

exemple :

0001111000 D1 = 3 et F1 = 7
0011111100 D2 = 2 et F2 = 8
0001110000 D3 = 3 et F3 = 6

on a donc :

ligne 1 :
Métre cloture nord (bord extérieur du haut) = (10- (F1-D1))*2.5 = 4 *2.5

ligne 2 :
Métre de cloture nord = ((D1-D2) + (F2-F1)) * 2.5 = 2*2.5

ligne 3 :
Métre de cloture nord = (10 - (F3-D3))*2.5 + ((D3-D2) + (F2-F3)) * 2.5 = 3*2.5+3*2.5

Calcul de la cloture total : Ligne1+ligne2+ligne3+ (nbligne*2*2.5) = 10+5+15+15= 45

EN créant plein de condition pour chacune des possibilitées, ( D1<D2 ou D1>D2,.....). Je ne sais pas si cela est le plus simple mais je ne vois pas d'autre solution.

**joel.drigo** · 16/10/2015, 16h19

Envoyé par hoturi

Merci Joel c'est ce que j'ai fait mais je me demande si cela est vraiment utile pour résoudre mon exercice.

Si tu parles du pavé que tu as mis dans ton dernier post, j'en doute oui... moi je répondais à la question initiale que tu as posée, et des questions subséquentes...

Je pensé trouver la position du premier 1 et di dernier 1 de chaque ligne et ensuite faire une comparaison d'une ligne à l'autre afin de calculer les mètres de clôtures qui sont nécessaire :

A ta place, je relirais le sujet et la remarque de @Thelvin. Ensuite, procéder par étape, comme le conseil le sujet (commence donc par "effacer" les étangs - la remarque sur la convexité est utile dans ce cas). Ensuite tu auras un pavé de 1 dans un océan de 0 : ensuite les clôtures n'étant que sur les "faces" de 1 exposées face à des 0 (ou à l'extérieure de la carte), le problème ne devrait pas être difficile à résoudre (la solution repose essentiellement sur du comptage (le résultat du comptage est à multiplié par 2,50m à la fin)).

**hoturi** · 16/10/2015, 16h56

Envoyé par joel.drigo

Si tu parles du pavé que tu as mis dans ton dernier post, j'en doute oui... moi je répondais à la question initiale que tu as posée, et des questions subséquentes...

A ta place, je relirais le sujet et la remarque de @Thelvin. Ensuite, procéder par étape, comme le conseil le sujet (commence donc par "effacer" les étangs - la remarque sur la convexité est utile dans ce cas). Ensuite tu auras un pavé de 1 dans un océan de 0 : ensuite les clôtures n'étant que sur les "faces" de 1 exposées face à des 0 (ou à l'extérieure de la carte), le problème ne devrait pas être difficile à résoudre (la solution repose essentiellement sur du comptage (le résultat du comptage est à multiplié par 2,50m à la fin)).

Si je comprends il faut compter les faces qui sont entouré par des 0, mais je ne comprend pas comment le faire sans comparer les lignes, les unes avec les autres.
Ma solution de trouver la position du premier et du dernier 1 sur chaque ligne n'est donc pas utile?

Une idée me vient est il possible de lire les nombres présents sur 2 lignes en même temps et de les comparer :

001100
011110

si y[i][j]=0 et y[i][j+1] = 1 on a donc = 2.5 ; on avance comme cela dans le tableau et on incrémente afin de calculer à chaque tour de la boucle le nombre de métres de cloture??

**joel.drigo** · 16/10/2015, 17h11

Envoyé par hoturi

Ma solution de trouver la position du premier et du dernier 1 sur chaque ligne n'est donc pas utile?

Ce n'est utile que dans une version optimisée : si tu comptes les cases qui contiennent 0 autour d'un 1 entouré que de 1, tu obtiens 0 : simplement, on va compter autour de 1 dont on sait qu'il ne faut pas les compter. En revanche, si connaitre le premier et le dernier est utile pour en pas compter des 0 autour de certains 1, ce n'est pas suffisant pour la première ligne et la dernière (surtout qu'on est pas forcément convexe par colonne).
Imagines qu'on ait :

ou même

ou le 1 surligné, n'est ni le premier ni le dernier de sa ligne, mais dispose d'un 0 au-dessus, donc compte pour 2,50m de clôture (pour la partie en haut, il suffirait de conserver les positions du premier et dernier de la ligne précédente, et faire des comparaisons et des différences pour connaitre les longueurs des côtés exposés, mais pour la partie en bas, c'est un petit peu plus complexe (il faut faire un traitement de la ligne n dans l'itération qui traite la ligne n-1).

**hoturi** · 16/10/2015, 19h07

1/ Je comble les étangs avec des 1

2/ Je fait un premier calcul pour calculer le nombre de mètre de clôture pour la première ligne.
2'/ Je fait la même chose mais pour la dernière ligne.

3/ Si y[i+1][j+1]=0 et y[i+1][j+2] = 1 on a donc = 2.5 (en partant depuis la gauche)
3'/ Je fais la même chose que précédemment en partant depuis la droite et dans le sens inverse.

4/ je multiplie le nombre de ligne par 2.5*2 pour avoir la clôture de parte et d'autre de mon terrain.

5/ j'additionne les étapes 2,2',3,3',4 ce qui me donne ma clôture total.

Cela est il une bonne marche à suivre ou bien je suis encore loin d'avoir compris la méthode que l'exercice veut me faire suivre.

Merci d'avance

**hoturi** · 17/10/2015, 01h19

Je n'ai pas encore compris comment combler les étangs par contre j'ai commencé un code qui semble être en bonne voie pour calculer le contour de mon terrain :

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
import java.util.ArrayList;
 
class exercices {
    public static void main(String[] args) {
        int[][] carte = {
            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
            {0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0},
            {0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,0,0},
            {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
            {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0},
            {0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
            {0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
        };
 
        /*******************************************
         * Completez le programme Ã* partir d'ici.
         *******************************************/
 
 
 
{int j;
int count = 0;
 
	for (j=0 ;j<carte[0].length;j++){	
			if (carte[0][j]>0){count++;}
 
    }double a=count*2.5;
    System.out.println(a);
}
 
 
{int k;
int count1 = 0;
 
	for (k=0 ;k<carte[carte.length-1].length;k++){	
			if (carte[carte.length-1][k]>0){count1++;}
 
    }double b=count1*2.5;
    System.out.println(b);
}
 
{int l, m;
int count2=0;
 
    for (l=0 ;l<carte.length-1;l++){ 
    	for (m=0; m<carte.length-1;m++){ 
    		if (carte [l][m]==0 && carte[l+1][m]==1 ){count2++;}	
    		}}double c=count2*2.5;
        System.out.println(c);
    }}}

pouvez vous me dire si celui-ci vous semble correct?

Merci d'avance ( je sais il est moche).

Invité · 19/10/2015, 10h28

Indentes correctement ton code s'il te plait et donnes des noms explicites à tes variables.
En donnant des noms aussi généraux ou imprécis à tes variables tu te compliques la tâche (et la notre aussi btw).

Je suis aussi d'accord avec @thelvin.

Le but de l'exercice, c'est de te forcer à acquérir une façon de raisonner que tu n'as pas encore.
Tu verras qu'avec l'habitude, tu trouveras ce genre de problème très simple à traiter.
La différence probable avec tes précédents exercices, c'est qu'ici on ne te demande pas d'apprendre une syntaxe ou un concept qui s'apprend par cœur et que l'on ressort sur un exercice très guidés. Ici, on te demande de raisonner a partir de ces concepts (ici tableaux boucles variables) sur un vrai problème et mis à part quelques pistes dans l'énoncé, tout reste à faire, tout est à ta charge, de la traduction de l'énoncé à la résolution du problème. C'est malheureusement un cap à passer, mais c'est ce qui fait la grande partie de la valeur ajoutée qu'apporte un développeur. Rassures toi, je pense ne pas dire de bêtise en écrivant qu'on est tous passé par là.

**hoturi** · 19/10/2015, 16h59

bon j'ai travaillé un peu sur mon code il me manque toujours la partie ou je comble les étangs je n'ai pas encore trouvé la solution (je seiche un peu sur cette phase), par contre j'ai terminé mon code pour la longueur de clôture qu'il faut.

Le voila si vous avez des remarques et si quelqu'un peut m'aiguiller pour combler ces fichus étang je vous remercie :

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
class exercices {
    public static void main(String[] args) {
        int[][] carte = {
            {0,0,0,1,1,1,1,0,0,0},
            {1,1,1,1,1,1,1,1,1,1},
            {0,0,1,1,0,1,1,0,0,0},
 
 
        };
 
        /*******************************************
         * Completez le programme Ã* partir d'ici.
         *******************************************/
 
{  
 
 
int i,j;
int count = 0;
int count1 = 0;
int count2 = 0;
int count3 = 0;
 
 
// ----------cloture sur les cotés |1|:
for (i=0 ;i<carte.length;i++){ 
	for (j=0; j<carte[i].length-1;j++){ 
		if (carte [i][j]==0 && carte[i][j+1]==1 ){count++;}
		if (carte [i][j]==1 && carte[i][j+1]==0 ){count1++;}
 
 
	}}double trancheG=count*2.5;
	  double trancheD=count1*2.5;
 
 
for (i=0 ;i<carte.length;i++){      
		if (carte [i] [0]==1 ){count2++;}		
		if (carte [i] [carte[i].length-1]==1){count3++;}
 
	}double trancheDsp=count2*2.5;
     double trancheGsp=count3*2.5;
 
double bordure = trancheD+trancheG+trancheDsp+trancheGsp;
 
//-----------cloture dessus premiére ligne :
count =0;
 
	for (j=0 ;j<carte[0].length;j++){	
			if (carte[0][j]>0){count++;}
 
    }double a=count*2.5;
    System.out.println ( "dessus " +a);
 
//-----------cloture dessous derniére ligne :
 count = 0;
 
	for (j=0 ;j<carte[carte.length-1].length;j++){	
			if (carte[carte.length-1][j]>0){count++;}
 
    }double b=count*2.5;
    System.out.println("dessous " +b);
 
//-----------cloture entre la premiére et derniére ligne :
count = 0;
count1=0;
 
    for (i=0 ;i<carte.length-1;i++){ 
    	for (j=0; j<carte[i].length;j++){ 
    		if (carte [i][j]==0 && carte[i+1][j]==1 ){count++;}
    		if (carte [i][j]==1 && carte[i+1][j]==0 ){count1++;}
 
 
    		}}double c=count*2.5;
    		double d=count1*2.5;
 
        System.out.println("gauche " +c);
        System.out.println("droite " +d);
 
//-----------cloture total :
        System.out.println ("total = " +(bordure+a+b+c+d));
 
    }}}

**joel.drigo** · 19/10/2015, 17h22

Envoyé par hoturi

bon j'ai travaillé un peu sur mon code il me manque toujours la partie ou je comble les étangs je n'ai pas encore trouvé la solution (je seiche un peu sur cette phase),

Il fallait pourtant commencer par là vu l'énoncé, et c'est normal, c'est ce qui simplifie le calcul de la longueur de clôture.

Tout est dans la phrase qui précise qu'on est "convexe par ligne" :

que le pourtour extérieur du terrain est « convexe par ligne », c'est-à-dire que pour chaque ligne de l'image du terrain (mais on ne fait pas cette hypothèse pour les colonnes! Voir l'exemple ci-dessus.), les seuls 1 du pourtour extérieur sont le premier et le dernier présents sur la ligne (mais il peut n'y en avoir qu'un seul lorsque le premier et le dernier sont le même: « 000010000 ».); on ne peut pas avoir une ligne comme cela : « 0011110001111 » où les 0 du milieu seraient des 0 extérieurs; ce sont dans ce cas forcément des 0 d'un étang.

C'est pour ça que je te disais de relire ton énoncé. C'est écrit noir sur blanc : "on ne peut pas avoir une ligne comme cela : « 0011110001111 » où les 0 du milieu seraient des 0 extérieurs; ce sont dans ce cas forcément des 0 d'un étang". Donc à partir du moment où tu connais le premier 1 de la ligne et le dernier, tous les 0 qui sont entre les deux appartiennent à des étangs : à partir de là, c'est trivial d'"effacer" les étangs ! Et quand les étangs sont effacés, tout l'espace à clôturer est une île de de 1 dans un océan de 0 : donc la longueur de clôture, c'est le nombre de faces (de case contenant 1) adjacentes avec une case qui contient 0 ou un bord, multiplié par 2,50m...

**hoturi** · 19/10/2015, 17h27

Ok je comprends je ne peux pas avoir ce type de carte :

00011110000
00110011000
00110001100

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.

Merci me manque plus qu'a le faire.

Trouver le nombre valeur 0 avant une valeur définie dans un tableau dynamique

Collection et Stream Java

Discussions similaires

Partager

Partager