Discussion :

[cdsoft]

Bonjour à tous,
Actuellement j'essaie de me lancer dans la programmation java, et je suis une formation en ligne dans laquelle nous devons coder des programmes données sous forme de problème en langage naturel.

il y en a un sur lequel, je bloque totalement et je pense que le soucis vient de mon code, mais je n'arrive pas à le déboguer.
Nous devons suivre une logique de programmation qui nous est imposée et nous ne connaissons pas encore à ce stade la POO.
je vous poste le sujet ainsi que la partie de mon code qui ne me retourne pas du tout le même résultat qu'eux pour un même jeux d'essai .

Je vous remercie de votre aide .

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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
import java.util.Scanner;
 
class PredProie {
 
    private final static double TAUX_ATTAQUE_INIT = 0.01;
    private final static double TAUX_CROISSANCE_LAPINS = 0.3;
    private final static double TAUX_CROISSANCE_RENARDS = 0.008;
    private final static double TAUX_MORTALITE = 0.1;
    private final static int DUREE = 50;
 
    public static void afficheStatus(int temps, double lapins, double renards) {
        System.out.print("Après ");
        System.out.print(temps);
        System.out.print(" mois, il y a ");
        System.out.format("%.3f", lapins );
        System.out.print(" lapins et ");
        System.out.format("%.3f", renards );
        System.out.println(" renards");
    }
 
    public static void afficheTauxDAttaque(double tauxAttaque) {
        System.out.println("");
        System.out.print("***** Le taux d'attaque vaut ");
        System.out.format("%.2f", tauxAttaque * 100);
        System.out.println("%");
    }
 
    /*****************************************************
     * Compléter le code à partir d'ici
     *****************************************************/
     public static double plafonner(double value)
    {
    	if(value < 0){
			return 0;
		}else{
			return value;
		}
 
    }
 
 
    	public static double entrerPopulation(String animal, double nombreMin, Scanner clavier) {
		int res = 0;
 
		    // completer en utilisant cette ligne sans la modifier
		do{
			System.out.print("Combien de "+ animal);
			System.out.print(" au départ (>="+ nombreMin);
			System.out.print(") ? ");
			res = clavier.nextInt();
		}while(res < 0 && res < nombreMin);
 
		// A modifier pour un retour correct:
		return res;
 
	}
 
	public static void afficheResultat(String animal, boolean menacesExtinction, boolean disparus, boolean remonte) {
		if(menacesExtinction){
			System.out.print("Les "+animal);
			System.out.println(" ont été en voie d'extinction");
		}
 
		if(disparus){
			System.out.print("et les "+animal);
			System.out.println(" ont disparus :-(");
		}
 
		if(remonte){
			System.out.println("mais la population est remontée ! Ouf !");
		}
 
		if(!menacesExtinction && !disparus && !remonte){
			System.out.println("Les lapins et les renards ont des populations stables.");
		}
 
	}
 
 
	public static double calculerLapins(double lapins, double renards, double tauxAttaque) {
 
		double nbRenards = 0.0;
		nbRenards = renards;
 
		lapins *= (1.0 + TAUX_CROISSANCE_LAPINS - tauxAttaque * nbRenards );
 
		lapins = plafonner(lapins);
 
		// A modifier pour un retour correct: 
		return lapins;	
	}
 
	public static double calculerRenards(double lapins, double renards, double tauxAttaque) {
 
		int idx = 1;
		double nbLapins = 0.0;
		nbLapins = lapins;
 
		renards *= (1.0 + tauxAttaque * nbLapins * TAUX_CROISSANCE_RENARDS - TAUX_MORTALITE);
 
		renards = plafonner(renards);
 
		// A modifier pour un retour correct: 
		return renards;
	}
 
