Sujet: Ce qui suit est un T.P que nous avons étudié en formation de développeur.
Thème: Logique combinatoire et division de grands nombres.
Enoncé: Possibilité d'entrer un nombre entre 101 et 999. La machine doit pouvoir le décomposer et vous soumettre toutes les combinaisons de calcul possible. Il doit etre possible de saisir manuellement les combinaisons. Basé sur le jeu: le compte est bon "Des chiffres et des Lettres"
Source / Exemple :
fichier---> calculDuCompteEstBon.java
import java.util.Vector;
final class CalculDuCompteEstBon {
private int plaque[][] = new int[6][6]; //tableau pour traiter les plaques
private int ecart; // ecart entre le resultat en cours et à trouver au cas ou le compte est impossible
private int resultat; //resultat à trouver
private long appel = 0; //nombre d'appel a la fonction recursive
solution temp_soluce = new solution(); //sauvegarde de la solution en cours
Vector lesSolutions = new Vector(); //vecteur contenant les solutions
long nb_appel() {return appel;}
void rempli(int pb[],int total) {
for (int i=0;i<=5;i++)
plaque[5][i] = pb[i];
resultat = total;
for(int h=0;h<6;h++) temp_soluce.reset(h);
lesSolutions.removeAllElements();
}
void affiche_soluce(){
for (int i=0;i<lesSolutions.size();i++) ((solution)lesSolutions.elementAt(i)).affiche();
System.out.println(lesSolutions.size());
}
int nbSolution(){return lesSolutions.size();}
String uneSolution(int numero,int l){
if (numero > lesSolutions.size()){return "Erreur";}
else{
String temp;
solution ttt;
ttt = (solution)lesSolutions.elementAt(numero);
temp = ttt.ligne(l);
return temp;}
}
void compte(int niveau) {
appel++; //Nombre d'appel de la fonction recursive.
boolean t_resultat = false;
/* comparaison de resultat */
if (plaque[niveau][0]==resultat) { // le resultat est trouve
t_resultat = true;
solution rr =new solution();
rr.egale(temp_soluce);
if (lesSolutions.size() == 0) { //si aucune solution creation.
solution tempp = new solution();
tempp.egale(temp_soluce);
lesSolutions.addElement(tempp);
} else {
boolean ajout = false;
for (int i=0;i<lesSolutions.size();i++) {
boolean temp;
if (rr.niveau() >= ((solution)lesSolutions.elementAt(i)).niveau()) {
temp = rr.compare(rr,(solution)lesSolutions.elementAt(i));
} else {
temp = rr.compare((solution)lesSolutions.elementAt(i),rr);
}
if (temp){ //doit remplacer l'existant cas des solutions avec operations inutiles
if (rr.niveau() >= ((solution)lesSolutions.elementAt(i)).niveau()){
lesSolutions.removeElementAt(i);
i--;
ajout = true;
}else{
rr.egale((solution)lesSolutions.elementAt(i));
i=0;
}
}else{
ajout = true;
}
}
if (ajout) lesSolutions.addElement(rr);
}
} else {
if (Math.abs(plaque[niveau][0] - resultat) < ecart) ecart = Math.abs(plaque[niveau][0] - resultat);
}
if (t_resultat) return;
if (niveau == 0) return; //si nous sommes au niveau 0 c'est que la solution n'a pas été trouvée
/* boucle for pour traiter toutes les combinaisons par niveau
- pour une rangée de plaque si des plaques sont identiques on traite plusieurs fois
- les même combinaiasons cette boucle a pour but de ne traiter par la suite que les combinaisons
- interessantes à traiter, elle ralentit le traitement de la boucle lorsque toutes les plaques
- sont differentes mais l'accelere enormement lorsqu'elles sont identiques.
- elle a aussi l'avantage de filtrer une premiere fois les solutions en eliminant les solutions identiques */
int combinaison[][] = new int[2][16];
for (int a = 0;a<=(niveau -1);a++) {
for (int b = a+1;b<=niveau;b++) {
int c = 0;
boolean existe = false;
while (combinaison[0][c] != 0){
if ((combinaison[0][c] == plaque[niveau][a] & combinaison[1][c] == plaque[niveau][b])||(combinaison[1][c] == plaque[niveau][a] & combinaison[0][c] == plaque[niveau][b]) ) existe = true;
c++;
}
if (!existe) {
if (plaque[niveau][a]>plaque[niveau][b]){
combinaison[0][c]= plaque[niveau][a];
combinaison[1][c]= plaque[niveau][b];
}else{
combinaison[0][c]= plaque[niveau][b];
combinaison[1][c]= plaque[niveau][a];
}
}
}
}
// Début du traitement de toutes les combinaisons //
int compt = 0;
while (combinaison[0][compt] != 0 ) {
/* on choisit deux plaques qui vous nous servir pour les 4 CalculDuCompteEstBonDuCompteEstBons possibles */
int P1 = combinaison[0][compt];
int P2 = combinaison[1][compt];
/* je rempli le tableau du niveau inferieur avec les plaques restantes
le resultat de l'operation y sera insere en premiere position par la suite */
int pointeur = 1;
boolean p_a = true;
boolean p_b = true;
for (int z=0;z<=niveau;z++) {
if (plaque[niveau][z]==P1 && p_a) {
p_a = false;
continue;
}
if (plaque[niveau][z]==P2 && p_b) {
p_b = false;
continue;
}
plaque[(niveau - 1)][pointeur]=plaque[niveau][z];
pointeur++;
}
/* maintenant on traite toutes les opérations possible sur les 2 plaques
selectionnées precedement */
// ADDITION
plaque[(niveau - 1)][0] = (P1 + P2);
temp_soluce.set(niveau,P1,'+',P2,P1+P2);
compte(niveau-1);
temp_soluce.reset(niveau);
// SOUSTRACTION
if ((P1 - P2) > 0 ) {
plaque[(niveau - 1)][0] = (P1 - P2);
temp_soluce.set(niveau,P1,'-',P2,P1-P2);
compte(niveau-1);
temp_soluce.reset(niveau);
}
if ((P2 - P1) > 0 ) {
plaque[(niveau - 1)][0] = (P2 - P1);
temp_soluce.set(niveau,P2,'-',P1,P2-P1);
compte(niveau-1);
temp_soluce.reset(niveau);
}
// MULTIPLICATION l'operation est inutile si p1 ou p2 est egale a 1
if (!(P1==1)&!(P2==1)) {
plaque[(niveau - 1)][0] = (P1 * P2);
temp_soluce.set(niveau,P1,'*',P2,P1*P2);
compte(niveau-1);
temp_soluce.reset(niveau);
// DIVISION
if (P1%P2 == 0) {
plaque[(niveau - 1)][0] = (P1/P2);
temp_soluce.set(niveau,P1,'/',P2,P1/P2);
compte(niveau-1);
temp_soluce.reset(niveau);
}
if (P2%P1 == 0) {
plaque[(niveau - 1)][0] = (P2/P1);
temp_soluce.set(niveau,P2,'/',P1,P2/P1);
compte(niveau-1);
temp_soluce.reset(niveau);
}
}
compt++;
}
}
class operation {
int p1,p2,resultat;
char op;
operation(){
p1 = 0;
op = ' ';
p2 = 0;
resultat = 0;
}
operation(int a,char b,int c,int d){
p1 = a;
op = b;
p2 = c;
resultat = d;
}
boolean compare(operation a){
if (this.p1==a.p1 && this.p2==a.p2 && this.op == a.op)return true;
return false;
}
void egale(operation a){
this.p1 = a.p1;
this.p2 = a.p2;
this.op = a.op;
this.resultat = a.resultat;
}
void reset(){
p1 = 0;
op = ' ';
p2 = 0;
resultat = 0;
}
void set(int a,char b,int c,int d){
p1 = a;
op = b;
p2 = c;
resultat = d;
}
String op_affiche(){
String pp1 = Integer.toString(p1);
String pp2 = Integer.toString(p2);
String presult = Integer.toString(resultat);
return pp1+op+pp2+"="+presult+" ";
}
}
class solution {
operation soluce[] = new operation[6] ; //= new operation();
int niveau;
solution() {for (int i=0;i<6;i++) soluce[i] = new operation();}
void set (int niv,int p1,char op,int p2,int result) {
soluce[niv].set(p1,op,p2,result);
niveau = niv;
}
void reset (int niv){
soluce[niv].reset();
this.niveau = niv;
}
void affiche(){
for (int i=5;i>=niveau;i--) System.out.print (soluce[i].op_affiche());
System.out.println(" ");
}
String ligne(int l){
if (soluce[l].resultat == 0) return " ";
return soluce[l].op_affiche();
}
operation retourne(int niv) {return soluce[niv];}
void egale(solution a){
this.niveau = a.niveau();
for (int i=0;i<6;i++) this.soluce[i].egale(a.retourne(i));
}
boolean compare (solution a,solution b){ //doit comparer deux solutions
boolean trouve;
for (int i=5;i>=a.niveau();i--) {
trouve = false;
for (int j=5;j>=b.niveau();j--) {
if (a.soluce[i].compare(b.soluce[j])) trouve = true;
}
if (!trouve) return false;
}
return true;
}
int niveau () {return this.niveau;}
}
}
-------------------------------------------------------------------------------------------------------------------
---> fichier: le_compte_est_bon.java
import java.awt.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.applet.*;
import java.lang.String;
import java.util.Vector;
import java.util.*;
public class Le_compte_est_bon extends java.applet.Applet {
boutonPerso boutonPlus = new boutonPerso("+",Color.cyan);
boutonPerso boutonMoins = new boutonPerso("-",Color.cyan);
boutonPerso boutonMult = new boutonPerso("x",Color.cyan);
boutonPerso boutonDiv = new boutonPerso("/",Color.cyan);
boutonPerso tirage = new boutonPerso("Tirage Aléatoire");
boutonPerso voirSolutions = new boutonPerso("Voir Les Solutions !");
boutonPerso quitter = new boutonPerso("Quitter");
boutonPerso droite = new boutonPerso(">");
boutonPerso gauche = new boutonPerso("<");
TextField indicateur = new TextField(6);
TextField lab_p1 = new TextField(3);
TextField lab_p2 = new TextField(3);
TextField lab_p3 = new TextField(3);
TextField lab_p4 = new TextField(3);
TextField lab_p5 = new TextField(3);
TextField lab_p6 = new TextField(3);
TextField lab_resultat = new TextField(3);
CalculDuCompteEstBon leCompte = new CalculDuCompteEstBon();
List liste = new List(5,false);
int solutionEnCours = 0;
public void init() {
//dessin de l'interface.
setLayout(new GridLayout(6,1));
Panel pan_resultat = new Panel();
Panel pan_plaque = new Panel();
Panel pan_operation = new Panel();
Panel pan_tableau = new Panel();
Panel pan_navig = new Panel();
Panel pan_control = new Panel();
pan_resultat.add(lab_resultat);
pan_plaque.add(lab_p1); pan_plaque.add(lab_p2); pan_plaque.add(lab_p3);
pan_plaque.add(lab_p4); pan_plaque.add(lab_p5); pan_plaque.add(lab_p6);
pan_operation.add(boutonPlus);
pan_operation.add(boutonMoins);
pan_operation.add(boutonMult);
pan_operation.add(boutonDiv);
pan_tableau.add(liste);
pan_navig.add(gauche);
pan_navig.add(indicateur);
pan_navig.add(droite);
pan_control.add(tirage);
pan_control.add(voirSolutions);
pan_control.add(quitter);
add(pan_resultat);
add(pan_plaque);
add(pan_operation);
add(pan_tableau);
add(pan_navig);
add(pan_control);
}
public void paint(Graphics g) {
g.drawString("le compte est bon", 50, 60 );
}
class boutonPerso extends Button implements ActionListener {
public boutonPerso(String nom,Color couleur){
super(nom);
this.setBackground(couleur);
this.setSize(300,300);
addActionListener(this);
}
public boutonPerso(String nom){
super(nom);
this.setSize(300,300);
addActionListener(this);
}
public void actionPerformed(ActionEvent e) {
Object oBouton = e.getSource();
if (oBouton == boutonPlus ) {
System.out.println("+++++++");
}
if (oBouton == boutonMoins ) {
System.out.println("------");
}
if (oBouton == boutonMult ) {
System.out.println("xxxxxxx");
}
if (oBouton == boutonDiv ) {
System.out.println("////////");
}
if (oBouton == tirage ) {
Random r = new Random();
int plak;
Integer chiffre = new Integer(Math.abs(r.nextInt() % 898) + 101); //tirage du resultat à trouver
lab_resultat.setText(chiffre.toString());
int plaquette[][] = {{1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,25,50,75,100},{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
plak = Math.abs(r.nextInt() % 23);
lab_p1.setText(chiffre.toString(plaquette[0][plak]));
int j=0;
for (int i=0;i<23;i++){if (i == plak) continue;plaquette[1][j] = plaquette[0][i];j++;}
plak = Math.abs(r.nextInt() % 22);
lab_p2.setText(chiffre.toString(plaquette[1][plak]));
j=0;
for (int i=0;i<22;i++){if (i == plak) continue;plaquette[2][j] = plaquette[1][i];j++;}
plak = Math.abs(r.nextInt() % 21);
lab_p3.setText(chiffre.toString(plaquette[2][plak]));
j=0;
for (int i=0;i<21;i++){if (i == plak) continue;plaquette[3][j] = plaquette[2][i];j++;}
plak = Math.abs(r.nextInt() % 20);
lab_p4.setText(chiffre.toString(plaquette[3][plak]));
j=0;
for (int i=0;i<20;i++){if (i == plak) continue;plaquette[4][j] = plaquette[3][i];j++;}
plak = Math.abs(r.nextInt() % 19);
lab_p5.setText(chiffre.toString(plaquette[4][plak]));
j=0;
for (int i=0;i<19;i++){if (i == plak) continue;plaquette[5][j] = plaquette[4][i];j++;}
plak = Math.abs(r.nextInt() % 18);
lab_p6.setText(chiffre.toString(plaquette[5][plak]));
liste.removeAll();
indicateur.setText(" ");
solutionEnCours = 0;
}
if (oBouton == voirSolutions ) {
Integer temp;
int tirage[] = new int[6];
System.out.println("t"+ lab_p1.getText() +"t");
if (lab_p1.getText() == ""){liste.addItem("tt");return;}
//return;
temp = Integer.decode(lab_p1.getText());tirage[0] = temp.intValue();
temp = Integer.decode(lab_p2.getText());tirage[1] = temp.intValue();
temp = Integer.decode(lab_p3.getText());tirage[2] = temp.intValue();
temp = Integer.decode(lab_p4.getText());tirage[3] = temp.intValue();
temp = Integer.decode(lab_p5.getText());tirage[4] = temp.intValue();
temp = Integer.decode(lab_p6.getText());tirage[5] = temp.intValue();
temp = Integer.decode(lab_resultat.getText());
for (int i=0;i<6;i++){if (tirage[i] == 0){liste.removeAll();liste.addItem("Les chiffres");liste.addItem("doivent être");liste.addItem("supérieur");liste.addItem("à 0");return;}}
solutionEnCours = 0;
liste.removeAll();
liste.addItem("Veuillez");
liste.addItem("patienter..");
leCompte.rempli(tirage,temp.intValue());
leCompte.compte(5);
liste.removeAll();
if (leCompte.nbSolution() == 0) {liste.addItem("Pas de");liste.addItem("Solutions");return;}
for (int i=5;i>0;i--){liste.addItem(leCompte.uneSolution(solutionEnCours,i));}
solutionEnCours++;
indicateur.setText(solutionEnCours+"/"+leCompte.nbSolution());
}
if (oBouton == quitter ) {
System.out.println("////////");
}
if (oBouton == droite ) {
if (solutionEnCours == 0) return;
if (solutionEnCours == leCompte.nbSolution()) return;
liste.removeAll();
for (int i=5;i>0;i--){liste.addItem(leCompte.uneSolution(solutionEnCours,i));}
solutionEnCours++;
indicateur.setText(solutionEnCours+"/"+leCompte.nbSolution());
}
if (oBouton == gauche ) {
if (solutionEnCours <= 1) return;
liste.removeAll();
solutionEnCours--;
for (int i=5;i>0;i--){liste.addItem(leCompte.uneSolution(solutionEnCours-1,i));}
indicateur.setText(solutionEnCours+"/"+leCompte.nbSolution());
}
}
}
}
----------------------------------------------------------------------------------------------------------
fichier----> Le_compte_est_bon.htm
<html>
<head>
<title>Olivier | Applet Java Le compte est bon</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>
<!--<body bgcolor="#99CCFF" text="#004080">-->
<!-- Temporary files -->
<BODY bgColor="#FFFFFF" background="../../styles/fondGris.gif">
<!-- Temporary files -->
<!--<body bgcolor='#99CCFF'>-->
<div align="center">
<p align="left"><i><b><a href="mailto:ami.informaticien@laposte.net">Olivier</a> Applet Java le compte est bon</b></i></p>
<p><b><font size="5">Calcul du compte est bon </font></b></p><br>
<p align="left"><b>Cette applet propose de résoudre le problème
du compte est bon.</b></p>
<p align="left">Hélas, le temps a manqué pour terminer la gestion
des exceptions. Ainsi pour tester l'applet il faut remplir tous les champs
avec des valeurs superieures à 0 et ne pas mettre le résultat à trouver dans les plaquettes.</p>
<p align="left"><b><u>Le problème</b></u>: il consiste à trouver un résultat
compris entre <b><font size=4 color=red>101 et 999</b></font> à l'aide de 6 plaquettes tirées au
sort (parmis 2 plaquettes représentant les chiffres de 1 à 9
puis une de 10,25,50,75,100), en utilisant les opérations de base que
sont l'addition, la soustraction, la multiplication et la division.Le tout
en restant dans l'ensemble des entiers positifs.</p><hr>
<p align="left"><b><u>Résolution du problème</u>: </b>pour la résolution
de ce problème je souhaitais connaitre toutes les solutions possibles
ce qui me contraint à calculer pour un problème donné
dans le pire des cas :</p><hr>
<p align="center"><img src="equation.gif" width="411" height="71"><font size="6">combinaisons</font></p>
<p align="left">Heureusement la contrainte de rester dans l'ensemble des entiers
positifs limite le nombre des calculs possibles.Ainsi que les multiplications
ou les divisions par un.Je laisse le soin aux personnes que cela intéressent
de regarder le code.</p><hr>
<p align="left">Reste que la plus grande difficulté réside dans
le filtrage des solutions.En effet pour un probléme on peut trouver
de nombreuses solutions équivalentes ou comportant des étapes
inutiles.La première des solutions est de travailler sur les combinaisons
de plaquettes et non les plaquettes elles-même.Ceci évite dans
le cas où il y a des plaquettes identiques de retrouver plusieurs fois
les mêmes resultats et dans ce cas de les calculer réduisant
ainsi le nombre de combinaisons.</p>
<p align="left">Le deuxième filtrage : Si une solution contient les mêmes
opérations qu'une autre solution ,la solution comportant le plus grand
nombre d'opération est supprimée(ou à défaut,
même nombre d'opération : solutions équivalentes, une
est supprimée).</p><hr>
<p align="left">Exemple : 3 2 6 100 (600) </p>
<p align="left">Solution 1 : 3 x 2 = 6 , 6 x100 = 600</p>
<p align="left">Solution 2 : 6 x 100 = 600</p>
<p align="left">Seule la solution n°2 est retenue.</p><hr>
<p align="center"><font size="5"><b></b></font></p>
<p align="center"><img src="3djava.jpg" width="100" height="49"></p>
<p align="left"><u><B><CENTER>Pour ceux qui ont eu le courage de lire jusqu'ici un petit exemple</u>:</p></CENTER></B>
<p align="left"> </p>
<p align="center"><applet code="Le_compte_est_bon.class" archive="LCEB2.zip" width="500" height="500"> </applet> </p>
<table border="0" cellpadding="0" cellspacing="0" id="header">
<tr>
<td id="logo">
<a href="index.html" title="Telecharger"><img src="Zip.gif" alt="Telecharger" /></a>
<h1 class='site-name'><a href="index.html" title="Home"></a></h1>
<p align="left"><b><a href="LCEB2.zip">Télécharger l'Applet</a></b>
</p>
<br>
<p align="left"><a href="index.html" title="zip"><br><img src="Zip.gif" alt="Telecharger" /></a>
<b><a href="LCEB2.zip">Télécharger les sources</a></b>
</p>
</div>
</body>
</html>
-------------------------------------------------------------------------------------------------
Conclusion :
Lancer l'application par le fichier HTML. Voila, ça marche à peu près (Gestion des exceptions à revoir et problème lors de la saisie manuelle du nombre à trouver et des combinaisons). à bientôt. Olivier
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.