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
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
| package plateforme;
import java.util.ArrayList;
import java.util.Random;
public class individual {
int[][] geneZone;
int[][] geneRemanufacturing;
int[][] geneDeche;
int[][] geneQR;
int[][] geneQS;
int[] geneVehicule;
public void individual(int[] Plateforme)
{
geneZone=new int[4][5]; //inutile puisque tu l'écrase immédiatement à la ligne suivante
geneZone=getZone(Plateforme);
geneRemanufacturing=new int[4][5]; //inutile puisque tu l'écrase immédiatement à la ligne suivante
geneRemanufacturing=getRemanufacturing(Plateforme);
geneDeche=new int[2][5]; //inutile puisque tu l'écrase immédiatement à la ligne suivante
geneDeche=getDeche(Plateforme);
geneQR=new int[4][5]; //inutile puisque tu l'écrase immédiatement à la ligne suivante
geneQR=generateQR();
geneQS=new int[2][5]; //inutile puisque tu l'écrase immédiatement à la ligne suivante
geneQS=generateQS();
geneVehicule=new int[5]; //inutile puisque tu l'écrase immédiatement à la ligne suivante
geneVehicule=randVeh(Plateforme);
}
// generer un tableau de zone tout en respectant que la somme du tableau soit 1
public int[] geneZ(int[] Plateforme) {
int[] tab = new int[5];
int somme = 0;
// Si je comprend bien ce bout de code, le but
// est d'allumer une et une seule entrée dans tab
// au hasard, pour autant que l'entrée i de Plateforme soit
// aussi à 1? Dans ce cas, il y a des moyens bien plus rapide
while (somme != 1) {
int som = 0;
for (int i = 0; i < 5; i++) {
if (Plateforme[i] == 1) {
Random ran = new Random();
int s = ran.nextInt(2);
tab[i] = s;
} else {
tab[i] = 0;
}
som = som + tab[i];
}
somme = som;
}
return tab;
}
// generate 4 tableau de 4 zone
public int[][] CreateZone(int[] Plateforme) {
int[][] zone = new int[4][5];
int[] tabZ = new int[5];
for (int i = 0; i < 4; i++) {
tabZ = geneZ(Plateforme);
for (int j = 0; j < 5; j++) {
zone[i][j] = tabZ[j];
}
}
return zone;
}
// avoir les 4 zones tout en respectant que au moins 1 zone affectée
//si la plateforme elle est ouverte
public int[][] getZone(int[] Plateforme) {
int[][] Zone = new int[4][5]; // inutile tu l'écrase juste après
Zone=CreateZone(Plateforme);
int[] somme = new int[5];
for (int k = 0; k < 5; k++) {
somme[k] = 0;
for (int y = 0; y < 4; y++) {
somme[k] += Zone[y][k];
}
}
for (int i = 0; i < Plateforme.length; i++) {
if (Plateforme[i] == 1) {
while (somme[0] < 1 && somme[1] < 1 && somme[2] < 1 && somme[3] < 1 && somme[4] < 1) {
int[] som = new int[5];
Zone = CreateZone(Plateforme);
for (int s = 0; s < 5; s++) {
for (int j = 0; j < Zone.length; j++) {
som[s] = Zone[j][i];
}
}
for (int a = 0; a < 5; a++) {
somme[a] = som[a];
}
}
}
}
return Zone;
}
// generer un tableau de remanufacturing
public int geneR(int[] tabr, int[] Plateforme) {
int somme = 0;
for (int i = 0; i < 5; i++) {
if (Plateforme[i] == 1) {
Random ran = new Random();
int s = ran.nextInt(2);
tabr[i] = s;
} else {
tabr[i] = 0;
}
somme = somme + tabr[i];
}
return somme;
}
// test le tableau de remanufacturing
public int[] testR(int[] Plateforme) {
int[] tabr = new int[5];
// définis somme à 0 et le while fera le travail, pas besoin de dupliquer la ligne de code
int somme = geneR(tabr, Plateforme);
while (somme == 0) {
somme = geneR(tabr, Plateforme);
}
return tabr;
}
// generate 4 tableau de 4 remanufacturing
public int[][] getRemanufacturing(int[] Plateforme) {
int[] []Rema = new int[4][5];
for (int i = 0; i < 4; i++) {
int[] tabR = testR(Plateforme);
for (int j = 0; j < 5; j++) {
Rema[i][j] = tabR[j];
}
}
return Rema;
}
// generer un tableau d'affectation de decheterie
public int geneDeche(int[] tabD, int[] Plateforme) {
int somme = 0;
for (int i = 0; i < 5; i++) {
if (Plateforme[i] == 1) {
Random ran = new Random();
int s = ran.nextInt(2);
tabD[i] = s;
} else {
tabD[i] = 0;
}
somme = somme + tabD[i];
}
return somme;
}
// test les tableau d'affectation de decheterie
public int[] testDeche(int[] Plateforme) {
int[] tabD = new int[5];
int somme = geneDeche(tabD, Plateforme);
while (somme == 0) {
somme = geneDeche(tabD, Plateforme);
}
return tabD;
}
// generer 2 tableau de decheterie
public int[][] getDeche(int[] Plateforme) {
int[][] deche = new int[2][5];
for (int i = 0; i < 2; i++) {
int[] tabD = testDeche(Plateforme);
for (int j = 0; j < 5; j++) {
deche[i][j] = tabD[j];
}
}
return deche;
}
// generer une quantité retournée
// peut être résumé en
// return Affer==0?0:5000;
public int randQR(int AffeR) {
int QR = 0;
if (AffeR == 0) {
QR = 0;
} else {
int x = 5000;
QR = x;
}
return QR;
}
// // generer 4 tabelau de quantité retourné
public int[][] generateQR() {
int[][] TabQR = new int[4][5];
int [][] Rema=getGeneRemanufacturing();
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 5; j++) {
int QR = randQR(Rema[i][j]);
TabQR[i][j] = QR;
}
}
return TabQR;
}
// generer une quantité de decheterie
// return Affer==0?0:10000;
public int randQS(int Affed) {
int QS = 0;
if (Affed == 0) {
QS = 0;
} else {
Random ran = new Random();
int x = 10000;
QS = x;
}
return QS;
}
// // generer 4 tabelau de quantité de decheterie
public int[][] generateQS() {
int[][] TabQS = new int[2][5];
int[][] deche=getGeneDeche();
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 5; j++) {
int QS = randQS(deche[i][j]);
TabQS[i][j] = QS;
}
}
return TabQS;
}
// generer un tableau de vehicules
public int[] randVeh(int[] Plateforme) {
int[] TabVeh = new int[5];
for (int i = 0; i < 5; i++) {
if (Plateforme[i] == 0) {
TabVeh[i] = 0;
} else {
Random ran = new Random();
int x = ran.nextInt(5) + 1;
TabVeh[i] = x;
}
}
return TabVeh;
}
public int[][] getGeneZone() {
return geneZone;
}
public void setGeneZone(int[][] geneZone1) {
geneZone = geneZone1;
}
public void setGeneZone(int[] plateforme)
{
geneZone=getZone(plateforme);
}
public int[][] getGeneRemanufacturing() {
return geneRemanufacturing;
}
public void setGeneRemanufacturing(int[][] geneRemanufacturing1) {
geneRemanufacturing = geneRemanufacturing1;
}
public void setGeneRemanufacturing(int[] Plateforme) {
geneRemanufacturing = getRemanufacturing(Plateforme);
}
public int[][] getGeneDeche() {
return geneDeche;
}
public void setGeneDeche(int[][] geneDeche1) {
geneDeche = geneDeche1;
}
public void setGeneDeche(int[] Plateforme) {
geneDeche = getDeche(Plateforme);
}
public int[][] getGeneQR() {
return geneQR;
}
public void setGeneQR(int[][] geneQR1) {
geneQR = geneQR1;
}
public void setGeneQR() {
geneQR = generateQR();
}
public int[][] getGeneQS() {
return geneQS;
}
public void setGeneQS(int[][] geneQS1) {
geneQS = geneQS1;
}
public void setGeneQS() {
geneQS = generateQS();
}
public int[] getGeneVehicule() {
return geneVehicule;
}
public void setGeneVehicule(int[] geneVehicule1) {
geneVehicule = geneVehicule1;
}
public void setVehicule(int[] Plateforme) {
geneVehicule = randVeh(Plateforme);
}
} |
Problème de création d'une liste ArrayList
Répondre avec citation
Envoyé par tchize_
La plupart des réponses à vos questions sont déjà dans les 
Partager