	public static void simule(double renardsInit, double lapinsInit, double tauxInit, double tauxFin)	{
 
		double[][] tab = new double[2][2];
 
		int idx = 1, idx2 = 0;
		double nbLapinsPrec = lapinsInit, nbRenardsPrec = renardsInit;
		double nbLapins = lapinsInit, nbRenards = renardsInit;
		boolean extinction = false, popRemonte = false, disp = false;
		String animal="";
 
		while(tauxInit <= tauxFin){
			afficheTauxDAttaque(tauxInit);
 
/*
			nbLapins = calculerLapins(lapinsInit,renardsInit,tauxInit);
 
			nbRenards = calculerRenards(lapinsInit,renardsInit,tauxInit);
			*/
			nbRenardsPrec = nbRenards;
			nbLapinsPrec = nbLapins;
 
			tab[0][0] = lapinsInit;
			tab[1][0] = renardsInit;
 
			nbLapins = calculerLapins(tab[0][0],0,tauxInit);
			tab[0][1] = nbLapins;
 
			nbRenards = calculerRenards(tab[0][0],tab[1][0],tauxInit);
			tab[1][1] = nbRenards;
 
			++idx;
 
			while(idx < 10){
				nbLapinsPrec = tab[0][0];
				nbRenardsPrec = tab[1][0];
 
				nbLapins = calculerLapins(tab[0][1],tab[1][0],tauxInit);
 
				nbRenards = calculerRenards(tab[0][0],tab[1][1],tauxInit);
 
				tab[0][0] = tab[0][1];
				tab[1][0] = tab[1][1];
 
				tab[0][1] = nbLapins;
				tab[1][1] = nbRenards;
 
 
				if(nbLapins < 2.0 && nbRenards < 2.0){
					nbLapins = 0 ;
					nbRenards = 0;
					break;
				}
				++idx;
			}
 
			afficheStatus(idx, nbLapins, nbRenards);
			if(nbLapins < 5 && nbLapins > 0){
				extinction = true;
				animal = "Lapins";
			}else{
				if(nbLapins == 0){
					disp = true;
					animal = "Lapins";
				}
			}
			if(nbRenards < 5 && nbRenards > 0){
				extinction = true;
				animal = "Renards";
			}else{
				if(nbRenards == 0){
					disp = true;
					animal = "Renards";
				}
			}
			if(extinction && nbLapins >= 5){
				popRemonte = true;
			}
			if(extinction && nbRenards >= 5){
				popRemonte = true;
			}
 
			afficheResultat(animal,extinction,disp,popRemonte);
			tauxInit += 0.01;
			idx=1;
 
		}
 
	}
 
 
    /*******************************************
     * ne rien modifier apres cette ligne
     *******************************************/
 
    public static void main(String[] args) {
 
        Scanner clavier = new Scanner(System.in);
 
        // Saisie des populations initiales
        double renardInit = entrerPopulation("renards", 2.0, clavier);
        double lapinsInit = entrerPopulation("lapins", 5.0, clavier);
 
        // ===== PARTIE 1 =====
        // Première simulation
        // Evolution de la population avec les paramètres initiaux
 
        simule(renardInit, lapinsInit, TAUX_ATTAQUE_INIT, TAUX_ATTAQUE_INIT);
 
        // ===== PARTIE 2 =====
        // Variation du taux d'attaque
        System.out.println("");
 
        double tauxInit = 0.0;
        double tauxFin = 0.0;
 
        do {
            System.out.print("taux d'attaque au départ en % (entre 0.5 et 6) ? ");
            tauxInit = clavier.nextDouble();
        } while ((tauxInit < 0.5) || (tauxInit > 6.0));
 
        do {
            System.out.print("taux d'attaque à la fin  en % (entre ");
            System.out.print(tauxInit);
            System.out.print(" et 6) ? ");
            tauxFin = clavier.nextDouble();
        } while ((tauxFin < tauxInit) || (tauxFin > 6.0));
 
        tauxInit /= 100.0;
        tauxFin  /= 100.0;
 
 
        simule(renardInit, lapinsInit, tauxInit, tauxFin);
    }
}

énoncé :

On souhaite ensuite simuler l'évolution des populations de lapins et de renards pendant DUREE mois (constante fournie dans le code) et en incrémentant à chaque fois le mois d'une unité.

Complétez pour cela les méthodes calculerLapins et calculerRenards qui serviront à mettre à jour les populations de ces animaux chaque mois.

La méthode calculerLapins calcule et retourne la croissance des lapins, c'est à dire leur nouveau nombre après l'écoulement d'un mois. Le calcul se fait en multipliant le nombre courant de lapins par la formule suivante :
(1.0 + TAUX_CROISSANCE_LAPINS - tauxAttaque * nbRenards )
où nbRenards est le nombre de renards du mois précédent le calcul.

