Discussion :

[cpiter]

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 :

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
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();
    }
}

[joel.drigo]

Salut,

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

[cpiter]

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

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
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 :

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
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();
    }
}

[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 .

Bonne soirée

[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).

[cpiter]

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..

[cpiter]

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 .

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

[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 ) 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

[joel.drigo]

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.