inclure des booleans dans une boucle

Version imprimable

bonjour,je suis encore bloquer depuis ce matin
voici mon programme,il marche bien par contre je dois mettre des variables booleans pour que mes conditions de if soit moins aproximatives ,le soucis c est que de que je cree des variables ex "boolean ouvertureParachute = ht<2500 ;"et ensuite if(ouvertureParachute){ ....je voudrais l inscrire qu'une fois alors que ça s' inscrit à chaque tour de boucle jusqu'a la fin du code.Je ne dois pas chercher encore dans la bonne direction ...
merci de m 'aiguiller un peu..

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
import java.util.Scanner;
 
class Parachutiste {
 
    public static void main(String[] args) {
 
        Scanner clavier = new Scanner(System.in);
 
        double masse = 80.0;
        do {
            System.out.print("masse du parachutiste (>= 40) ? ");
            masse = clavier.nextDouble();
        } while (masse < 40.0);
 
        double h0 = 39000.0;
        do {
            System.out.print("hauteur de depart du parachutiste (>= 250) ? ");
            h0 = clavier.nextDouble();
        } while (h0 < 250.0);
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
        //attributs,déclaration et initialisation
        final double G =9.81;
        double v0 =0.0;
        double t0 = 0.0;
        double vitesse = v0;
        double hauteur=h0;
        double t = t0;
        double accel=G;
        double surface =2.0;
 
        //calcul chute libre
 
        for( t = 0 ;t <=170 ;t++) {
 
        	double s =surface/masse;       
	        double q = Math.exp(-s*(t-t0));        
	        double vt =( G/s)*(1-q)+(v0*q);       
	        double ht = h0-(G/s)*(t-t0)-((v0-(G/s))/s)*(1-q);        
	        double at = G -(s*vt);
 
 
 
 
        	if(vt>=343 && vt<344) {
        		System.out.println("## Felix dépasse la vitesse du son");
        	}
        	if(at>=0.48 && at <0.50) {
        		System.out.println("## Felix a atteind sa vitesse max");
        	}
 
    		if(ht<2500 && ht>2300) {
        		System.out.println("## Felix ouvre son parachute");
        		surface =25;
        		t0=t;
        		v0=vt;
        		h0=ht;
 
    		}
 
        	System.out.printf("%.0f, %.4f, %.4f, %.5f\n",t, ht, vt, at);
 
        	}
 
 
 
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
        clavier.close();
    }
}

24/07/2019, 21h04
joel.drigo

Salut,

On ne voit pas ouvertureParachute dans ton code, ni déclaration, ni utilisation. C'est indispensable pour pouvoir te répondre.

Alors voilà,avec ce code je n'arrive pas à afficher la phrase "felix ouvre son parachute " qu 'une seule fois?

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
import java.util.Scanner;
 
class Parachutiste {
 
    public static void main(String[] args) {
 
        Scanner clavier = new Scanner(System.in);
 
        double masse = 80.0;
        do {
            System.out.print("masse du parachutiste (>= 40) ? ");
            masse = clavier.nextDouble();
        } while (masse < 40.0);
 
        double h0 = 39000.0;
        do {
            System.out.print("hauteur de depart du parachutiste (>= 250) ? ");
            h0 = clavier.nextDouble();
        } while (h0 < 250.0);
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
        //attributs,déclaration et initialisation
        final double G =9.81;
        double v0 =0.0;
        double t0 = 0.0;
        double vitesse = v0;
        double hauteur=h0;
        double t = t0;
        double accel=G;
        double surface =2.0;
 
        //calcul chute libre
 
        for( t = 0 ;t <=170 ;t++) {
 
        	double s =surface/masse;       
	        double q = Math.exp(-s*(t-t0));        
	        double vt =( G/s)*(1-q)+(v0*q);       
	        double ht = h0-(G/s)*(t-t0)-((v0-(G/s))/s)*(1-q);        
	        double at = G -(s*vt);
	        boolean ouvertureParachute;
	        ouvertureParachute = ht<2500;
 
 
 
 
        	if(vt>=343 && vt<344) {
        		System.out.println("## Felix dépasse la vitesse du son");
        	}
        	if(at>=0.48 && at <0.50) {
        		System.out.println("## Felix a atteind sa vitesse max");
        	}
 
    		if(ouvertureParachute) {
        		System.out.println("## Felix ouvre son parachute");
        		surface =25;
        		t0=t;
        		v0=vt;
        		h0=ht;
 
    		}
 
        	System.out.printf("%.0f, %.4f, %.4f, %.5f\n",t, ht, vt, at);
 
        	}
 
 
 
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
        clavier.close();
    }
}

et dans ce deuxieme code je n 'affiche plus la phrase et mes données apres l 'ouverture du parachute sont fausses ...

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
import java.util.Scanner;
 
class Parachutiste {
 
    public static void main(String[] args) {
 
        Scanner clavier = new Scanner(System.in);
 
        double masse = 80.0;
        do {
            System.out.print("masse du parachutiste (>= 40) ? ");
            masse = clavier.nextDouble();
        } while (masse < 40.0);
 
        double h0 = 39000.0;
        do {
            System.out.print("hauteur de depart du parachutiste (>= 250) ? ");
            h0 = clavier.nextDouble();
        } while (h0 < 250.0);
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
        //attributs,déclaration et initialisation
        final double G =9.81;
        double v0 =0.0;
        double t0 = 0.0;
        double vitesse = v0;
        double hauteur=h0;
        double t = t0;
        double accel=G;
        double surface =2.0;
 
        //calcul chute libre
 
        for( t = 0 ;t <=170 ;t++) {
 
        	double s =surface/masse;       
	        double q = Math.exp(-s*(t-t0));        
	        double vt =( G/s)*(1-q)+(v0*q);       
	        double ht = h0-(G/s)*(t-t0)-((v0-(G/s))/s)*(1-q);        
	        double at = G -(s*vt);
	        boolean ouvertureParachute;
	        ouvertureParachute = ht<2500;
	        boolean parachuteOuvert;
	        parachuteOuvert = false;
 
 
 
        	if(vt>=343 && vt<344) {
        		System.out.println("## Felix dépasse la vitesse du son");
        	}
        	if(at>=0.48 && at <0.50) {
        		System.out.println("## Felix a atteind sa vitesse max");
        	}
        	if(parachuteOuvert = false) {
	    		if(ouvertureParachute) {
	        		System.out.println("## Felix ouvre son parachute");
	        		surface =25;
	        		t0=t;
	        		v0=vt;
	        		h0=ht;
	        		parachuteOuvert = true;
	    		}
    		}
 
        	System.out.printf("%.0f, %.4f, %.4f, %.5f\n",t, ht, vt, at);
 
        	}
 
 
 
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
        clavier.close();
    }
}

24/07/2019, 23h58
Gaillac

Bonsoir,

dans le second cas le booléen parachuteOuvert est remis à faux à chaque itération, et est donc strictement inutile. Pour l'utiliser il faudrait sortir cette initialisation de la boucle.
Ensuite l’opérateur de comparaison c'est ==, pas =, donc if(parachuteOuvert == false), couramment abrégé en if(!parachuteOuvert).
Et là Félix ouvre son parachute.
Par contre 2 mauvaises nouvelles pour lui : ça ne le ralenti pas, et il continue même sous terre, jusqu'à ce que les 170 itérations se terminent :lol:.

Bonne soirée
25/07/2019, 09h19
joel.drigo

Dans le premier code, le souci est que le test vaut ht<2500 et non pas ht<2500 && ht>2300 comme dans le premier code, donc forcément les deux programmes se comportent différemment. Je suis pas fan du test initial parce qu'on peut logiquement imaginer que ce test soit vrai plusieurs fois (dans plusieurs itérations), mais c'est forcément le cas à priori pour le premier puisque ht est censé décroître forcément (à moins d'un coup de vent qui ferait remonter le parachute), à mois qu'on passe directement de ht=2500 à ht=0.

Et pour compléter ce que dit Gaillacif(parachuteOuvert = false) { consiste à affecter d'abord parachuteOuvert à false, puis à évaluer parachuteOuvert qui vaut donc forcément false, donc on n'entre pas dans le bloc du test.

La solution du booléen qui empêche de tester plusieurs fois l'altitude pour déterminer que le parachute doit s'ouvrir est une bonne idée, mais il faut évidemment que ce booléen soit déclaré et initialisé en dehors de la boucle comme l'a dit @Gaiillac (si c'est fait dans la boucle, ça signifie qu'on referme le parachute sans arrêt pendant la chute). Ensuite, à chaque itération, ouvertureParachute doit être égal à !parachuteOuvert && condition d'ouverture (en clair, on ouvre le parachute s'il n'est pas déjà ouvert et si on a atteint l'altitude d'ouverture).

+1 pour la boucle jusqu'à 170, mais c'est un autre sujet à régler après la problématique d'ouverture. Ça peut être une bonne façon de mettre au point le programme pour voir si le parachutiste atterrit bien ou traverse le sol (voir qu'à la fin, on boucle bien sur une altitude nulle).
25/07/2019, 09h40
cpiter

Citation:

Envoyé par Gaillac

Bonsoir,

dans le second cas le booléen parachuteOuvert est remis à faux à chaque itération, et est donc strictement inutile. Pour l'utiliser il faudrait sortir cette initialisation de la boucle.
Ensuite l’opérateur de comparaison c'est ==, pas =, donc if(parachuteOuvert == false), couramment abrégé en if(!parachuteOuvert).
Et là Félix ouvre son parachute.
Par contre 2 mauvaises nouvelles pour lui : ça ne le ralenti pas, et il continue même sous terre, jusqu'à ce que les 170 itérations se terminent :lol:.

Bonne soirée

bonjour,oui je le remettais à faux pour plus que ma phrase ne s'écrive pas plusieurs fois car j 'avais mis "parachute ouvert = true" donc je pensais qu on ne reviendrais plus dans la boucle mais le soucis c'est que les valeurs ne sont plus correctes apres,
merci je vais continuer avec vos indications à tous les 2
25/07/2019, 10h41
Gaillac

Oui @joel.drigo je pensais faire une réponse plus complète mais j'ai été pris par le temps et j'ai fait au plus court. Mais au minimum j'aurais du dire que = false c'est une affectation.

Bref, pour revenir à Félix, la gestion des évènements est un peu bancale.
On n'est pas à l'abri de ne jamais valider "vt>=343 && vt<344" par exemple, si lors des itérations successives vt vaut 342 puis 344. De même pour le mur du son.
Et si tu applique la même méthode des booléens, tu va multiplier les variables, surtout quand tu va aussi gérer une vitesse différente parachute ouvert, l'atterrissage, etc.

Une solution pourrait être de reconsidérer un peu le problème. Puisque son vol est constitué de plusieurs phases où le calcul de la vitesse change(ra) et où les transitions sont importantes (puisque tu veux les afficher), pourquoi ne pas envisager une sorte de diagramme d'état du vol ? De manière simplifiée, tu pourrais avoir un énuméré avec les différent états de Félix/phases du vol (dans l'avion, accélération, palier libre, décélération, palier en parachute, atterri. Encore que la phase décélération est peut-être trop rapide et violente pour qu'il y ait besoin de la prendre en compte, mais là c'est un problème de physique pas d'informatique).
Puis dans ta boucle principale, deux parties (en vrac ou dans des méthodes séparées) : calcul de la vitesse et évaluation des transitions. Calcul des vitesses suivant ton état courant, via un switch sur la phase (aller un indice : quand Félix est dans l'avion vt = 0 8-)) et donc de la nouvelle position probable (attention à la dernière itération, pour ne pas que Félix s'enterre). Puis, sur la base de ce nouveau jeu de vitesse et position, et compte tenu de la phase actuelle, le calcul de la nouvelle phase. Encore un switch sur la phase (courante) à l'intérieur duquel si la condition de transition est validée on affiche la transition et on change la phase. Par exemple dans le cas ou Félix est dans l'avion, sans condition on affiche "Félix saute" et la phase devient accélération. Ainsi à la prochaine itération, la première vitesse sera calculée. Dans ce switch, pour le cas accélération, la première condition serait donc si at >= 0.48, et dans ce cas on affiche "Félix a atteint sa vitesse max" (que l'on pourrait préciser) et passer la phase à "pallier libre". Il en faut aussi une seconde, sur l'altitude, parce que suivant l'altitude de départ Félix doit pouvoir ouvrir son parachute avant d'être au max. Et là tu vois que tu peux donc avoir des conditions similaires pour plusieurs phases. De belles améliorations en perspectives, mais chaque chose en son temps.

Assez naturellement, ta boucle for devint ainsi une boucle while où la condition d’arrêt c'est que Félix a atteint la phase atterrit.

Voilà ce n'est qu'une piste, pour éviter que ton petit algo ne devienne une machine à gaz avec trop de booléens qui vont finir par prêter à confusion. Et qui permet de faire évoluer ton algo simplement. Par exemple si dans un premier temps tu néglige la phase de décélération quand il ouvre le parachute, et qu'après tu affine et veux l'intégrer, très facile de rajouter un état et son traitement dans les switchs. De même pour une phase d’atterrissage plus complexe.

Bonne journée
25/07/2019, 11h09
joel.drigo

Citation:

Envoyé par cpiter

donc je pensais qu on ne reviendrais plus dans la boucle mais le soucis c'est que les valeurs ne sont plus correctes apres,

C'est la même confusion que tu as faite avec le for dans l'autre question. Les instructions ne sont pas des sortes de règles globales qui s'appliquent globalement. L'exécution est séquentielle, chaque instruction s'exécute l'une après l'autre et les états sont modifiés au moment de l'exécution, les conditions sont testées au moment du test, et les actions au moment où elles sont déclarées.

Le code de modification de parachuteOuvert s'effectue dans la boucle. La boucle n'est pas conditionnée par parachuteOuvert. Aucune raison donc que cette modification n'est d'impact sur la boucle et qu'elle s'arrête alors. Pour ce faire, il faut que soit tu déclenches un ordre de sortie de boucle (un break par exemple), soit que tu prennes en compte parachuteOuvert dans la condition de boucle (par exemple for( t = 0 ;t <=170 && !parachuteOuvert ;t++) {).

La solution de l'automate à état est une bonne solution, simple, efficace, lisible et facilement maintenable, mais je ne suis pas sûr que l'introduire à ce niveau d'apprentissage soit idéal, de même que pour l'introduction du switch . Personnellement, j'opterais plutôt pour une série de boucles successives, qui n'introduit qu'un travail de logique sur les conditions de bouclage/sortie de boucle (on a 2 étapes qui correspondent en gros à deux chutes de vitesse différente, une parachute fermé, une parachute ouvert, et une fin, atterrissage ou écrasement). Une solution intermédiaire pourrait être d'utiliser du if/else if à la place du switch, ce qui éviterait d'avoir à répéter les conditions globales (chute et écrasement) dans chaque boucle.
25/07/2019, 11h13
cpiter

Citation:

Envoyé par joel.drigo

Dans le premier code, le souci est que le test vaut ht<2500 et non pas ht<2500 && ht>2300 comme dans le premier code, donc forcément les deux programmes se comportent différemment. Je suis pas fan du test initial parce qu'on peut logiquement imaginer que ce test soit vrai plusieurs fois (dans plusieurs itérations), mais c'est forcément le cas à priori pour le premier puisque ht est censé décroître forcément (à moins d'un coup de vent qui ferait remonter le parachute), à mois qu'on passe directement de ht=2500 à ht=0.
oui je voulais remplacer(ht<2500&&ht>2300) avec parachute =true et comme ça ne plus rentrer dans la boucle et ne plus écrire la phrase et c'etait moins aléatoire car la j 'ai tatonné pour le 2300 donc en programmation je ne pense pas qu'on face ceci.

Et pour compléter ce que dit Gaillacif(parachuteOuvert = false) { consiste à affecter d'abord parachuteOuvert à false, puis à évaluer parachuteOuvert qui vaut donc forcément false, donc on n'entre pas dans le bloc du test.

La solution du booléen qui empêche de tester plusieurs fois l'altitude pour déterminer que le parachute doit s'ouvrir est une bonne idée, mais il faut évidemment que ce booléen soit déclaré et initialisé en dehors de la boucle comme l'a dit @Gaiillac (si c'est fait dans la boucle, ça signifie qu'on referme le parachute sans arrêt pendant la chute). Ensuite, à chaque itération, ouvertureParachute doit être égal à !parachuteOuvert && condition d'ouverture (en clair, on ouvre le parachute s'il n'est pas déjà ouvert et si on a atteint l'altitude d'ouverture).

+1 pour la boucle jusqu'à 170, mais c'est un autre sujet à régler après la problématique d'ouverture. Ça peut être une bonne façon de mettre au point le programme pour voir si le parachutiste atterrit bien ou traverse le sol (voir qu'à la fin, on boucle bien sur une altitude nulle).

j' essai comme autre boucle while(ht>0) au lieu de for avec des secondes c est plus logique de s 'arrêter avant de toucher le sol au lieu de tatonner pour voir le nombre de seconde qu'il met pour faire le saut avant de toucher le sol et l 'inscrire dans la boucle for..
25/07/2019, 11h52
Gaillac

Citation:

Envoyé par cpiter

c est plus logique de s 'arrêter avant de toucher le sol au lieu de tatonner pour voir le nombre de seconde qu'il met pour faire le saut avant de toucher le sol et l 'inscrire dans la boucle for..

D'autant plus que la masse et le hauteur du saut étant variables, la durée du saut est variable. Donc mettre une valeur fixe ne peut pas marcher.

Néanmoins

Citation:

Envoyé par joel.drigo

Ça peut être une bonne façon de mettre au point le programme pour voir si le parachutiste atterrit bien ou traverse le sol (voir qu'à la fin, on boucle bien sur une altitude nulle).

Si tu fais une boucle for avec un nombre d'itérations suffisamment grand pour que tous les cas réalistes soient couvert (170s en chute libre ça marche, quand tu aura une vitesse plus faible pour les dernier 2500 pieds ça marchera moins bien), et que tu gère el fait qu'une fois fois que Félix est à 0 il arrête de descendre, ça marche, tu aura juste plein d'itérations "au sol" où il ne se passera rien. Ce qui peut effectivement aider à mettre au point la phase atterrissage.

alors je vous met le code que j 'essai de faire qui me parais plus logique avec comme condition la hauteur et non les secondes.
et je vous poserai quelques questions sur ces portées de variables qui me pose problème,
Ce code fonctionne avec les phrases au bon endroit mais ne s'arrête pas,mais j 'essaierai de voir le problême si je comprend cette portée de variable et ensuite faire c e que joel me dit car j'ai pas vu encore les swichs

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
import java.util.Scanner;
 
class Parachutiste {
 
    public static void main(String[] args) {
 
        Scanner clavier = new Scanner(System.in);
 
        double masse = 80.0;
        do {
            System.out.print("masse du parachutiste (>= 40) ? ");
            masse = clavier.nextDouble();
        } while (masse < 40.0);
 
        double h0 = 39000.0;
        do {
            System.out.print("hauteur de depart du parachutiste (>= 250) ? ");
            h0 = clavier.nextDouble();
        } while (h0 < 250.0);
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
        //attributs,déclaration et initialisation
 
        final double G = 9.81;
        double v0 = 0.0;
        double t0 = 0.0;
        double vitesse = v0;
        double hauteur = h0;
        double t = t0;
        double accel = G;
        double surface = 2.0;
 
        //calcul chute libre
 
 
 
        while(hauteur > 0) {
        	double s = surface/masse;       
	        double q = Math.exp(-s*(t-t0));        
	        double vt =( G/s)*(1-q)+(v0*q);       
	        double ht = h0-(G/s)*(t-t0)-((v0-(G/s))/s)*(1-q);        
	        double at = G -(s*vt);
 
	        if(hauteur>2500) {
 
	        	if(vt >= 343 && vt < 344) {
	        		System.out.println("## Felix dépasse la vitesse du son");
	        	}
	        	if(at >= 0.48 && at < 0.50) {
	        		System.out.println("## Felix a atteind sa vitesse max");
	        	}
	        }
        	else {
        		System.out.println("## Felix ouvre son parachute");
        		surface = 25;
	        	t0 = t;
	        	v0 = vt;
	        	h0 = ht;
    		}
 
	        	System.out.printf("%.0f, %.4f, %.4f, %.5f\n",t, ht, vt, at);
	        	t++;
 
	        }
 
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
        clavier.close();
    }
}

alors les questions qui me poses soucis
dans mon mon affectation des attributs de la variable "G "à la variable "surface" est ce qu 'on y a accès dans toutes les boucles ?
partons du début ex :on déclare hauteur =h0;
on entre au clavier ho = 39000;
donc on se sert de cette variable dans les formules de la boucle while,
ensuite quant le parachute s 'ouvre h0 devient ht,ça veut dire que ma variable hauteur =h0 vaut :hauteur =ht ? ou quand on sort de celle on revient à hauteur =h0 ?
merci

voila le code exécuté que j ai pu arrêter

masse du parachutiste (>= 40) ? 80
hauteur de depart du parachutiste (>= 250) ? 39000
false
0, 39000.0000, 0.0000, 9.81000
true
1, 38995.1356, 9.6884, 9.56779
true
2, 38980.7030, 19.1376, 9.33156
true
3, 38956.9382, 28.3535, 9.10116
true
4, 38924.0719, 37.3418, 8.87646
true
5, 38882.3286, 46.1082, 8.65729
true
6, 38831.9276, 54.6582, 8.44355
true
7, 38773.0826, 62.9971, 8.23507

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
 
import java.util.Scanner;
 
class Parachutiste {
 
    public static void main(String[] args) {
 
        Scanner clavier = new Scanner(System.in);
 
        double masse = 80.0;
        do {
            System.out.print("masse du parachutiste (>= 40) ? ");
            masse = clavier.nextDouble();
        } while (masse < 40.0);
 
        double h0 = 39000.0;
        do {
            System.out.print("hauteur de depart du parachutiste (>= 250) ? ");
            h0 = clavier.nextDouble();
        } while (h0 < 250.0);
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
        //attributs,déclaration et initialisation
 
        final double G = 9.81;
        double v0 = 0.0;
        double t0 = 0.0;
        double vitesse = v0;
        double hauteur = h0;
        double t = t0;
        double accel = G;
        double surface = 2.0;
        boolean parachuteOuvert =false;
 
        //calcul chute libre
 
         while(hauteur > 0) {
        	double s = surface/masse;       
    		double q = Math.exp(-s*(t-t0));        
    		double vt =( G/s)*(1-q)+(v0*q);       
    		double ht = h0-(G/s)*(t-t0)-((v0-(G/s))/s)*(1-q);        
    		double at = G -(s*vt);
    		System.out.println(parachuteOuvert);
 
        	if( hauteur >2500 && !parachuteOuvert){
 
 
        		if(vt >= 343 && vt < 344) {
	        		System.out.println("## Felix dépasse la vitesse du son");
	        	}
	        	if(at >= 0.48 && at < 0.50) {
	        		System.out.println("## Felix a atteind sa vitesse max");
	        	}
        	}
	        	parachuteOuvert = true;
 
	        	if(hauteur <2500 && parachuteOuvert) {
	        		System.out.println("Felix ouvre son parachute");
	        		surface = 25;
	        		t0 =t;
	        		v0 = vt;
	        		h0 = ht;
 
	        	}
 
	        	System.out.printf("%.0f, %.4f, %.4f, %.5f\n",t, ht, vt, at);
	        	t++;
 
 
 
    	}
 
 
 
        	/*******************************************
                 * Ne rien modifier apres cette ligne.
                 *******************************************/
        	clavier.close();
    }
}

Pourquoi je ne rentre pas dans la première boucle if ? dans mon print je peux voir que ouvertureparachute =false et ensuite l'affichage m'indique hauteur 39000 mètres donc > 2500 ??
merci pour vos réponses

Citation:

Envoyé par cpiter

Ce code fonctionne avec les phrases au bon endroit mais ne s'arrête pas

Forcément, ta condition de boucle est sur la variable hauteur, or tu calcules la hauteur du parachutiste avec la variable ht... en modifiant ht, tu ne modifies pas hauteur...

Citation:

Envoyé par cpiter

dans mon mon affectation des attributs de la variable "G "à la variable "surface" est ce qu 'on y a accès dans toutes les boucles ?

Il s'agit d'une question relative à la portée des variables. Il y a deux types de portée : la portée de "classe", qui concerne les attributs de la classes, qui sont déclarés dans le corps d'une classe. Ce qui n'est pas du tout le cas. Toi tu es dans le cas d'une portée de bloc, en l’occurrence une portée de bloc de méthode, puisque tes variables sont déclarées dans une méthode (de nom main). Dans ce cas, savoir si une variable est à la portée de l'instruction est simple :

Toute variable définie dans un bloc de code est à la portée de ses sous-blocs (ceux crées à l'intérieur)
Tout variable définie dans un bloc n'est jamais à la portée des blocs qui l'entoure, qui le contienne
Attention à la problématique des classes anonymes créées dans le bloc de la méthode qui ont des blocs qui ont l'air d'être à l'intérieur des blocs de la méthode mais qui ne le sont pas (on change de classe, on n'est plus dans le cas des blocs de méthodes, tu verras ça plus tard)

Autrement dit, si tu as (je rappelle que les blocs se définissent par des accolades ({}), l'intérieur du bloc étant ce qui est compris entre les deux :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 { // on est à l'intérieur du bloc 1 int i=0; { // on est à l'intérieur du bloc 2 qui est à l'intérieur du bloc 1 int j=0; // cette variable j n'est pas à la portée du bloc 1 int k=i; // la variable i est à la portée du bloc 2, donc on peut y faire référence pour affecter la variable k qui n'est pas à la portée du bloc 1 } }
Le fait que le bloc soit une structure n'y change rien. Autrement dit, qu'il y ait if, for, while, etc, devant le bloc ne change rien à ce fonctionnement de la portée.

Citation:

Envoyé par cpiter

partons du début ex :on déclare hauteur =h0;
on entre au clavier ho = 39000;
donc on se sert de cette variable dans les formules de la boucle while,

Vu que l'instruction est double ht = h0-(G/s)*(t-t0)-((v0-(G/s))/s)*(1-q);, on se sert de h0 (entre autres), mais pas de hauteur...

Citation:

Envoyé par cpiter

ensuite quant le parachute s 'ouvre h0 devient ht,

Je ne comprends pas bien la logique de cette assertion. C'est éventuellement une question que je comptais aborder plus tard, lorsque le problème courant serait réglé, mais à l'évidence h0 est l'altitude à laquelle le parachutiste saute : pourquoi changerait-elle au moment de l'ouverture du parachute ? Même si introduire plus de variable complexifie le problème (plus de variables = plus de bugs), il est toujours préférable qu'une même variable ne serve pas à plusieurs choses différentes, ça évite toujours de faire des confusions de raisonnement.

Citation:

Envoyé par cpiter

ça veut dire que ma variable hauteur =h0 vaut :hauteur =ht ?

ça ne veut rien dire concernant la variable hauteur tant qu'on n'affecte pas une valeur à la variable hauteur avec une instruction du type hauteur = /* h0, ht, ou ce que tu veux...*/

Citation:

Envoyé par cpiter

ou quand on sort de celle on revient à hauteur =h0 ?

Manque un mot là... de celle ? c'est-à-dire ? Si c'est d'une boucle que tu parles, ou d'une condition peut-être, bah c'est pareil que ce que je viens de dire, on revient à rien du tout, hauteur a une valeur, et il n'y a qu'une affectation qui pourrait la changer...

Citation:

Envoyé par cpiter

Pourquoi je ne rentre pas dans la première boucle if ? dans mon print je peux voir que ouvertureparachute =false et ensuite l'affichage m'indique hauteur 39000 mètres donc > 2500 ??
merci pour vos réponses

Le code suivant veut dire que quelque soit les conditions, dès la première itération, la variable parachuteOuvert passe à true. Ensuite on entre dans le if si la valeur de la variable hauteur est effectivement inférieur à 2500, ce qui n'arrive jamais si h0 (la hauteur de saut saisie par l'utilisateur) est > 2500...
Code:

1 2 3 4 5 6 7 8 9 10 parachuteOuvert = true; if(hauteur <2500 && parachuteOuvert) { System.out.println("Felix ouvre son parachute"); surface = 25; t0 =t; v0 = vt; h0 = ht; }

plus je cherche et plus je me perd,je m'aperçois que si je met if à la place else if à la dernière condition je ne rentre plus dans la première boucle,et j inscris dès le debut "felix ouvre son parachute" alors que l 'on est pas en dessous de 2500 m au début?? j ai quand même réussi a exécuter le code avec la variable d altitude au lieu de temps,par contre je comprends pas non plus pourquoi je ne sors pas de la boucle while alors que je suis à -300m ?
Dans le print format j'ai mis un ParachuteOuvert pour voir l'état..
je vous met le code,la nuit porte conseil j'espère que ça ira mieux demain...merci pour votre aide

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
import java.util.Scanner;
 
class Parachutiste {
 
    public static void main(String[] args) {
 
        Scanner clavier = new Scanner(System.in);
 
        double masse = 80.0;
        do {
            System.out.print("masse du parachutiste (>= 40) ? ");
            masse = clavier.nextDouble();
        } while (masse < 40.0);
 
        double h0 = 39000.0;
        do {
            System.out.print("hauteur de depart du parachutiste (>= 250) ? ");
            h0 = clavier.nextDouble();
        } while (h0 < 250.0);
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
        //attributs,déclaration et initialisation
 
        final double G = 9.81;
        double v0 = 0.0;
        double t0 = 0.0;
        double vitesse = v0;
        double hauteur = h0;
        double t = t0;
        double accel = G;
        double surface = 2.0;
        boolean parachuteOuvert =false;
        double ht = h0;
 
        //calcul chute libre
 
		while(  ht > 0) {
        	double s = surface/masse;       
    		double q = Math.exp(-s*(t-t0));        
    		double vt =( G/s)*(1-q)+(v0*q);       
    		 ht = h0-(G/s)*(t-t0)-((v0-(G/s))/s)*(1-q);        
    		double at = G -(s*vt);
 
 
        	if( ht >2500 && !parachuteOuvert){
 
 
        		if(vt >= 343 && vt < 344) {
	        		System.out.println("## Felix dépasse la vitesse du son");
	        	}
	        	if(at >= 0.48 && at < 0.50) {
	        		System.out.println("## Felix a atteind sa vitesse max");
	        	}
        	}
        	else if(vt <2500 ){
        		parachuteOuvert = true;
        				System.out.println("Felix ouvre son parachute");
 
        	}
 
 
 
 
 
 
        	System.out.printf("%.0f, %.4f, %.4f, %.5f,%b\n",t, ht, vt, at, parachuteOuvert);
        	t++;
 
 
 
 
 
    	}
 
 
 
        	/*******************************************
                 * Ne rien modifier apres cette ligne.
                 *******************************************/
        	clavier.close();
    }
}

exécution du code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
130, 3075.4000, 377.1850, 0.38037,false
131, 2698.0264, 377.5607, 0.37098,false
Felix ouvre son parachute
132, 2320.2818, 377.9270, 0.36182,true
Felix ouvre son parachute
133, 1942.1753, 378.2844, 0.35289,true
Felix ouvre son parachute
134, 1563.7160, 378.6329, 0.34418,true
Felix ouvre son parachute
135, 1184.9124, 378.9728, 0.33568,true
Felix ouvre son parachute
136, 805.7732, 379.3043, 0.32739,true
Felix ouvre son parachute
137, 426.3065, 379.6277, 0.31931,true
Felix ouvre son parachute
138, 46.5205, 379.9430, 0.31142,true
Felix ouvre son parachute
139, -333.5769, 380.2506, 0.30374,true

25/07/2019, 23h52
Gaillac

Mais tu sorts de ta boucle.
ht vaut 46.5205, donc supérieur à 0, tu rentre dans le while.
Tu calcules le nouveau ht, qui vaut -333.5769. Tu affiches.
ht est inférieur à 0, tu sorts de la boucle.
333 pieds sous terre pour Félix, mais tu sorts.
26/07/2019, 00h13
joel.drigo

Et là else if(vt <2500 ){, ce serait pas plutôt ht que tu veux tester... vt devant être < 2500 dès la première itération, parachuteOuvert passe direct à true et on a ( ht >2500 && !parachuteOuvert) probablement jamais vrai, ce qui explique qu'on n'entre pas dans le if...
26/07/2019, 08h57
cpiter

Citation:

Envoyé par Gaillac

Mais tu sorts de ta boucle.
ht vaut 46.5205, donc supérieur à 0, tu rentre dans le while.
Tu calcules le nouveau ht, qui vaut -333.5769. Tu affiches.
ht est inférieur à 0, tu sorts de la boucle.
333 pieds sous terre pour Félix, mais tu sorts.

oui je sors mais pourquoi je sors pas avant d 'afficher le -333 ?avec un while on compare pas la valeur par rapport à la condition avant de rentrer dans la boucle contrairement à un do while ?

pourriez vous me donner un indice pour n'afficher qu une seule fois la phrase ?
merci
26/07/2019, 09h04
cpiter

Citation:

Envoyé par joel.drigo

Et là else if(vt <2500 ){, ce serait pas plutôt ht que tu veux tester... vt devant être < 2500 dès la première itération, parachuteOuvert passe direct à true et on a ( ht >2500 && !parachuteOuvert) probablement jamais vrai, ce qui explique qu'on n'entre pas dans le if...

oui ht sûrement la fatigue..:)

bingo j'ai bataillé mais j 'ai réussi ,c'est vrai qu il faut pratiquer pour y arriver mais parfois seul c'est dur ,on s'embête pour une toute petite lacune ,merci à vous pour votre aide,maintenant je vais pouvoir passer au tableau :) ;)

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
import java.util.Scanner;
 
class Parachutiste {
 
    public static void main(String[] args) {
 
        Scanner clavier = new Scanner(System.in);
 
        double masse = 80.0;
        do {
            System.out.print("masse du parachutiste (>= 40) ? ");
            masse = clavier.nextDouble();
        } while (masse < 40.0);
 
        double h0 = 39000.0;
        do {
            System.out.print("hauteur de depart du parachutiste (>= 250) ? ");
            h0 = clavier.nextDouble();
        } while (h0 < 250.0);
 
        /*******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
      //attributs,déclaration et initialisation
 
        final double G = 9.81;
        double v0 = 0.0;
        double t0 = 0.0;
        double vitesse = v0;
        double hauteur = h0;
        double t = t0;
        double accel = G;
        double surface = 2.0;
        boolean parachuteOuvert =false;
        double ht = h0;
        int i = 0;
        int j = 0;
        int k = 0;
 
        double s;
        double q;
        double vt;
        double at;
 
 
        //calcul chute libre
 
        do {
        	 s = surface/masse;       
        	 q = Math.exp(-s*(t-t0));        
        	 vt = ( G/s)*(1-q)+(v0*q);       
        	 ht = h0-(G/s)*(t-t0)-((v0-(G/s))/s)*(1-q);        
        	 at = G -(s*vt);
 
 
        	if( ht > 2500 && !parachuteOuvert){
 
 
        		if(vt >= 343 ) {
        			if(j == 0) {
            		System.out.println("## Felix dépasse la vitesse du son");
            		j = 1;
        			}
            	}
            	if( at < 0.50) {
            		if(k == 0) {
            		System.out.println("## Felix a atteind sa vitesse max");
            		k = 1;
            		}
            	}
        	}
        	else{
        		surface = 25;
        		t0 = t;
        		h0 = ht;
        		v0 = vt;
        		parachuteOuvert = true;
        		if(i == 0 ) {
        			System.out.println("Felix ouvre son parachute");
        			i = 1;
        		}
        	}
 
 
 
 
 
 
        	if(ht >0) {
        	System.out.printf("%.0f, %.4f, %.4f,%.5f\n",t, ht, vt, at);
        	}
 
        	t++;
 
 
 
 
        }while( ht> 0);
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
        clavier.close();
    }
}

Et si on remplaçait ton if/else par :

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
if( ht >2500 ){
 
 
        		if(vt >= 343 ) {
        			if(j ==0) {
	        		System.out.println("## Felix dépasse la vitesse du son");
	        		j = 1;
        			}
	        	}
	        	if( at < 0.50) {
	        		if(k==0) {
	        		System.out.println("## Felix a atteind sa vitesse max");
	        		k = 1;
	        		}
	        	}
        	}
        	else{
        		surface = 25;
        		t0 = t;
        		h0 = ht;
        		v0 = vt;
        		if(iparachuteOuvert) {
        			System.out.println("Felix ouvre son parachute");
        		        parachuteOuvert = true;
        		}
        	}

Déjà pas besoin de i, parachuteOuvert sert déjà à savoir que le parachute a déjà été ouvert. Et puis, si lorsque ht>2500 && !parachuteOuvert est faux on passe parachuteOuvert à true, alors il est impossible que ht soit > 2500 en même temps que parachuteOuvert à true, donc inutile de le tester.

pour les trucs du genre :

Code:

1
2
3
4
if(j ==0) {
	        		System.out.println("## Felix dépasse la vitesse du son");
	        		j = 1;
        			}

ce serait plus logique d'utiliser un booléen :

Code:

1
2
3
4
if( !messageVitesseSon ) {
	System.out.println("## Felix dépasse la vitesse du son");
	messageVitesseSon = true;
}

Code:

1
2
3
4
if( afficherMessageVitesseSon ) { // avec afficherMessageVitesseSon initialisé à true
	System.out.println("## Felix dépasse la vitesse du son");
	afficherMessageVitesseSon = false;
}

26/07/2019, 13h57
cpiter

ok j 'ai modifié ,je comprend mieux les portée de variables grâce à toi et ,après une bonne nuit j 'ai eu le déclic alors qu'hier j'étais complètement bloqué..et c'est beaucoup plus clair pour moi maintenant avec les booleans. merci à vous 2 pour votre aide .