Cela représente le fait que le nouveau nombre de lapins équivaut au nombre de lapins qu'il y avait précédemment plus le nombre de lapins qui sont nés (TAUX_CROISSANCE_LAPINS) moins le nombre de lapins tués par les renards. Le nombre de lapins tués dépend du nombre de renards puisque plus il y a de renards, plus ils mangent de lapins.

De son coté, la croissance des renards, retournée par la méthode calculerRenards, est calculée en multipliant le nombre courant de renards par :
(1.0 + tauxAttaque * nbLapins * TAUX_CROISSANCE_RENARDS
- TAUX_MORTALITE)
où nbLapins est le nombre de lapins du mois précédent.

Cela représente le fait que le nouveau nombre de renards augmente du nombre de renards nés moins le nombre de renards morts. On voit que dans le cas des renards, c'est le nombre de naissances qui dépend du nombre de lapins, car les renards doivent attraper des lapins afin de pouvoir se nourrir, se reproduire et nourrir leurs petits.

Les formules ci-dessus n'empêchent pas les populations de lapins et de renards d'être négatives. Il vous faut donc faire en sorte que la valeur retournée soit plafonnée à 0 si la formule calcule un nombre négatif.

Vous écrirez et utiliserez pour cela une méthode
double plafonner(double value)
qui retourne 0 si value est négative et value sinon.

Note : Nous avons représenté le nombre de lapins et de renards retournés par les méthodes calculerRenards et calculerLapins par des double afin de garder de la précision sur le calcul. On pourrait interpréter cela comme une incertitude sur le nombre exact d'animaux existants.
3.3.1 Simulation

Complétez enfin la méthode simule qui fait évoluer les populations de lapins et de renards sur DUREE mois en mettant à jour, à chaque itération, les populations de renards et de lapins au moyen des méthodes calculerRenards et calculerLapins.

La méthode simule devra :

Arrêter d'itérer si les lapins et les renards ont disparus. On considère que les lapins/renards ont disparu si leur nombre devient inférieur à 2. Si la population de renards ou de lapins passe en dessous de 2, nous supposons que l'espèce ne peut plus se reproduire. Dans ce cas de figure, le nombre de renards ou de lapins doit alors être mis à zéro.

