1. Accueil
  2. Java
  3. Sources Java
  4. Sources Maths et Algorithmes
  5. Le compte est bon

Le compte est bon

Soyez le premier à donner votre avis sur cette source.

Vue 13 969 fois - Téléchargée 1 332 fois

Télécharger le projet
Commenter

Description

Une petite application autour du jeu ancestral de France Television.
Le niveau du solveur est ajustable, 1 pour un joueur débutant, 4 pour un bon joueur, 3 pour un joueur moyen.

Le niveau 5 est spécial car il analyse toutes les solutions possibles, il est donc imbattable, sauf erreur de programmation.

L'intérêt se trouve dans l'algorithme de résolution.

Source / Exemple : 


/**


    	 
  •  methode optimisee pour effectuer un parcourt des solutions dans un arbre

    • 	 
  •  de hauteur 2

    • 	 
  •  

    • 	 
  •  @param a

    • 	 
  •  @param b

    • 	 
  • /

	private final void chercherSolutionReference(int a, int b) {

		List<Operation> operationsPossibles;
		int c;

		operationsPossibles = getOperationsPossibles(a, b);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			c = operationPossible.resultat;
			testerSolution(c, 5);
			solutionCourante.retirerOperation();

		}

	}

	/**


    	 
  •  methode optimisee pour effectuer un parcourt des solutions dans un arbre

    • 	 
  •  de hauteur 3

    • 	 
  •  

    • 	 
  •  @param a

    • 	 
  •  @param b

    • 	 
  •  @param c

    • 	 
  • /

	private final void chercherSolutionReference(int a, int b, int c) {

		List<Operation> operationsPossibles;
		int d;

		operationsPossibles = getOperationsPossibles(a, b);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			d = operationPossible.resultat;
			testerSolution(d, 4);
			chercherSolutionReference(c, d);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, c);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			d = operationPossible.resultat;
			testerSolution(d, 4);
			chercherSolutionReference(b, d);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, c);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			d = operationPossible.resultat;
			testerSolution(d, 4);
			chercherSolutionReference(a, d);
			solutionCourante.retirerOperation();

		}

	}

	/**


    	 
  •  methode optimisee pour effectuer un parcourt des solutions dans un arbre

    • 	 
  •  de hauteur 4

    • 	 
  •  

    • 	 
  •  @param a

    • 	 
  •  @param b

    • 	 
  •  @param c

    • 	 
  •  @param d

    • 	 
  • /

	private final void chercherSolutionReference(int a, int b, int c, int d) {

		List<Operation> operationsPossibles;
		int e;

		operationsPossibles = getOperationsPossibles(a, b);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			e = operationPossible.resultat;
			testerSolution(e, 3);
			chercherSolutionReference(c, d, e);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, c);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			e = operationPossible.resultat;
			testerSolution(e, 3);
			chercherSolutionReference(b, d, e);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			e = operationPossible.resultat;
			testerSolution(e, 3);
			chercherSolutionReference(b, c, e);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, c);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			e = operationPossible.resultat;
			testerSolution(e, 3);
			chercherSolutionReference(a, d, e);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			e = operationPossible.resultat;
			testerSolution(e, 3);
			chercherSolutionReference(a, c, e);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(c, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			e = operationPossible.resultat;
			testerSolution(e, 3);
			chercherSolutionReference(a, b, e);
			solutionCourante.retirerOperation();

		}

	}

	/**


    	 
  •  methode optimisee pour effectuer un parcourt des solutions dans un arbre

    • 	 
  •  de hauteur 5

    • 	 
  •  

    • 	 
  •  @param a

    • 	 
  •  @param b

    • 	 
  •  @param c

    • 	 
  •  @param d

    • 	 
  •  @param e

    • 	 
  • /

	private final void chercherSolutionReference(int a, int b, int c, int d, int e) {

		List<Operation> operationsPossibles;
		int f;

		operationsPossibles = getOperationsPossibles(a, b);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(c, d, e, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, c);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(b, d, e, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(b, c, e, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, e);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(b, c, d, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, c);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(a, d, e, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(a, c, e, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, e);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(a, c, d, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(c, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(a, b, e, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(c, e);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(a, b, d, f);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(d, e);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			f = operationPossible.resultat;
			testerSolution(f, 2);
			chercherSolutionReference(a, b, c, f);
			solutionCourante.retirerOperation();

		}

	}

	/**


    	 
  •  methode optimisee pour effectuer un parcourt des solutions dans un arbre

    • 	 
  •  de hauteur 6

    • 	 
  •  

    • 	 
  •  @param a

    • 	 
  •  @param b

    • 	 
  •  @param c

    • 	 
  •  @param d

    • 	 
  •  @param e

    • 	 
  •  @param f

    • 	 
  • /

	private final void chercherSolutionReference(int a, int b, int c, int d, int e, int f) {

		List<Operation> operationsPossibles;
		int g;

		operationsPossibles = getOperationsPossibles(a, b);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(c, d, e, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, c);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(b, d, e, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(b, c, e, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, e);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(b, c, d, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(a, f);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(b, c, d, e, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, c);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, d, e, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, c, e, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, e);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, c, d, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(b, f);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, c, d, e, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(c, d);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, b, e, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(c, e);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, b, d, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(c, f);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, b, d, e, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(d, e);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, b, c, f, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(d, f);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, b, c, e, g);
			solutionCourante.retirerOperation();

		}

		operationsPossibles = getOperationsPossibles(e, f);

		for (Operation operationPossible : operationsPossibles) {

			solutionCourante.ajouterOperation(operationPossible);
			g = operationPossible.resultat;
			testerSolution(g, 1);
			chercherSolutionReference(a, b, c, d, g);
			solutionCourante.retirerOperation();

		}

	}

Conclusion :


L'algorithme est optimisé mais pas multithreadé, c'est une piste d'amélioration.
Les solutions présentées par l'ordinateur au niveau 1 et 2 ne sont pas très naturelles.
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire Commentaires
cs_Julien39 Messages postés 6414 Date d'inscription mardi 8 mars 2005 Statut Modérateur Dernière intervention 29 juillet 2020 369
13 mars 2011 à 10:58
Pour améliorer la lisibilité et la testabilité de ton code, il serait peut être intéressant de décomposer ta fonction en plusieurs sous fonctions.

Les blocs catch sans rien sont dangereux !

Sinon, ca marche bien
cs_jojolemariole Messages postés 519 Date d'inscription mercredi 21 mars 2007 Statut Membre Dernière intervention 19 décembre 2016 25
13 mars 2011 à 11:09
Salut,

Une exception n'est pas nécessairement une erreur. Dans ce cas, il s'agit d'exceptions levées dans le but de signaler que l'opération testée n'est pas légale ou pas utile (division par 1, soustraction négative...). Pas de problème de ce côté-là selon moi.
Concernant la lisibilité du code, tu as raison : elle est faible dans cette méthode. Mais dans ce genre d'algos, il faut rechercher la performance au détriment de la lisibilité. Y'a encore du boulot c'est sûr.
cs_marcos72 Messages postés 1 Date d'inscription lundi 8 octobre 2007 Statut Membre Dernière intervention 15 mars 2011
15 mars 2011 à 10:52
Bonjour,

Interface conviviale. En lançant le fichier .bat le programme se lance et s'exécute bien. J'ai voulu importer ton projet dans eclipse pour regarder le code mais là il y des soucis à la compilation car le package utilitaire.jar fournit les .class mais j'ai pas trouvé les .java correspondants. As tu développé toi même utilitaire.jar? si oui pourrais tu S.T.P ajouter les sources ?
cs_jojolemariole Messages postés 519 Date d'inscription mercredi 21 mars 2007 Statut Membre Dernière intervention 19 décembre 2016 25
15 mars 2011 à 11:16
Salut,
Merci pour ton commentaire.
Oui, j'ai développé la bibliothèque utilitaire, je vais ajouter les sources cet après-midi, avec quelques optimisations.
cs_jojolemariole Messages postés 519 Date d'inscription mercredi 21 mars 2007 Statut Membre Dernière intervention 19 décembre 2016 25
16 mars 2011 à 10:12
Re,
La mise à jour sera pour plus tard, j'ai pas mal de travail par ailleurs.
J'ai amélioré grandement les performances en ne gérant plus les opération interdites avec des exceptions. Je ne me doutais pas que la gestion des exceptions était si consommatrice de temps pour la JVM.
S'inscrire maintenant

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.

Du même auteur (cs_jojolemariole)