Bonjour,
je voudrais coder l’organigramme ci-joint en JAVA. Je suis arrivé à l’idée de créer trois boucles while (symbolisées par les pointillés) repérées par trois étiquettes sur lesquelles viendraient se brancher des break.
La démarche me semble quelque peu artificielle, cela vient-il forcément d’une mauvaise conception ?
orga.pdf (12.3 KB)
Woaw ! Je vois pas de moyen de coder ça proprement par contre il me semble qu’il pourrait être écris de manière propre si tu voyais ça comme un automate à état fini.
Bonjour,
Je ne comprends pas le schéma, peut-être que si tu postes le code java j’aurais une idée.
voilà le code qui marche presque (l’organigramme a un peu changé)
la méthode ‘place’ refuse simplement que l’on mette la pièce 3 à l’emplacement 2 (pour l’instant), et la 15 en 14.
J’ai bien galéré car j’ai tardé à mettre l’étiquette ‘titi’, je la croyais inutile. Est-ce parce que continue se trouve dans une boucle for ?
Le ‘continue’ sans ‘titi’ est-il considéré comme ‘continue la boucle for’ ? Il semblerait.
[code]package pac;
public class dh
{
public static void main(String[] args)
{
int [][] resol = new int [18][2]; // contient n° pièce et orientation
int min [] = {1,1,1,1,1,1,7,7,7,7,7,7,7,7,7,7,7,7};
int max [] = {6,6,6,6,6,6,18,18,18,18,18,18,18,18,18,18,18,18};
resol[0][0]=1; resol[0][1]=1;
int e = 0 ;
gen : while (e >= 0 && e < 18 )
{
resol[e][1] = matrice.place (e,resol[e][0],resol[e][1]);
if (resol[e][1]<9)
{
if (e==17) { System.out.println ("OK"); break;}
e++;
{resol[e][0] = min [e]; resol [e][1] = 0 ;
titi : while (true)
{
for (int j = (min [e]-1); j < e ; j++){if (resol[e][0] == resol[j][0]){ resol[e][0]++;continue titi;}}
break;
}
}
}
else
{
toto : while (true)
{resol[e][0]++;
if (resol[e][0]>max[e])
{
if (e == 0) {System.out.println ("impossible");break gen;}
e--; resol[e][1]++; break;
}
for (int j = min [e]-1; j < e; j++) {if (resol[e][0] == resol[j][0]) continue toto;}
break;
}
}
}
for (int d=0 ; d<18 ; d++) System.out.println ("empl "+d+" pièce "+resol[d][0]+" pos "+resol[d][1]);
}
}
[/code]
donne en console
OK
empl 0 pièce 1 pos 1
empl 1 pièce 2 pos 1
empl 2 pièce 4 pos 1
empl 3 pièce 3 pos 1
empl 4 pièce 5 pos 1
empl 5 pièce 6 pos 1
empl 6 pièce 7 pos 1
empl 7 pièce 8 pos 1
empl 8 pièce 9 pos 1
empl 9 pièce 10 pos 1
empl 10 pièce 11 pos 1
empl 11 pièce 12 pos 1
empl 12 pièce 13 pos 1
empl 13 pièce 14 pos 1
empl 14 pièce 16 pos 1
empl 15 pièce 15 pos 1
empl 16 pièce 17 pos 1
empl 17 pièce 18 pos 1
Qu’en pensez-vous ?
nb : c’est la classe matrice qui s’occupe maintenant de tourner la pièce jusqu’à pouvoir la placer. Ou non.
Ben même avec des goto, je vois des variables et des étiquettes non explicites, donne des noms clairs à tes variables ou bien décris un peu mieux ce que fait ton algorithme. En tout cas, tel que c’est quasi incompréhensible quand on ne connaît pas le problème. Tu nous parles de pièces, de places et de retournement, on (moi en tout cas) ne pige rien.
J’ai regardé vite fait (en indentant parce que sinon c’est illisible).
Et pour cette partie :
while (true) {
for (int j = (min [e]-1); j < e ; j++){
if (resol[e][0] == resol[j][0]) {
resol[e][0]++;
continue titi;
}
}
break;
}
ça devrait pouvoir se remplacer par :
int j;
do {
for (j = (min [e]-1); j < e ; j++){
if (resol[e][0] == resol[j][0]) {
resol[e][0]++;
break;
}
}
} while(j < e);
ça permet déjà de virer une étiquette et un goto (même si ce n’est pas très très propre).
Pour rire une solution sale serait :
for (int j = (min [e]-1); j < e ; j++){
if (resol[e][0] == resol[j][0]) {
resol[e][0]++;
j = (min [e]-1)-1; // c'est vraiment pas génial de modifier ainsi j
}
}
Allez pour virer le toto, tu devrais pouvoir remplacer ça :
toto:
while (true) {
resol[e][0]++;
if (resol[e][0]>max[e]) {
if (e == 0) {
System.out.println ("impossible");
break gen;
}
e--;
resol[e][1]++;
break;
}
for (int j = min [e]-1; j < e; j++) {
if (resol[e][0] == resol[j][0]) continue toto;
}
break;
}
par :
[code]do {
resol[e][0]++;
if (resol[e][0]>max[e]) {
if (e == 0) {
System.out.println (“impossible”);
break gen;
}
e–;
resol[e][1]++;
break;
}
} while(test(resol, min, e));
private boolean test(final int [][] resol, final int [] min, final int e) {
boolean ret = false;
for (int j = min [e]-1; j < e; j++) {
if (resol[e][0] == resol[j][0]) {
ret = true;
}
}
return ret;
}[/code]
Mais je suis d’avis que remplacer des variables pars des attributs serais une bonne idée.
Ca y est, le programme trouve la solution. (fichier joint)
Il s’agit d’une masturbation intellectuelle qui me permet de trouver la solution d’un casse-tête.
Je place des pièces jusqu’à ce que ça coince, j’enlève alors pour placer autrement. Il met 2 min pour trouver OK
empl 0 pièce 0 pos 4
empl 1 pièce 2 pos 3
empl 2 pièce 3 pos 2
empl 3 pièce 4 pos 6
empl 4 pièce 1 pos 3
empl 5 pièce 5 pos 8
empl 6 pièce 12 pos 1
empl 7 pièce 17 pos 6
empl 8 pièce 10 pos 8
empl 9 pièce 7 pos 1
empl 10 pièce 16 pos 3
empl 11 pièce 9 pos 1
empl 12 pièce 13 pos 7
empl 13 pièce 15 pos 1
empl 14 pièce 8 pos 4
empl 15 pièce 14 pos 4
empl 16 pièce 11 pos 5
empl 17 pièce 6 pos 1
Il ne me reste plus qu’à modifier comme tu me l’as indiqué pour les branchements.
J’aimerais aussi qu’il me dise l’ordre de montage parce que le résultat est assez difficile à transposer.
L’idéal, un petit visuel en Swing …
cassetete.odt (17.3 KB)