LE COMPTE EST BON APPLET

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>
-------------------------------------------------------------------------------------------------

Télécharger le zip

20 octobre 2006 09:37:23 :

Précisions concernant l'état d'avancement du projet et les choses à revoir.

20 octobre 2006 09:40:00 :

J'ai enlevé une faute d'orthographe qui me genait vraiment!!

20 octobre 2006 09:42:51 :

orthographe bis++