Le compte est bon

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

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)