IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

avec Java Discussion :

Simulation complexe d'un cycliste


Sujet :

avec Java

  1. #1
    Membre averti
    Homme Profil pro
    Technicien réseau
    Inscrit en
    Septembre 2015
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Technicien réseau
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Septembre 2015
    Messages : 50
    Par défaut Simulation complexe d'un cycliste
    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.

  2. #2
    Membre éclairé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2008
    Messages
    764
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2008
    Messages : 764
    Par défaut
    Bonjour Hoturi,

    Petite aide ! je dis petite car je n'ai pas pu lire ton texte en entier .... un peu long

    Bon, de ce que j'ai lu et à mon avis personnel qui sera sûrement et allègrement démonté par les cadors du site

    Je vois que le code que tu as fourni est codé sans utiliser la particularité de java qui est un language orienté objet. Perso, j'aurais codé autrement et je ne reprends donc pas ton exemple car il me prendrait plus de temps (désolé).

    Moi, j'aurais créé déjà deux beans :
    1- Cycliste
    2- Trajet

    comme suit :
    Trajet
    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
    package beans;
     
    public class Trajet {
    	private float dtot;	//distance totale du parcours
    	private float longMont;	//longueur de la montée (en kilomètres)
    	private float penteMont;	//pourcentage de la montée
    	private float descente;	//longueur de la descente (en kilomètres)
    	private float penteDesc;	//pourcentage de la descente
    	private float vent;	//force du vent
     
    	//CONSTRUCTEUR
    	public Trajet(float dtot, float d1, float p1, float p2, float vent) {
    		super();
    		this.dtot = dtot;
    		this.longMont = d1;
    		this.penteMont = p1;
    		this.penteDesc = p2;
    		this.setVent(vent);
     
    		descente = dtot - d1;
    	}
     
    	//ACCESSEURS
    	public float getDtot() {return dtot;}
    	public void setDtot(float dtot) {this.dtot = dtot;}
    	public float getD1() {return longMont;}
    	public void setD1(float d1) {this.longMont = d1;}
    	public float getP1() {return penteMont;}
    	public void setP1(float p1) {this.penteMont = p1;}
    	public float getP2() {return penteDesc;}
    	public void setP2(float p2) {this.penteDesc = p2;}
    	public float getDescente() {return descente;}
    	public float getVent() {return vent;}
    	public void setVent(float vent) {this.vent = vent;}	
    }
    Cycliste
    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
    package beans;
     
    public class Cycliste {
     
    	private String nom;
    	private float masse;	//en kilogrammes
    	private float vitesse;	//en kilomètres / heure
    	private float acceleration;	//en km / heure / minute
    	private float puiss;	// en watts
     
    	//CONSTRUCTEUR
    	public Cycliste(String nom, float masse) {
    		super();
     
    		this.masse = masse;
    	}
     
    	//ACCESSEURS
    	public float getMasse() {return masse;}
    	public void setMasse(float masse) {this.masse = masse;}
    	public float getVitesse() {return vitesse;}
    	public void setVitesse(float vitesse) {this.vitesse = vitesse;}
    	public float getAcceleration() {return acceleration;}
    	public void setAcceleration(float acceleration) {this.acceleration = acceleration;}
    	public float getPuiss() {return puiss;}
    	public void setPuiss(float puiss) {this.puiss = puiss;}
    	public String getNom() {return nom;}
    	public void setNom(String nom) {this.nom = nom;}	
    }
    Pour effectuer tous les calculs .. etc je créé toujours un contrôleur que voici :
    Controleur
    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
    package controleur;
     
    import java.util.Scanner;
     
    import beans.Cycliste;
    import beans.Trajet;
     
    public class Controleur {
     
    	float masse, vitVent, dtot, longMont, penteMont, penteDesc;
    	String nom;
     
    	public Controleur() {
    		super();
     
    		//demande des paramètres
    		poserQuestions();
     
     
    		//création des objets cycliste et trajet
    		Cycliste poulidor = new Cycliste(nom, masse);
     
    		Trajet prologueTourDeFrance = new Trajet(dtot, longMont, penteMont, penteDesc, vitVent);
     
    		System.out.println("Cycliste :\n\tnom : " + nom + "\n\tmasse : " + masse + "\nTrajet :\n\tdistance totale : "
    				+ dtot + "\n\tlongueur descente : " + (dtot - longMont));
     
    	}
     
    	//méthodes
    	private void poserQuestions() {
     
    		Scanner scan = new Scanner(System.in);
     
    		System.out.println("nom du cycliste :");
    		nom = scan.next();
     
    		do{
    			System.out.println("Indiquer la masse du cylcite (entre 40 et 180 kilos)");
    			masse = scan.nextFloat();
    		}while(masse < 40 || masse > 180);
     
    		do{
    			System.out.println("Indiquer la vitesse du vent (entre -20 et 20 km/heure)");
    			vitVent = scan.nextFloat();
    		}while(vitVent < -20 || vitVent > 20);
     
    		do{
    			System.out.println("Indiquer la distance totale du parcours (entre 11 et 200 km)");
    			dtot = scan.nextFloat();
    		}while(dtot < 11 || dtot > 200);
     
    		do{
    			System.out.println("Indiquer la longueur de la montée (>0 et dtot - distanceMontée > 10)");
    			longMont = scan.nextFloat();
    		}while(longMont < 0 || dtot - longMont < 10);
     
    		do{
    			System.out.println("Indiquer la pente de la montée (> 0% et <= 20 %)");
    			penteMont = scan.nextFloat();
    		}while(penteMont < 0 || penteMont > 20);
     
    		do{
    			System.out.println("Indiquer la pente de la descente (> 0% et <= 20 %)");
    			penteDesc = scan.nextFloat();
    		}while(penteDesc < 0 || penteDesc > 20);
    	}
    }
    et avec mes habitudes, je créé un Lanceur ....
    Lanceur
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    package principal;
     
    import controleur.Controleur;
     
    public class Lanceur {
     
    	public static void main(String[] args) {
    		Controleur ctrl = new Controleur();
    	}
     
    }
    Voilà, ce que je peux faire pour toi ! je ne pense pas avoir le temps de faire plus ce week-end
    Mais déjà essaie de comprendre ce que j'ai fait.

    Tu peux ajouter quelques parties de code que tu as fait dans le controleur.

    On voit que les contraintes sont vérifiées avec des do ... while, je crée ensuite les objets puis j'affiche pour vérifier visuellement.

  3. #3
    Membre averti
    Homme Profil pro
    Technicien réseau
    Inscrit en
    Septembre 2015
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Technicien réseau
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Septembre 2015
    Messages : 50
    Par défaut
    Merci pour votre réponse hélas je ne peux utiliser le langage orienté objet dans cette exercice je dois uniquement utiliser des structure conditionnels, des itérations et des boucles.

    En faite d’après ce que j'ai compris je dois créer une grosse boucle qui avance par pas de temps de 5 min à l'aide de cette formule :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    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); }
    En faite pour l'instant je n'arrive pas a créer la boucle qui vas englober tous mes calculs, je n'ai que traduit dans mon code l'ensemble des formules qui sont salicaire pour calculer l'avancer du cycliste.

    Enfin bref je sais toujours pas comment commencer tous cela et surtout je n'arrive pas a schématiser (dans ma tête) le processus que je dois traduire en code, ce qui est encore plus gênant.

  4. #4
    Membre éclairé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Février 2008
    Messages
    764
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Février 2008
    Messages : 764
    Par défaut
    Bonjour !

    Alors dans ce cas, au lieu de donner l'énoncé de ton problème en un gros bloc, je te conseille plutôt de décrire ce que tu souhaite faire à l'endroit où tu es bloqué.
    Peut-être que tu l'as dit dans ton message mais, très sincèrement, je n'ai pas tout lu et je pense que nombre de personnes qui auraient pu t'aider se sont désistée en voyant la tartine de l'énoncé

    Créé plutôt un nouveau sujet en expliquant l'endroit où tu es bloqué (sans donner tous les détails de l'énoncé mais plutôt les détails qui aideront les autres à t'aider àrésoudre ton problème) et le but recherché.

    A mon avis tu trouveras plus d'aide. Après j'ai peut-être tort mais c'est mon ressenti .

    Je suis vraiment désolé de ne pouvoir t'aider plus mais moi-même je suis en formation, j'ai déjà un très gros exercice à réaliser dans l'année et en plus je suis en période en entreprise actuellement (bien qu'en arrêt maladie ...) et je doit donc aussi faire un mémoire !!! avec en plus deux enfants jeunes ....

    je sais toujours pas comment commencer tous cela et surtout je n'arrive pas a schématiser (dans ma tête) le processus que je dois traduire en code
    Voilà le type de problème que tu rencontrera souvent si tu es débutant. On commence à coder en se disant je vais faire un cycliste qui va monter une côte ....
    puis petit à petit on a une myriade des petits ou gros problèmes qui s'ajoutent et on fini par laisser tomber devant la montagne de problèmes à résoudre !

    Tout cela parce que l'on a pas schématisé les actions que l'on doit faire avant de se lancer dans le codage.
    Bien sûr, on ne peux pas penser à tout mais déjà, prendre une feuille de papier et noter séquentiellement les étapes qui vont devoir s'enchaîner pour arriver à notre but est une étape importante.

    Ainsi, je te conseillerais de créer au moins un petit diagramme d'activités UML. Lis ce petit tuto qui devrait t'éclairer comme les feux d'une voiture .....
    http://laurent-audibert.developpez.c...amme-activites

    Bon courage ! si tu as d'autres problèmes, n'hésites pas à poster sur ce forum d'entraide

  5. #5
    Membre averti
    Homme Profil pro
    Technicien réseau
    Inscrit en
    Septembre 2015
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Technicien réseau
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Septembre 2015
    Messages : 50
    Par défaut
    C'est bon après pas mal de travail j'ai enfin réussi mon exercice enfin presque evidemment il me reste un truc qui ne vas pas mais je ne sais pas quoi, un très léger décalage entre mon résultat et le résultat attendu

    exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
     Votre programme a écrit (ligne 2) :
      "5, 1.06, 12.26, -0.0284,  172.50"
      là où notre programme voulait :
      "5, 1.05, 12.26, -0.0284,  172.50"
      Lignes 4 à 7, votre programme a écrit :
      "15, 3.08, 11.97, -0.0288,  167.50"
      "20, 4.07, 11.83, -0.0290,  165.00"
      "25, 5.05, 11.68, -0.0291,  162.50"
      "30, 6.02, 11.54, -0.0293,  160.00"
      là où notre programme voulait :
      "15, 3.07, 11.97, -0.0288,  167.50"
      "20, 4.06, 11.83, -0.0290,  165.00"
      "25, 5.04, 11.68, -0.0291,  162.50"
      "30, 6.01, 11.54, -0.0293,  160.00"

    Voici mon code si quelqu'un voit ce qui cloche merci de me le signaler, perso je pense que cela vient de la variable Dt (Dt = 1/60 soit 0.0166666666.....66667), je dois avoir un un pb d'arrondie mais comment faire?

    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
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    import java.util.Scanner;
     
    class exercices {
        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.00; // accélération, en km/h/min
            double p = 175.00;  // puissance, en W
     
     
            /******************************************
             * Completez le programme a partir d'ici.
             *******************************************/
     
     
            // variables utilisateur
     
            double masseCycliste = 80;
            double vent = 10;
            double dtot = 35;
            double lmonté = 20;
            double Pmonté = 8;
            double Pdescente = 12;
            float a = 1;
            float b = 60;
            float Dt = a/b; 
            double P_Min = 10;
            System.out.println (Dt);
     
     
     
     
            // ==== SIMULATION ====
     
     
           double t1 = 0.00;
           double d1 =0.00;
     
     
     
     
     
          // affichage des informations courantes :	
           System.out.format("%.0f, %.2f, %.2f, %.4f,  %.2f\n",
                   t, d, v, acc, p);
     
             do {	        	 
     
            // calcul fatigue cycliste :
                    if (lmonté > 0 && p> P_Min ) { p = p-0.5*Dt;}	 	
            // augmenter le temps :	
            	t1 = (t+Dt);
               	t = t1;       	         	
           // mettre à jour la distance :		
            		d1 = d+v*(Dt/60); 
               		d=d1;        	
           // calcul vitesse du vent :
                    double V = v-vent;                              
          // calcul vitesse accélaration :
                  	acc = (-2118.96*Math.sin(Math.atan(Pmonté/100)))-((5*V*(Math.abs(V)/masseCycliste)));                              		
                    		if (p>0 && v>0) {acc = acc+(777.6*(p/(v*masseCycliste)));}        		                		
                    		{if (Math.abs(acc)<1e-5) {acc= 0;
                    		}                		
                    v = v+acc*Dt;}              	        			
     
            	if (v<=3) {System.out.println("## Bernard abandonne, il n'en peut plus"); System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                        t, d, v, acc, p); 
            			   return;}
     
                             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); } 
     
     
             }while(lmonté>=d1);		
             System.out.format("## Bernard a atteint le sommet en %.0f min.\n", t);
     
     
     
     
     
             // ATTTENTION à ENLEVER
     
     
            // ======>Cas particuliers LA DESCENTE :
     
             do {   
            	 p = P_Min;    	 
     
      // augmenter le temps :	
     	t1 = (t+Dt);
        	t = t1;	 
      // mettre à jour la distance :		
     	d1 = d+v*(Dt/60); 
        	d=d1;
     
      // calcul vitesse du vent :
             double V = v-vent;        
      // calcul vitesse accélaration :
           	acc = (-2118.96*Math.sin(Math.atan(-Pdescente/100)))-((5*V*(Math.abs(V)/masseCycliste)));
     
     
             		if (p>0 && v>0) {acc = acc+(777.6*(p/(v*masseCycliste)));}        		
     
             		{if (Math.abs(acc)<1e-5) {acc= 0;}
     
             v = v+acc*Dt;
           	}	
             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); }
             }while((dtot)>=d1);
     
     
             System.out.println("## Bernard est arrivé");
             System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",
                               t, d, v, acc, p);
     =        
             }		
     
     
          	}

  6. #6
    Invité de passage
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2015
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : Maroc

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Octobre 2015
    Messages : 1
    Par défaut
    declarer un variable
    int c au debut
    apres

    c=(int) (d*100); // prend la partie entier appres diviser par cent
    System.out.format("%.0f, %.2f, %.2f, %.4f, %.2f\n",t, ((c/100.0)), v, acc, p); }

  7. #7
    Membre régulier
    Femme Profil pro
    Technicien maintenance
    Inscrit en
    Mai 2015
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 64
    Localisation : France, Haute Vienne (Limousin)

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Arts - Culture

    Informations forums :
    Inscription : Mai 2015
    Messages : 7
    Par défaut
    as tu trouvé une réponse à ton problème car moi j'ai la même chose et cela devient une prise de tête
    merci

  8. #8
    Membre averti
    Homme Profil pro
    Technicien réseau
    Inscrit en
    Septembre 2015
    Messages
    50
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Alpes Maritimes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Technicien réseau
    Secteur : Administration - Collectivité locale

    Informations forums :
    Inscription : Septembre 2015
    Messages : 50
    Par défaut
    Citation Envoyé par Babou87 Voir le message
    as tu trouvé une réponse à ton problème car moi j'ai la même chose et cela devient une prise de tête
    merci
    Oui j'ai résolu l'exercice avec un peu de persévérance, si tu veux de l'aide envoi moi un message privé.

    cldt

  9. #9
    Membre éclairé
    Profil pro
    Inscrit en
    Juin 2006
    Messages
    412
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2006
    Messages : 412
    Par défaut
    moi aussi le correcteur me met zéro because imprécision après la virgule..dans eclipse c'est bon

    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
    Test '1' permissif échoué, 0 point :
      Votre programme a écrit (ligne 37) :
      "180, 29.01, 6.70, -0.0354,  85.00"
      là où notre programme voulait :
      "180, 29.00, 6.70, -0.0354,  85.00"
      Votre programme a écrit (ligne 40) :
      "190, 30.62, 48.31, 0.4334,  10.00"
      là où notre programme voulait :
      "190, 30.59, 48.28, 0.6407,  10.00"
      "195, 34.62, 48.36, 0.0000,  10.00"
      "200, 38.65, 48.36, 0.0000,  10.00"
      "205, 42.68, 48.36, 0.0000,  10.00"
      "210, 46.71, 48.36, 0.0000,  10.00"
      Votre programme a écrit (ligne 42) :
      "214, 50.01, 48.36, 0.0000, 10.00"
      là où notre programme voulait :
      "214, 50.00, 48.36, 0.0000, 10.00"

  10. #10
    Membre confirmé
    Profil pro
    Inscrit en
    Mai 2008
    Messages
    206
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2008
    Messages : 206
    Par défaut
    bonjour,,
    je suis bloqué sur cette exercice,
    hoturi si tu peux me faire profiter de ta trouvaille, je t'en remercie d'avance

    merci encore pour ton aide

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Des chercheurs canadiens simulent le cerveau le plus complexe jamais créé
    Par Hinault Romaric dans le forum Intelligence artificielle
    Réponses: 11
    Dernier message: 18/12/2012, 00h40
  2. Probleme Voyageur de Commerce - Recuit Simulé
    Par dinver dans le forum Algorithmes et structures de données
    Réponses: 4
    Dernier message: 21/06/2009, 22h26
  3. Réponses: 7
    Dernier message: 07/04/2003, 09h35
  4. Simuler un coup de molette sur un memo...
    Par dynobremo dans le forum Composants VCL
    Réponses: 2
    Dernier message: 28/02/2003, 11h31
  5. Simulation de transmission de paquet entre différent réseaux
    Par MelloW dans le forum Développement
    Réponses: 2
    Dernier message: 12/07/2002, 19h51

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo