Le compte est bon

Soyez le premier à donner votre avis sur cette source.

Vue 12 867 fois - Téléchargée 1 284 fois

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.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

bonjour est ce que c'est possible d'executér ta classe applicationboncompte.java?
car j'utiise eclipse mais j'arrrive pas.
dit moi comment tu as creer ton executable bon_compte.jar stp?
c'est avec le fichier build.xml?
Messages postés
519
Date d'inscription
mercredi 21 mars 2007
Statut
Membre
Dernière intervention
19 décembre 2016
23
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.
Messages postés
519
Date d'inscription
mercredi 21 mars 2007
Statut
Membre
Dernière intervention
19 décembre 2016
23
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.
Messages postés
1
Date d'inscription
lundi 8 octobre 2007
Statut
Membre
Dernière intervention
15 mars 2011

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 ?
Messages postés
519
Date d'inscription
mercredi 21 mars 2007
Statut
Membre
Dernière intervention
19 décembre 2016
23
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.
Afficher les 6 commentaires

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.