bonsoir tous le monde je suis des cours pour apprendre le langage JAVA, j'avance assez bien mais les exercices ne sont pas tous du même niveau, le dernier en date est plutôt compliqué c'est une simulation d'un cycliste et je ne sais vraiment pas par quel bout commencer je suis complètement perdu.

Voici l’annoncé si certain d'entre vous peuvent m'aider a commencer cela serai super parce que j'avoue ne pas savoir comment faire (ils sont fout dans cette formation pour de l'initiation je trouve les exercices très difficile).

Énonce.

On s'intéresse ici à écrire un programme permettant de simuler le trajet d'un cycliste lors d'un tour en montagne (suite à la location de la semaine passée ;-)).

2.2 Modélisation du cycliste

Figure 1: Le trajet prévu pour le cycliste (de gauche à droite).
Le programme demandé devra simuler le trajet (temps, distance, vitesse, accélération et puissance développée) d'un cycliste effectuant un trajet (cf figure 1) de dtot kilomètres en montagne, constitué d'une montée de d1 kilomètres à p1 pourcents et d'une descente de dtot−d1 kilomètres à p2 pourcents. Par exemple, un tour de 50 km (dtot=50) dont 30 km (d1=30) sont en montée à 5 % (p1=5) et le reste est une descente à 10% (p2=10).

On supposera de plus qu'il y a un vent constant tout le long du trajet. Le sens du vent est pris dans le sens du cycliste : un vent négatif (vent contraire) signifie que le cycliste se prend le vent de face (comme dans l'exemple de la figure) ; un vent positif signifie que le vent pousse le cycliste dans le dos.

Le cycliste sera représenté dans le programme par sa masse (en kilogrammes), sa vitesse (en kilomètres par heure), son accélération (en kilomètres par heure par minute), la distance (en kilomètres) qu'il a parcouru depuis le début de la montée et la puissance (en watts) qu'il développe.

Nous vous fournissons déjà quelques variables dans le programme téléchargé :

t représentera le temps (en minutes) depuis le début de la montée (le programme commence donc au temps t=0) ;

d, la distance (en kilomètres) que le cycliste a parcouru depuis le début de la montée ;

v, la vitesse du cycliste (en kilomètres par heure) au temps t ; au départ, c'est donc la vitesse avec laquelle le cycliste aborde la montée (il ne part pas de zéro, mais attaque la montée à 30 km/h) ;

acc, l'accélération du cycliste (en kilomètres par heure par minute) au temps t ; c'est donc le nombre de kilomètres par heure qu'il va gagner/perdre dans la prochaine minute ; elle sera calculée au fur et à mesure en fonction des autres paramètres ; sa valeur initiale n'a donc pas d'importance et nous avons choisi 0 ;

et p, la puissance (en watts) que le cycliste développe au temps t en pédalant ; il faudra la recalculer à chaque fois en fonction de la fatigue du cycliste (voir plus loin) ; nous avons choisi une valeur initiale de 175 W.

Le reste du code fourni consiste en :

plusieurs messages à afficher pour poser des questions à l'utilisateur (voir plus loin) ;

la condition et la ligne permettant d'afficher les informations sur le cycliste toutes les 5 minutes ; la condition utilise des fonctions qui n'ont pas été présentées dans le cours (Math.abs, Math.round) dont le but est simplement d'éviter trop d'affichages en n'affichant qu'une ligne toutes les 5 minutes de simulation ; utilisez ces lignes fournies telles quelles ;

deux messages utiles pour des conditions particulières (décrites plus bas) ;

l'affichage des deux derniers messages, à ne pas modifier.

Pour commencer, votre programme devra demander à l'utilisateur les grandeurs suivantes (voir exemple de déroulement en fin de l'énoncé) :

la masse du cycliste (en kilogrammes) ; cette masse doit être comprise entre 40 et 180 kg (inclus) ;

