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

Version imprimable

Voir 40 message(s) de cette discussion en une page

21/10/2015, 15h15
joel.drigo

Code:

for (int j = carte[i].length-1; j >= carte.length ; j--){

Tu ne te rends pas compte que c'est pas bon, et incohérent ?

Si j vaut carte[i].length-1 au début (donc l'index de la dernière colonne de la ligne), et qu'on cherche à boucle tant que j est >= à carte.length, le nombre de lignes, et qu'on décrémente j, sur un tableau carré, on fera aucune itération, parce j >= carte.length est faux dès le départ.

Tu dois itérer de la dernière colonne à la première, celle d'index 0 ! Je ne sais pas comment tu fais pour aller chercher carte.length ici... pour boucler sur un tableau, on boucle sur les bornes de ce tableau, pas sur celles d'un autre tableau (quand bien même le premier est un sous-tableau de l'autre).
21/10/2015, 16h41
hoturi

Je ne comprend pas mon erreur pourtant je trouve a chaque fois la position de mon dernier 1, dans cette exercice les sous tableaux sont toujours de même taille, je ne peux donc pas avoir ceci :

0011100
001110
0100

Par contre la taille du nombres de colonnes peux tableau peux varier en gros je suis certain d'avoir toujours le même nombres de colonnes entre chaque sous tableaux mais les tableaux testés peuvent être différents.
21/10/2015, 17h03
joel.drigo
Je ne comprends rien à ce que tu racontes. Quelle erreur ? Il y a une erreur mais ça fonctionne quand même ?
Et que vient faire le fait que toutes les lignes soient de même largeur ou pas avec ce que j'ai fait comme remarque au sujet de tes bornes, qui ne te permettent pas d'itérer sur le tableau quelque soit sa taille ?

Dans un for, on fait d'abord l'initialisation, puis on vérifie la condition de fin, s'il elle est vraie on boucle, sinon on s'arrête, donc si la condition n'est pas vérifiée pour les valeurs initiales, on n'entre pas dans la boucle;

Cette boucle ne fait rien (on y entre jamais) :
Code:

1 2 3 for(int i=-1; i>=0; i--) { System.out.println(i); }
Et c'est la version particulière pour n=0 de :
Code:

1 2 3 4 for(int i=n-1; i>=n; i--) { System.out.println(i); }
et si n=carte.length, c'est exactement ta boucle

Oui j'ai compris il faut que je remplace par 0 tous simplement.

bon au final avec pas mal de difficulté et beaucoup de persévérance voici mon code (en esperant que celui-ci n'a pas encore une erreur):

Code:

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
    //------------------------------------------------------------------------------------------
        int i,j; // **
 
 
        for(i=0;i<carte.length;i++){
        for(j=0;j<carte[0].length;j++){
        if(carte[i][j]==1 ||carte[i][j]==0){}
        else{System.out.print("Votre carte du terrain n'a pas le bon format :\nvaleur '");
        System.out.print(carte[i][j]+"'"+" trouvée en position ["+i+"]["+j+"]");
        return;}
 
        if(carte[i][j]>1 ||carte[i][j]<0){
        System.out.print("Votre carte du terrain n'a pas le bon format :\nvaleur '");
        System.out.print(carte[i][j]+"' trouvée en position [");
        System.out.print(i+"][");
        System.out.println(j+"]");
        return;
        			}
        		}
        	}
 
 
        int [] nombreZerosG = new int[carte.length];
        int [] nombreZerosD = new int[carte.length];
 
      //Détermination du premier 1 de la ligne
 
     for( i = 0; i < carte.length;i++) {
		int count = 0;
		int [] sequences = carte[i];
		for(int bit : sequences) {
				if(bit == 1) {
					break;
				}
				++count;
			}
			nombreZerosG[i] = count;
		}
 
 
	//Comptabe détermination du dernier 1 de la ligne    
	       {  for ( i = 0; i < carte.length ; i++){
		    	int count = 0;			
				for ( j = carte[i].length-1; j >= 0 ; j--){
					if(carte[i][j] == 1) {
							break;
						}
						++count;
					}
					nombreZerosD[i] = carte[i].length-count;	
	       }
 
	//Combler les étangs (remplacer les 0 par des 1)
	for (  i = 0; i < carte.length; i++)
	{
		for ( j = nombreZerosG[i]; j < nombreZerosD[i]; j++)
 
			if (carte[i][j]==0){
				carte [i][j] = 1;}
 
				j++;
 
			}
    }
 
        {  
        	int count = 0;
        	int count1 = 0;
        	int count2 = 0;
        	int count3 = 0;
 
 
     // ----------cloture sur les cotés |1|:
        	double bordure =  (carte.length)*2*2.5;
 
    //-----------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;
 
 
    //-----------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;
 
 
     //-----------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;
 
 
 
      //-----------cloture total :
 
        	        System.out.print("Il vous faut " +(bordure+a+b+c+d));
        	        System.out.println(" mètres de clôture pour votre terrain.");
        	                	    }

Un grand merci a Joel pour sa patience et ses conseils.

Je n'ai pas regardé en détail tous les calculs que tu fais pour déterminer la longueur de la clôture, parce que c'est une petite usine à gaz. As-tu vérifié que ça donnait les bons résultats (au moins pour les 2 qu'on te donne dans le sujet) ? Pense au moins à indenter correctement, que ça soit un minimum lisible (je parle en particulier des trucs comme ça }double a=count*2.5; : à la ligne après } !).

Maintenant que tu as fini, je te donne une solution, afin que tu puisses comparer la complexité avec la tienne (à ne surtout pas utiliser si tu ne peux pas expliquer son fonctionnement).

Code:

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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
public class Exercice {
 
   private static final int[][] CARTE1 = {
            {0,0,0,0,0,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},
        };
 
    private static final int[][] CARTE2 = {
            {0,1,1,0},
            {0,1,1,0}
    };
 
    private static final int[][] CARTE3 = {
            {0,1,1,1,1,1,0},
            {0,1,1,1,1,1,0},
            {0,1,1,1,1,1,0}
    };
 
    private static final int[][] CARTE4 = {
            {0,1,1,1,1,1,0},
            {0,1,0,0,0,1,0},
            {0,1,1,1,1,1,0}
    };
 
    private static final int[][] CARTE5 = {
            {0,1,1,1,1,1,0},
            {0,0,1,0,1,0,0},
            {0,1,1,1,1,1,0}
    };
 
    public static void main(String[] args) {
 
        int[][] carte = CARTE1; // remplacer CARTE1, par CARTE2, CARTE3... pour tester sur différents cas.
 
        System.out.println("Carte :");
        for(int[] ligne : carte) {
            for(int item : ligne) {
                System.out.print(item);
            }
            System.out.println();
        }
 
        // on "efface" les étangs
        for(int[] ligne : carte) {
            int premierUnAGauche = -1;
            for(int index=0; premierUnAGauche==-1 && index<ligne.length; index++) {
                if ( ligne[index]==1 ) {
                    premierUnAGauche=index;
                }
            } 
            if ( premierUnAGauche>=0 ) { // inutile de chercher le dernier un à droite, il n'y en a pas dans la ligne
                int dernierUnADroite = -1;
                for(int index=ligne.length-1; dernierUnADroite==-1 && index>=0; index--) {
                    if ( ligne[index]==1 ) {
                        dernierUnADroite=index;
                    }
                }
 
                if ( premierUnAGauche<dernierUnADroite ) { // s'ils sont égaux, on a qu'un seul un dans la ligne : rien à remplir donc
                    for(int index=premierUnAGauche; index<dernierUnADroite; index++) {
                        if ( ligne[index]==0 ) { // on n'est pas obligé de faire ce test : si on le fait pas, on remplace des 1 par 1
                            ligne[index]=1;
                        }
                    }
                }
 
            }
        }
 
        System.out.println("Carte avec les étangs \"effacés\"");
        for(int[] ligne : carte) {
            for(int item : ligne) {
                System.out.print(item);
            }
            System.out.println();
        }
 
        // on compte les faces exposées
        int nbFaces = 0;
 
        for(int i=0; i<carte.length; i++) {
            for(int j=0; j<carte[i].length; j++) {
 
                if ( carte[i][j]==1 ) {
                    // on compte les 0 en dessous, au dessus, à droite et à gauche
                    // au dessus [i-1][j], (correspond à (-1,0) dans la notation ci-après)
                    // en dessous [i+1][j] (correspond à (1,0))
                    // à gauche [i][j-1] (correspond à (0,-1)
                    // à droite [i][j+1] (correspond à (0,1)
                    // si on boucle de -1 à +1 selon les deux axes,
                    // il suffit d'éliminer le centre (0,0) et les coins (-1,-1), (-1,1), (1,-1), (1,1)
                    // on remarque que les éléments à éliminer sont ceux tels que les deux sont égaux, ou égaux au signe près
                    for(int di=-1; di<=1; di++) {
                        for(int dj=-1; dj<=1; dj++) {
                            if ( !( (di==dj) || (di==-dj) ) ) {
                                int y=i+di;
                                int x=j+dj;
                                if ( x<0 || x>=carte[i].length || y<0 || y>=carte.length ) {
                                    // on est en dehors de la carte
                                    // ça compte pour une case vide (donc une face exposée)
                                    nbFaces++;
                                }
                                else if ( carte[y][x]==0 ) {
                                    nbFaces++;
                                }
                            }
                        }
                    }
                }
 
            }
        }
 
        System.out.printf("La longueur de clôture nécessaire est : %.2f mètres%n", nbFaces * 2.5 );
 
 
    }
}

21/10/2015, 20h24
hoturi

Merci Joel je vais regarder ton code mais je ne pense pas pouvoir tous comprendre car il y a des notions que je n'ai pas vu dedans.

Mon code fonctionne le correcteur me donne 100% avec. Il faut que j'indente correctement pour plus de lisibilité tu as raisons (je vais le faire afin de conserver mon code).

Cordialement.
22/10/2015, 10h02
joel.drigo

A part le for-each (for(int[] ligne : carte) {) peut-être, je me suis efforcé de n'utiliser que des tableaux et des structures (pas de méthodes en tout cas, ce que j'aurais utilisé si j'avais dû faire un tel exercice, en particulier pour compter les faces d'un 1 exposées à un 0).

Voir 40 message(s) de cette discussion en une page