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