A voir également:
- Mastermind java
- Waptrick java football - Télécharger - Jeux vidéo
- Java apk - Télécharger - Langages
- Jeux java itel football - Télécharger - Jeux vidéo
- Waptrick java ✓ - Forum Mobile
- Jeux java itel 5360 ✓ - Forum Mobile
5 réponses
Je vous ai mis pas mal de commentaire utile, en esperant que ca vous serve
/*
* Atelier.java
*/
public class Atelier {
// définition des constantes
final static int nbCellules = 5;
final static int nbCouleurs =9;
final static int tailleCercle = 20;
private static Dessin dessin;
private static int[] solution;
public static void main(String[] args) {
Logo logo = new Logo("MasterMind... A vos cerveaux", 500, 360);
dessin = logo.dessin();
logo.afficher();
}
private static void ecrire(Object obj)
{
System.out.print(obj);
}
private static void aLaLigne()
{
System.out.println();
}
//===================================================================
// Procédure 1
// public static void proc1()
//{
// creerCombinaison();
// remplirCombinaison( );
// afficher ();
// }// fin de proc1()
//===================================================================
//Création de la combinaison
// public static void creerCombinaison()
// {
// int[] solution;
// solution = new int [nbCellules];
// }
//=====================================================================
public static void afficher (int[]combi)
{
;
for (int i=0; i< nbCellules; i=i+1)
{
ecrire(combi [i]);
}
} // fin de affiche
//===================================================================
// affichage d'une combinaison
public static void afficherCombinaison(int[]combi, int x, int y)
{
for (int i=0; i< nbCellules; i=i+1)
{
dessin.tracerOvalePlein( x+20*i, y+1, tailleCercle - 2, tailleCercle -2, combi[i] );
dessin.tracerOvaleVide ( x+20*i, y+1, tailleCercle - 2, tailleCercle -2, "noir");
//pour chaque valeur du tableau i on dessinera un cercle, les cercles se situeront les uns a la suite des autres.
}
} // fin de afficheCombinaison
//===================================================================
// affichage d'un cercle
public static void afficherCercle()
{
int x =50; int y = 100;
dessin.tracerOvalePlein( x+20, y+1, tailleCercle - 2, tailleCercle -2, 5 );
dessin.tracerOvaleVide ( x+20, y+1, tailleCercle - 2, tailleCercle -2, "noir");
} // fin de afficheCercle
//===================================================================
// remplissage d'une combinaison
public static int[] remplirCombinaison( )
{
int[] T;
T = new int [nbCellules];
for (int i=0; i< nbCellules; i=i+1)
{
T [i] = entierAleatoire(1,9) ;
//rempli chaque case par une valeur aléatoire allant de 1 à 9.
}
return T;
} // fin de remplirCombinaison
//===================================================================
// Procédure 2
public static void proc2()
{
int x = 100;
int y = 0;
afficherPlateau();
int[] combi1 = remplirCombinaison();
int[] combi2 = remplirCombinaison();
int[] combi3 = remplirCombinaison();
afficher(combi1);afficher(combi2);afficher(combi3);
afficherCombinaison(combi1,x,y);afficherCombinaison(combi2,x,y+tailleCercle);afficherCombinaison(combi3,x,y+2*tailleCercle);
} // fin de proc2()
//===================================================================
// Procédure 3
public static void proc3()
{ int x = 100; int y =0;
int valeur =0;
int [] proposition;
int nbPropositions = 0;
int nbTentativesMax = 12;
while (nbPropositions<=nbTentativesMax)
{
valeur=Dialogue.lireEntier("entrez votre combinaison"+valeur);
if ((valeur < 11111)&&(valeur>99999))
{
Dialogue.message("Erreur...Le nombre de couleurs est incorrect");
// on vérifie que la valeur entrée est au format de celle que l'on demande
}
else
{
String s = String.valueOf(valeur);
proposition = transformationChaineenCombi(s);
afficherPlateau();
afficher(proposition);
afficherCombinaison(proposition,x,y);
nbPropositions = nbPropositions + 1;
y = y+tailleCercle;
}
}
} // fin de proc3()
//===================================================================
// Procédure 4 - mise en place des comparaisons et affichage des résultats
public static void proc4()
{
boolean param= false;
int x = 100; int y = 0;int[] proposition;
// création de la combinaison à rechercher
int[]solution;
// création de la solution aléatoire
solution = remplirCombinaison();
afficher(solution);
// affichage TEXTUEL de la solution
// initialisation du jeu
afficherPlateau();
// affichage du plateau du jeu
afficherSolution( param, solution);
int nbPropositions =0;
int nbBienPlaces =0;
int nbMalPlaces =0;
int valeur=0;
while ( (nbPropositions<12) && (param == false) )
{
valeur = Dialogue.lireEntier("entrez votre combinaison"+valeur);
// si vous n'avez pas joué 12 tentatives, le jeu continue
if ((valeur < 11111)&&(valeur>99999))
{
Dialogue.message("Erreur...Le nombre de couleurs est incorrect");
// verification de la valeur entrée
}
else
{
String s = String.valueOf(valeur);
proposition = transformationChaineenCombi(s);
//transforme la valeur entrée en tableau
afficherPlateau();
afficher(proposition);
afficherCombinaison(proposition,x,y);
//affiche le plateau, la proposition
y = y+tailleCercle;
param = ( nombreDeBienPlaces(proposition,solution) == 5 );
/*Si le nombre de pions bien placés est égal à 5
alors le parametre devient vrai,
on fait appel à ce parametre plus tard pour
terminer la boucle (et ainsi le jeu).
*/
int nbmalpl = nombreDeMalPlaces(proposition,solution);
int nbbpl = nombreDeBienPlaces(proposition,solution);
/*On fait appel aux methodes nombreDeBienPlaces et nombreDeMalPlaces
pour affecter des valeurs à nbbpl et nbmalpl, car on peut faire appel à ces valeurs
dans la methode suivante mais on ne peut pas faire appel à la methode elle même
*/
afficherResultat (nbPropositions, nbbpl, nbmalpl );
//affiche des pions rouge et blancs pour chaque pions bien ou mal placés
nbPropositions = nbPropositions + 1;
//on augmente de 1 la valeur de nbPropositions pour continuer la boucle
}
}
if ( param == true )
{
Dialogue.message("Bravo vous avez gagné !!");
/*si la parametre est vraie (lorsque le nombre de pion biens placés vaut 5
alors ce message s'affiche et la boucle ne se relancera pas :
le jeu s'arrete
*/
}
else
Dialogue.message("Bravo vous ètes un paté !! ");
/* au bout des 12 tentatives si l'evenement "vous avez gagné"
n'est pas appelé alors ce message s'affiche
pour vous indiquer votre defaite face à l'ordinateur !
*/
// affichage de la solution avec son bandeau
param= true ;
afficherSolution (param,solution );
/* Si la boucle n'a pas fait apparaitre la solution,
il faut bien que celle-ci soit devoilé au joueur
on applique au boolean "param" la valeur true d'office afin que
la solution s'affiche,et la valeur true ne sera appliquer qu'en fin
de proc4().
*/
} // fin de proc4()
//===================================================================
public static int nombreDeBienPlaces ( int [] proposition , int [] solution )
{
int nbBienPlaces = 0;
boolean trouve = true;
for (int i = 0; i < nbCellules; i++)
{
if (proposition [i] == solution [i])
{
nbBienPlaces++;
/*Si le pion dans la case i est le meme
dans le tableau solution et le tableau proposition
alors la valeur de nbBienplaces augmente de 1.
*/
}
else
{
trouve = false;
}
}
return nbBienPlaces;
} // fin de nombreDeBienPLaces
//===================================================================
public static int nombreDeMalPlaces(int [] proposition , int [] solution )
{
int nbMalPlaces =0;
int [] doubleSolution = new int[nbCellules];
int [] doubleProposition = new int[nbCellules];
boolean trouve;
// copie des tableaux
// Vous copierez le tableau SOLUTION dans DOUBLESOLUTION
// Vous copierez le tableau PROPOSITION dans DOUBLEPROPOSITION
for (int i = 0; i < nbCellules; i++)
{
doubleSolution[i] = solution[i];
doubleProposition[i] = proposition[i];
}
//marquage des bien placés.
//VOUS TRAVAILLEZ SEULEMENT AVEC LES TABLEAUX DOUBLE
// A CHAQUE FOIS QUE VOUS TROUVEZ UN BIEN PLACE, IL FAUT
// LE REMPLACER AVEC LA VALEUR -1 DANS DOUBLESOLUTION
// LE REMPLACER AVEC LA VALEUR -2 DANS DOUBLEPROPOSITION
for (int i = 0; i < nbCellules; i++)
{
if ( doubleProposition[i] == doubleSolution[i])
{
doubleSolution[i] = -1;
doubleProposition[i] = -2;
}
}
// RECHERCHE DES MAL PLACES
// ON PARCOURT LE TABLEAU DOUBLEPROPOSITION
for (int i = 0; i < nbCellules; i++)
{
trouve = false;
// recherche de la cellule de proposition dans Solution
// ON PARCOURT LE TABLEAU DOUBLESOLUTION
// SI ON TROUVE L'ELEMENT I DE DOUBLEPROPOSITION
// ON PLACE BOOLEAN A TRUE et on marque la SOLUTION avec -1
for (int j = 0; j < nbCellules; j++)
{
if (doubleProposition[j] == doubleSolution[i])
{
nbMalPlaces++;
doubleSolution[i] = -1;
trouve = true;
/*Si la valeur dans doublePorposition est la même que dans une
des case de solution, alors le nombre de pions trouvés mais
mal placé augmente de 1. On remplace ensuite dans doubleSoution le pion
trouvé par la valeur -1 qui ne peut pas être égale a une valeur de
doubleProposition, ainsi le pion ne sera pas compté plusieurs fois
ou une seule fois.
*/
}
j++;
// la valeur j augmente de 1 pour scanner la case suivante
}
}
return nbMalPlaces;
}// fin de nombreDeMalPLaces
//===================================================================
// affichage de la solution
public static void afficherSolution(boolean param, int[] combinaison)
{
for (int cellule = 0; cellule < nbCellules; cellule = cellule + 1)
dessin.tracerRectangleVide( 100 + cellule * tailleCercle, 0 + 13 * tailleCercle, tailleCercle, tailleCercle,"noir");
if (param==true)
{
afficherCombinaison(combinaison,100,13*tailleCercle);
}
} // fin de afficheSolution
//=================================================================
// ================== METHODES FOURNIES ===========================
//==================================================================
// tirage aléatoire d'un nombre entre MIN et MAX
private static int entierAleatoire(int min, int max){
return (int)(min+(max-min+1)*Math.random() ); }
//=====================================================================
// TRANSFORME L'ENTIER SAISI PAR L'UTILISATEUR en COMBINAISON
private static int[] transformationChaineenCombi(String s)
{ int[] combi = new int[nbCellules];
for (int i = 0;i<nbCellules; i++)
{
String sch =s.substring(i,i+1);
combi[i] = Integer.parseInt(sch);
}
return combi;
}
//=====================================================================
// affichage du plateau de jeu
public static void afficherPlateau()
{
for (int ligne =0; ligne <12; ligne = ligne +1)
for (int cellule = 0; cellule < nbCellules; cellule = cellule + 1)
dessin.tracerRectangleVide( 100 + cellule * tailleCercle, 0 + ligne * tailleCercle, tailleCercle, tailleCercle,"noir");
dessin.tracerPalette (10,tailleCercle, nbCouleurs, tailleCercle);
}
//===================================================================
public static void afficherResultat (int tent, int nbbpl, int nbmalpl )
{
int marge = tailleCercle /4;
int diam = tailleCercle/2;
for (int i=0; i< nbbpl ; i= i+1)
{
dessin.tracerOvalePlein(220 + i * (marge + diam) + marge,(tent-1) * tailleCercle + marge, diam, diam, "rouge");
dessin.tracerOvaleVide (220 + i * (marge + diam) + marge,(tent-1) * tailleCercle + marge, diam, diam, "noir");
}
for (int j = 0 ; j < nbmalpl; j=j+1)
{
dessin.tracerOvaleVide(220 +(j+nbbpl)*(marge+diam)+marge, (tent-1) * tailleCercle + marge, diam, diam, "noir");
}
} // fin de afficheResultat
//===================================================================
// procédure 5
public static void proc5()
{
}
} // fin de la classe
/*
* Atelier.java
*/
public class Atelier {
// définition des constantes
final static int nbCellules = 5;
final static int nbCouleurs =9;
final static int tailleCercle = 20;
private static Dessin dessin;
private static int[] solution;
public static void main(String[] args) {
Logo logo = new Logo("MasterMind... A vos cerveaux", 500, 360);
dessin = logo.dessin();
logo.afficher();
}
private static void ecrire(Object obj)
{
System.out.print(obj);
}
private static void aLaLigne()
{
System.out.println();
}
//===================================================================
// Procédure 1
// public static void proc1()
//{
// creerCombinaison();
// remplirCombinaison( );
// afficher ();
// }// fin de proc1()
//===================================================================
//Création de la combinaison
// public static void creerCombinaison()
// {
// int[] solution;
// solution = new int [nbCellules];
// }
//=====================================================================
public static void afficher (int[]combi)
{
;
for (int i=0; i< nbCellules; i=i+1)
{
ecrire(combi [i]);
}
} // fin de affiche
//===================================================================
// affichage d'une combinaison
public static void afficherCombinaison(int[]combi, int x, int y)
{
for (int i=0; i< nbCellules; i=i+1)
{
dessin.tracerOvalePlein( x+20*i, y+1, tailleCercle - 2, tailleCercle -2, combi[i] );
dessin.tracerOvaleVide ( x+20*i, y+1, tailleCercle - 2, tailleCercle -2, "noir");
//pour chaque valeur du tableau i on dessinera un cercle, les cercles se situeront les uns a la suite des autres.
}
} // fin de afficheCombinaison
//===================================================================
// affichage d'un cercle
public static void afficherCercle()
{
int x =50; int y = 100;
dessin.tracerOvalePlein( x+20, y+1, tailleCercle - 2, tailleCercle -2, 5 );
dessin.tracerOvaleVide ( x+20, y+1, tailleCercle - 2, tailleCercle -2, "noir");
} // fin de afficheCercle
//===================================================================
// remplissage d'une combinaison
public static int[] remplirCombinaison( )
{
int[] T;
T = new int [nbCellules];
for (int i=0; i< nbCellules; i=i+1)
{
T [i] = entierAleatoire(1,9) ;
//rempli chaque case par une valeur aléatoire allant de 1 à 9.
}
return T;
} // fin de remplirCombinaison
//===================================================================
// Procédure 2
public static void proc2()
{
int x = 100;
int y = 0;
afficherPlateau();
int[] combi1 = remplirCombinaison();
int[] combi2 = remplirCombinaison();
int[] combi3 = remplirCombinaison();
afficher(combi1);afficher(combi2);afficher(combi3);
afficherCombinaison(combi1,x,y);afficherCombinaison(combi2,x,y+tailleCercle);afficherCombinaison(combi3,x,y+2*tailleCercle);
} // fin de proc2()
//===================================================================
// Procédure 3
public static void proc3()
{ int x = 100; int y =0;
int valeur =0;
int [] proposition;
int nbPropositions = 0;
int nbTentativesMax = 12;
while (nbPropositions<=nbTentativesMax)
{
valeur=Dialogue.lireEntier("entrez votre combinaison"+valeur);
if ((valeur < 11111)&&(valeur>99999))
{
Dialogue.message("Erreur...Le nombre de couleurs est incorrect");
// on vérifie que la valeur entrée est au format de celle que l'on demande
}
else
{
String s = String.valueOf(valeur);
proposition = transformationChaineenCombi(s);
afficherPlateau();
afficher(proposition);
afficherCombinaison(proposition,x,y);
nbPropositions = nbPropositions + 1;
y = y+tailleCercle;
}
}
} // fin de proc3()
//===================================================================
// Procédure 4 - mise en place des comparaisons et affichage des résultats
public static void proc4()
{
boolean param= false;
int x = 100; int y = 0;int[] proposition;
// création de la combinaison à rechercher
int[]solution;
// création de la solution aléatoire
solution = remplirCombinaison();
afficher(solution);
// affichage TEXTUEL de la solution
// initialisation du jeu
afficherPlateau();
// affichage du plateau du jeu
afficherSolution( param, solution);
int nbPropositions =0;
int nbBienPlaces =0;
int nbMalPlaces =0;
int valeur=0;
while ( (nbPropositions<12) && (param == false) )
{
valeur = Dialogue.lireEntier("entrez votre combinaison"+valeur);
// si vous n'avez pas joué 12 tentatives, le jeu continue
if ((valeur < 11111)&&(valeur>99999))
{
Dialogue.message("Erreur...Le nombre de couleurs est incorrect");
// verification de la valeur entrée
}
else
{
String s = String.valueOf(valeur);
proposition = transformationChaineenCombi(s);
//transforme la valeur entrée en tableau
afficherPlateau();
afficher(proposition);
afficherCombinaison(proposition,x,y);
//affiche le plateau, la proposition
y = y+tailleCercle;
param = ( nombreDeBienPlaces(proposition,solution) == 5 );
/*Si le nombre de pions bien placés est égal à 5
alors le parametre devient vrai,
on fait appel à ce parametre plus tard pour
terminer la boucle (et ainsi le jeu).
*/
int nbmalpl = nombreDeMalPlaces(proposition,solution);
int nbbpl = nombreDeBienPlaces(proposition,solution);
/*On fait appel aux methodes nombreDeBienPlaces et nombreDeMalPlaces
pour affecter des valeurs à nbbpl et nbmalpl, car on peut faire appel à ces valeurs
dans la methode suivante mais on ne peut pas faire appel à la methode elle même
*/
afficherResultat (nbPropositions, nbbpl, nbmalpl );
//affiche des pions rouge et blancs pour chaque pions bien ou mal placés
nbPropositions = nbPropositions + 1;
//on augmente de 1 la valeur de nbPropositions pour continuer la boucle
}
}
if ( param == true )
{
Dialogue.message("Bravo vous avez gagné !!");
/*si la parametre est vraie (lorsque le nombre de pion biens placés vaut 5
alors ce message s'affiche et la boucle ne se relancera pas :
le jeu s'arrete
*/
}
else
Dialogue.message("Bravo vous ètes un paté !! ");
/* au bout des 12 tentatives si l'evenement "vous avez gagné"
n'est pas appelé alors ce message s'affiche
pour vous indiquer votre defaite face à l'ordinateur !
*/
// affichage de la solution avec son bandeau
param= true ;
afficherSolution (param,solution );
/* Si la boucle n'a pas fait apparaitre la solution,
il faut bien que celle-ci soit devoilé au joueur
on applique au boolean "param" la valeur true d'office afin que
la solution s'affiche,et la valeur true ne sera appliquer qu'en fin
de proc4().
*/
} // fin de proc4()
//===================================================================
public static int nombreDeBienPlaces ( int [] proposition , int [] solution )
{
int nbBienPlaces = 0;
boolean trouve = true;
for (int i = 0; i < nbCellules; i++)
{
if (proposition [i] == solution [i])
{
nbBienPlaces++;
/*Si le pion dans la case i est le meme
dans le tableau solution et le tableau proposition
alors la valeur de nbBienplaces augmente de 1.
*/
}
else
{
trouve = false;
}
}
return nbBienPlaces;
} // fin de nombreDeBienPLaces
//===================================================================
public static int nombreDeMalPlaces(int [] proposition , int [] solution )
{
int nbMalPlaces =0;
int [] doubleSolution = new int[nbCellules];
int [] doubleProposition = new int[nbCellules];
boolean trouve;
// copie des tableaux
// Vous copierez le tableau SOLUTION dans DOUBLESOLUTION
// Vous copierez le tableau PROPOSITION dans DOUBLEPROPOSITION
for (int i = 0; i < nbCellules; i++)
{
doubleSolution[i] = solution[i];
doubleProposition[i] = proposition[i];
}
//marquage des bien placés.
//VOUS TRAVAILLEZ SEULEMENT AVEC LES TABLEAUX DOUBLE
// A CHAQUE FOIS QUE VOUS TROUVEZ UN BIEN PLACE, IL FAUT
// LE REMPLACER AVEC LA VALEUR -1 DANS DOUBLESOLUTION
// LE REMPLACER AVEC LA VALEUR -2 DANS DOUBLEPROPOSITION
for (int i = 0; i < nbCellules; i++)
{
if ( doubleProposition[i] == doubleSolution[i])
{
doubleSolution[i] = -1;
doubleProposition[i] = -2;
}
}
// RECHERCHE DES MAL PLACES
// ON PARCOURT LE TABLEAU DOUBLEPROPOSITION
for (int i = 0; i < nbCellules; i++)
{
trouve = false;
// recherche de la cellule de proposition dans Solution
// ON PARCOURT LE TABLEAU DOUBLESOLUTION
// SI ON TROUVE L'ELEMENT I DE DOUBLEPROPOSITION
// ON PLACE BOOLEAN A TRUE et on marque la SOLUTION avec -1
for (int j = 0; j < nbCellules; j++)
{
if (doubleProposition[j] == doubleSolution[i])
{
nbMalPlaces++;
doubleSolution[i] = -1;
trouve = true;
/*Si la valeur dans doublePorposition est la même que dans une
des case de solution, alors le nombre de pions trouvés mais
mal placé augmente de 1. On remplace ensuite dans doubleSoution le pion
trouvé par la valeur -1 qui ne peut pas être égale a une valeur de
doubleProposition, ainsi le pion ne sera pas compté plusieurs fois
ou une seule fois.
*/
}
j++;
// la valeur j augmente de 1 pour scanner la case suivante
}
}
return nbMalPlaces;
}// fin de nombreDeMalPLaces
//===================================================================
// affichage de la solution
public static void afficherSolution(boolean param, int[] combinaison)
{
for (int cellule = 0; cellule < nbCellules; cellule = cellule + 1)
dessin.tracerRectangleVide( 100 + cellule * tailleCercle, 0 + 13 * tailleCercle, tailleCercle, tailleCercle,"noir");
if (param==true)
{
afficherCombinaison(combinaison,100,13*tailleCercle);
}
} // fin de afficheSolution
//=================================================================
// ================== METHODES FOURNIES ===========================
//==================================================================
// tirage aléatoire d'un nombre entre MIN et MAX
private static int entierAleatoire(int min, int max){
return (int)(min+(max-min+1)*Math.random() ); }
//=====================================================================
// TRANSFORME L'ENTIER SAISI PAR L'UTILISATEUR en COMBINAISON
private static int[] transformationChaineenCombi(String s)
{ int[] combi = new int[nbCellules];
for (int i = 0;i<nbCellules; i++)
{
String sch =s.substring(i,i+1);
combi[i] = Integer.parseInt(sch);
}
return combi;
}
//=====================================================================
// affichage du plateau de jeu
public static void afficherPlateau()
{
for (int ligne =0; ligne <12; ligne = ligne +1)
for (int cellule = 0; cellule < nbCellules; cellule = cellule + 1)
dessin.tracerRectangleVide( 100 + cellule * tailleCercle, 0 + ligne * tailleCercle, tailleCercle, tailleCercle,"noir");
dessin.tracerPalette (10,tailleCercle, nbCouleurs, tailleCercle);
}
//===================================================================
public static void afficherResultat (int tent, int nbbpl, int nbmalpl )
{
int marge = tailleCercle /4;
int diam = tailleCercle/2;
for (int i=0; i< nbbpl ; i= i+1)
{
dessin.tracerOvalePlein(220 + i * (marge + diam) + marge,(tent-1) * tailleCercle + marge, diam, diam, "rouge");
dessin.tracerOvaleVide (220 + i * (marge + diam) + marge,(tent-1) * tailleCercle + marge, diam, diam, "noir");
}
for (int j = 0 ; j < nbmalpl; j=j+1)
{
dessin.tracerOvaleVide(220 +(j+nbbpl)*(marge+diam)+marge, (tent-1) * tailleCercle + marge, diam, diam, "noir");
}
} // fin de afficheResultat
//===================================================================
// procédure 5
public static void proc5()
{
}
} // fin de la classe
http://www.javafr.com/codes/JEU-MASTERMIND-AMELIORE_23901.aspx
Je ne crois pas qu'il y aie d'explications, mais si tu n'as pas trop sèché le cours de java ca devrait aller.
Je ne crois pas qu'il y aie d'explications, mais si tu n'as pas trop sèché le cours de java ca devrait aller.
import java.util.Random;
public class MasterMindJeu
{
public static String genererSequence(int taille)
{
String boules="NBRVbJ";
char[] tmp=boules.toCharArray();
String Resultat="";
int k=0,l=0;
Random alea=new Random();
char sauv='\0';
for(int i=1;i<=taille;i++)
{
for(int j=0;j<50;j++);
{k=alea.nextInt(60)/10;
l=alea.nextInt(60)/10;
sauv=tmp[k];
tmp[k]=tmp[l];
tmp[l]=sauv;}
Resultat+= String.valueOf(tmp[k]);
}
return Resultat;}
public static int nb_place_exactes(String Solution,String proposition)
{
int Resultat=0;
for(int i=0;i<proposition.length();i++)
if(proposition.charAt(i)==Solution.charAt(i)) Resultat++;
return Resultat;
}
public static int nb_place_fausses(String Solution,String proposition)
{
String tmp_prop=proposition;
String tmp_sol=Solution;
int Resultat=0;
for(int i=0;i<tmp_sol.length();i++)
{
if( tmp_sol.charAt(i) == tmp_prop.charAt(i) )
{ tmp_prop = remplacerChar(tmp_prop,i);
tmp_sol = remplacerChar(tmp_sol,i); }
}
tmp_prop = supprimerEspaces(tmp_prop);
tmp_sol = supprimerEspaces(tmp_sol);
int index=0;
for(int i=0;i<tmp_prop.length();i++)
{
index=tmp_sol.indexOf(String.valueOf(tmp_prop.charAt(i)) );
if(index!=-1)
{Resultat++;
tmp_sol = supprimerChar(tmp_sol,index);
}
}
return Resultat;
}
public static String supprimerEspaces(String ch)
{String res="";
for(int i=0;i<ch.length();i++)
if(ch.charAt(i) != ' ') res+=ch.charAt(i);
return res;
}
public static String supprimerChar(String ch,int index)
{String res="";
for(int i=0;i<ch.length();i++)
if(i != index) res+=ch.charAt(i);
return res;
}
public static String remplacerChar(String ch,int index)
{String res="";
for(int i=0;i<ch.length();i++)
if(i != index) res+=ch.charAt(i);
else res+=' ';
return res;
}
}
j'ai trouver sa c'est bon pour l'examen a l'écrit
public class MasterMindJeu
{
public static String genererSequence(int taille)
{
String boules="NBRVbJ";
char[] tmp=boules.toCharArray();
String Resultat="";
int k=0,l=0;
Random alea=new Random();
char sauv='\0';
for(int i=1;i<=taille;i++)
{
for(int j=0;j<50;j++);
{k=alea.nextInt(60)/10;
l=alea.nextInt(60)/10;
sauv=tmp[k];
tmp[k]=tmp[l];
tmp[l]=sauv;}
Resultat+= String.valueOf(tmp[k]);
}
return Resultat;}
public static int nb_place_exactes(String Solution,String proposition)
{
int Resultat=0;
for(int i=0;i<proposition.length();i++)
if(proposition.charAt(i)==Solution.charAt(i)) Resultat++;
return Resultat;
}
public static int nb_place_fausses(String Solution,String proposition)
{
String tmp_prop=proposition;
String tmp_sol=Solution;
int Resultat=0;
for(int i=0;i<tmp_sol.length();i++)
{
if( tmp_sol.charAt(i) == tmp_prop.charAt(i) )
{ tmp_prop = remplacerChar(tmp_prop,i);
tmp_sol = remplacerChar(tmp_sol,i); }
}
tmp_prop = supprimerEspaces(tmp_prop);
tmp_sol = supprimerEspaces(tmp_sol);
int index=0;
for(int i=0;i<tmp_prop.length();i++)
{
index=tmp_sol.indexOf(String.valueOf(tmp_prop.charAt(i)) );
if(index!=-1)
{Resultat++;
tmp_sol = supprimerChar(tmp_sol,index);
}
}
return Resultat;
}
public static String supprimerEspaces(String ch)
{String res="";
for(int i=0;i<ch.length();i++)
if(ch.charAt(i) != ' ') res+=ch.charAt(i);
return res;
}
public static String supprimerChar(String ch,int index)
{String res="";
for(int i=0;i<ch.length();i++)
if(i != index) res+=ch.charAt(i);
return res;
}
public static String remplacerChar(String ch,int index)
{String res="";
for(int i=0;i<ch.length();i++)
if(i != index) res+=ch.charAt(i);
else res+=' ';
return res;
}
}
j'ai trouver sa c'est bon pour l'examen a l'écrit
ll0ll
Messages postés
2577
Date d'inscription
mardi 1 mai 2007
Statut
Contributeur
Dernière intervention
13 avril 2010
511
16 mai 2007 à 00:47
16 mai 2007 à 00:47
Ce message a sa place dans Developpement plutot qu'ici.
J'ajouterai : l'espoir fait vivre.
J'ajouterai : l'espoir fait vivre.
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