la vitesse du vent (en kilomètres par heure) ; elle doit être comprise entre –20 et +20 km/h ;

la distance totale du parcours (en kilomètres) ; cette distance doit être supérieure ou égale à 11 km et inférieure ou égale à 200 km ;

la longueur (en kilomètres) de la montée ; cette distance doit être positive et telle qu'il reste au moins 10 km de descente ; il faudra afficher dans la question la longueur maximale possible ;

la pente (en pourcents) de la montée ; elle doit être plus grande que zéro et inférieure ou égale à 20% ;

la pente (en pourcents) de la descente ; elle doit être plus grande que zéro et inférieure ou égale à 20%.

En cas de valeur entrée incorrecte, votre programme devra (de suite) poser à nouveau la question (voir exemple de déroulement plus bas) ; et ce, jusqu'à obtention d'une réponse correcte.

Nous vous conseillons ensuite de définir deux constantes :

le « pas de temps » DT avec lequel nous allons faire avancer les calculs de la simulation ; fixez-le à 1/60 ;

la « puissance minimale » P_MIN que le cycliste fournit ; elle sera de 10 W.

2.3 Simulation du mouvement
Procédez de la façon suivante pour calculer l'évolution du cycliste :

afficher les informations courantes (code fourni) ;

augmenter le temps t d'un pas de temps (DT défini plus haut) ;

calculer la vitesse V du vent par rapport au cycliste : c'est simplement la différence entre la vitesse du cycliste et celle du vent : V=v–vitesse du vent ;

calculer la fatigue du cycliste : si le cycliste est encore en montée et que sa puissance est supérieure à la puissance minimale (définie plus haut : 10 W), alors il perd 0.5 fois DT de puissance (il pédale moins fort à cause de la fatigue) ;

calculer l'accélération du cycliste ; elle vaut :