Afficher après la fin des itérations le nombre de mois écoulés et le nombre de lapins et de renards à ce moment. Cet affichage se fera au moyen de la méthode fournie afficheStatus (voir l'exemple de déroulement plus bas).

Répéter ces traitements pour tous les taux d'attaque à partir de tauxInit, en incrémentant le taux de 1% (0.01) à chaque fois, tant que le taux est inférieur ou égal à tauxFin. La comparaison se fera au moyen de l'opérateur <= et strictement par rapport à tauxFin. En raison de l'imprécision liée à la représentation des doubles, il est possible que la borne tauxFin ne soit pas atteinte. Ceci est considéré comme un comportement normal du programme.

Pour chaque itération de cette boucle, il faudra afficher, en début d'itération, le taux d'attaque utilisé au moyen de la méthode fournie afficheTauxDAttaque. A chaque itération, la simulation démarre des populations initiale fournies en argument de simule (voir l'exemple de déroulement plus bas).

De plus, la méthode simule devra mémoriser dans des booléens si au cours de la simulation pour un taux donné :

les renards et/ou les lapins ont été en voie d'extinction (leur nombre descend en dessous de 5 strictement) ;

leur population a réussi a remonter après avoir été menacée d'extinction ;

les renards et/ou lapins ont disparu.

Ces booléens seront utilisés pour afficher des messages d'alertes après l'affichage fait par afficheStatus (voir l'exemple de déroulement ci-dessous).

Si la population d'un animal passe brutalement d'un nombre supérieur ou égal à 5 à zéro dans un cycle on considérera que la population a été en voie d'extinction et a disparu.

Pour simplifier nous ne tiendrons pas compte des oscillations entre les différents états: il suffit qu'ils se soient produits une seule fois pour mettre les booléens concernés à true. Par exemple si la population a disparu après avoir pu remonter (après une menace d'extinction), le message sur la remontée de la population s'affichera quand mêm

[joel.drigo]

Salut,

Je n'ai pas lu le sujet (pas le temps) et j'ai parcouru vite fait ton code :

• }while(res < 0 && res < nombreMin);tant que res est à la fois inférieur à 0 et à nombreMin : autant écrire res<0 (je suppose que nombreMin est >0 logiquement). Donc il y a un problème dans ce test : on veut saisir une valeur comprise entre 0 et nombreMin, donc la deuxième condition serait plutôt res > nombreMin, pour éviter de saisir un nombre trop grand. Mais si on change que cet opérateur, on va avoir 2 conditions impossibles en même temps : res ne pourrait pas être à la fin <0 et >nombreMin, donc ce n'est pas un et (&&) qu'il faut faire mais un ou (||) : la condition obligeant à resaisir sera donc bien "tant que res est inférieur à 0 ou supérieure à nombreMin".
• 
  

  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
  if(nbLapins < 5 && nbLapins > 0){
  				extinction = true;
  				animal = "Lapins";
  			}else{
  				if(nbLapins == 0){
  					disp = true;
  					animal = "Lapins";
  				}
  			}
  			if(nbRenards < 5 && nbRenards > 0){
  				extinction = true;
  				animal = "Renards";
  			}else{
  				if(nbRenards == 0){
  					disp = true;
  					animal = "Renards";
  				}
  			}
  			if(extinction && nbLapins >= 5){
  				popRemonte = true;
  			}
  			if(extinction && nbRenards >= 5){
  				popRemonte = true;
  			}

  Ce code est problématique, parce qu'on mélange des états résultants sur des conditions sur les lapins et sur les renards. Le résultat ne peut qu'être incohérent. Si nbLapins est entre 0 et 5, on va avoir extinction à true (mettons que ça signifie que les lapins vont disparaitre) : si les renards sont à 0, animal va passer de "Lapins" à "Renards" et disp à true. On avait donc un état résultant de contions sur les lapins, à priori concernant les lapins, qui va s'afficher pour les renards (extinction=true et animal="renard" : on n'affichera donc pas l'extinction des lapins, mais des renards à priori...) : pour gérer ça, sans objet, il faudrait une méthode qui fassent les traitements sur des variables neutres et appeler cette méthode pour chaque population :
  

  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
  void traitementPopulation((int nbAnimal, String animal) { // tu prends le nom que tu veux
   
  /* ... */
   
  if(nb > 0 && nb < 5) { // le test est plus facilement lisible dans ce sens là
  	extinction = true; 
   
  } else if(nb == 0){ // le else { if () { } } est plus lisible comme ça aussi
     disp = true;
  } 
   
  if ( extinction && nb >= 5){ // ce test devient forcément faux dans tous les cas : il est probable qu'il faille faire autrement*
      popRemonte = true;
  }
  afficheResultat(animal,extinction,disp,popRemonte);
  }

*ce test devient forcément faux dans tous les cas : il est probable qu'il faille faire autrement : et oui extinction étant vrai seulement si 0<nb<5, il sera faut si nb>=5. J'ai lu rapidement le sujet pour voir de quoi il s'agit, et il s'agit visiblement de

1. mémoriser un changement d'état ayant eu lieu dans un booléen
2. d'afficher une alerte au moment du changement d'état

Ce n'est pas exactement ce que ça fait : déjà, les états sont uniques pour les deux populations, alors qu'il devrait y avoir un exemplaire pour chaque population. Ensuite :

Si la population d'un animal passe brutalement d'un nombre supérieur ou égal à 5 à zéro dans un cycle on considérera que la population a été en voie d'extinction et a disparu.

ne peut pas se traduire par il y a extinction si nb>0 && nb<5 (le nombre actuel compris entre 0 et 5), mais par le nombre avant >=5 et le nombre après évolution ==0 : il faut donc mémoriser le nombre de lapins(ou renards), dans une variable, calculer la nouvelle population, et comparer la nouvelle population et l'ancienne (celle mémorisée avant)... pour popRemonte, le test devient alors pertinent et correct.

[cdsoft]

Merci de votre réponse.
je jette un coup d’œil a votre analyse et je fais des tests

A+