moins 2'118.96 fois le sinus de l'arctangente de la pente divisée par 100. (Pour ceux que la Physique intéresse, il s'agit là de l'accélération liée au poids : 2'118.96 étant 9.81×60×3.6 en raison des unités (kilomètres par heure par minute).) En Java, on écrit simplement :
« -2118.96 * Math.sin(Math.atan(pente/100)) » ;
Notez que ce terme ne change pas tant que la pente ne change pas ;

moins 5 fois V fois Math.abs(V) divisé par la masse du cycliste ; (Physique : c'est la force exercée par le vent sur le cycliste ; 5 provient de 0.3×60/3.6.)

si la puissance et la vitesse du cycliste sont toutes les deux plus grandes que zéro (i.e. s'il n'a pas posé le pied par terre), on ajoute sa poussée (il pédale) : 777.6 (60×3.6×3.6) fois sa puissance divisé par le produit de sa vitesse et de sa masse :

777.6×pv×m
si après tous ces calculs la valeur absolue de l'accélération (Math.abs(acc)) est plus petite que 10−5 (qui s'écrit « 1e-5 » en Java), alors on la mettra à 0 ;

sinon, calculer la nouvelle vitesse du cycliste en ajoutant à l'ancienne valeur le produit de l'accélération par le « pas de temps » :

v=v+acc×DT
puis mettre à jour la distance parcourue : lui ajouter le produit de la (nouvelle) vitesse et du « pas de temps » divisé par 60 : (Cette division par 60 vient des unités : la vitesse est en kilomètres par heure alors que le temps est en minutes.)

d=d+v×DT60
terminer enfin par le traitement des cas particuliers :

dès que le cycliste aborde la descente :

afficher un message :

## Bernard a atteint le sommet en ... min.

le cycliste arrête alors de pédaler fortement, il ne produit plus que la puissance minimale (définie plus haut) ; autrement dit : pendant toute la descente la puissance du cycliste est égale à la puissance minimale ;

penser également à changer la pente pour celle de la descente, qui doit de plus être négative ;

si la vitesse du cycliste devient inférieure à 3 km/h, le cycliste se décourage et abandonne : quitter votre programme en affichant « ## Bernard abandonne, il n'en peut plus » et les informations (temps, distance, vitesse, accélération et puissance) ; les deux instructions nécessaires pour réaliser ces affichages sont fournies ; pour quitter le programme, simplement utiliser l'instruction « return ».


voici le code que j'ai commencé :

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
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
import java.util.Scanner;
 
class Cycliste {
    private static Scanner clavier = new Scanner(System.in);
    public static void main(String[] args) {
 
        double t = 0.0;    // temps, en min.
        double d = 0.0;    // distance, en km
        double v = 30.0;   // vitesse, en km/h
        double acc = 0.0;  // accélération, en km/h/min
        double p = 175.0;  // puissance, en W
 
 
        /******************************************
         * Completez le programme a partir d'ici.
         *******************************************/
 
 
        // variables utilisateur
 
        double masseCycliste = 0.0;
        double vent = 0.0;
        double dtot = 0.0;
        double lmonté = 0.0;
        double Pmonté = 0.0;
        double Pdescente = 0.0;
        double Dt = 1/60;
        double P_Min = 10;
 
        do { 
        	System.out.print("masse du cycliste (entre 40 et 180 ) ? ");
        		masseCycliste= clavier.nextDouble();
        }while(!(masseCycliste>=40) || !(masseCycliste<=180) );
 
        do { 
        	System.out.print("vent (entre -20 et +20 km/h) ? ");
        		vent= clavier.nextDouble();
        }while(!(vent>=-20) || !(vent<=20));
 
        do { 
        	System.out.print("distance du parcours (<= 200 km) ? ");
        		dtot= clavier.nextDouble();
        }while(!(dtot>=11) || !(dtot<=200));
 
        do { 
        	System.out.print("distance au sommet du col " +(dtot - 10)+ " <=");
        	System.out.print(" km) ? ");	
        	lmonté= clavier.nextDouble();
        }while(!(lmonté>=0) || !(lmonté<=(dtot - 10)));
 
        do { 
            System.out.print("pente moyenne jusqu'au sommet (<= 20 %) ? ");
        		Pmonté= clavier.nextDouble();
        }while(!(Pmonté>0) || !(Pmonté<=20));
 
        do { 
            System.out.print("pente moyenne après le sommet (<= 20 %) ? ");
        		Pdescente= clavier.nextDouble();
        }while(!(Pdescente>0) || !(Pdescente<=20));
 
 
        // affichage des informations courantes :
 
        double roundedTime = Math.round(t);
 
        		if (Math.abs(roundedTime - t) < 1e-5 && (int)roundedTime % 5 == 0) {
        			System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                              t, d, v, acc, p); 
 
        double pente = Pmonté;	      
        double Dsommet = dtot-lmonté;
 
        // augmenter le temps :
        do {t = t+Dt;
 
 
 
        // calcul vitesse du vent :
        double V = v-vent;
 
        // calcul fatigue cycliste :
        if (Dsommet > 0 && p> P_Min ) { p = p-0.5*Dt;}
 
        // calcul vitesse accélaration :
      	acc = (2118.96*Math.atan(pente/100))-5*V*Math.abs(V);
 
        		if (p>0 && v>0){acc = acc+(777.6*(p/(v*masseCycliste)));}
 
        		{
        		if (Math.abs(acc)<1e-5) {acc= 0;}
        		else{ v=v*acc*Dt;}
 
        		}
 
        		}while(d>=dtot);
        		}
 
 
 
        // conditions spéciales
 
        System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
        System.out.println("## Bernard abandonne, il n'en peut plus");
        System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                          t, d, v, acc, p);
 
        /*******************************************
         * Ne rien modifier apres cette ligne.
         *******************************************/
 
        System.out.println("## Bernard est arrivé");
        System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                          t, d, v, acc, p);
    }
}

Merci d'avance pour votre aide.