Discussion :

[Disixlis]

Bonjour tout le monde, j'ai développé un Mastermind et j'ai voulu le rendre le plus complet que possible.

[Fonctionnement de base]

Au départ l'ordinateur sélectionne 4 couleurs (sur 8) dans un ordre précis ET toute différente.
Le joueur lui aussi, sélectionne 4 couleurs (sur 8) dans un ordre précis ET toute différente.

[boucle : tant que le joueurs n'as pas toute les couleurs juste et au bonne endroit]
Si le joueurs a sélectionné nb couleur qui sont au bonne endroit et de la bonne couleur alors on affiche par exemple : 2 couleur juste
Si le joueurs a sélectionné nb couleur qui sont de la bonne couleur mais pas au bonne endroit alors on affiche par exemple : 1 couleur au mauvaise en droit
[boucle]

Exemple :
L'ordinateur sélectionne : vert rouge jaune bleu
Le joueur sélectionne : vert jaune blanc jaune

sortie -> 1 couleur juste | 1 couleur au mauvaise en droit


Donc dans cette exemple les test sont simple à faire mais je souhaite que l'ordinateur (et donc le joueur aussi) puisse utilisé plusieurs fois la même couleur et c'est là que cela pose problème.

Admettons cette exemple :
L'ordinateur sélectionne : rouge jaune jaune jaune
Le joueur sélectionne : jaune jaune blanc blanc

sortie -> 1 couleur juste | 1 couleur au mauvaise en droit


Dans cette exemple on doit vérifier les doublons des couleurs au mauvais endroit du joueur mais aussi celle de l'ordinateur pour définir combien de couleur sont au mauvaise endroit... La phrase est compliqué donc la conception est ambigüe de mon côté :/

Voici la méthode pour compter les couleur juste et au bonne endroit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
public static int rightPin( Vector<Entitie> pins, ArrayList<Integer> pinToCheck, Vector<PinColor> cwp )
{
     int rp = 0;
     for( int i = 0; i < cwp.size(); i++ )
     {
          if( ((Pin)pins.elementAt(Tools.getIndex(pins, pinToCheck.get(i)))).pinColor().equals(cwp.elementAt(i)) )
               rp++;
     }
     return rp;
}

J'utilise le principe ECS
- pin est une classe qui contient la couleur du joueur et qui hérite d'Entitie
- pins est mon component
- pinToCheck les id des pin du joueur à comparé
- cwp les couleurs juste

Pour ce qui en est de ce code, pas de problèmes il fonctionne étant donné qu'on test la position et la couleur d'un pin en même temps pour compter le nombre de pin juste
Mais pour compter le nombre de couleur juste sachant qu'il ne faut pas compté les pin à la bonne position et la bonne couleur mais seulement compté le nombre de couleurs justes au mauvais endroit, je sèche (depuis 2h).

Je me retrouve avec une fonction que je ne sais pas "remplir"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
public static int rightPinColor( Vector<Entitie> pins, ArrayList<Integer> pinToCheck, Vector<PinColor> cwp )
{
     int rpc = 0;
     Vector<PinColor> pc = extract(pinsById(pins, pinToCheck));
 
		//pc  : couleurs du joueur (4)
		//cwp : couleurs de l'ordi (4)
		//rpc : le nombre de couleurs du joueurs qui sont seulement mal placé
 
     return rpc;
}

Si quelqu'un peux m'expliquer ( pas forcément en java étant donné que je n'est pas décrite mes classes ) comment faire je lui serais très reconnaissant !

Un screenshot du jeu :

[joel.drigo]

Salut,

Tu as fait en fait ce qui est le plus complexe, le plus simple étant de trouver le nombre de couleurs sans tenir compte du fait qu'elle soit ou non bien placée (un simple comptage).
Pour connaitre le nombre de couleurs mal placées, je procéderais simplement par différence. Le nombre de pièces d'une couleur mal placées est le nombre total de pièces de cette couleur, maximisé par le nombre de pièces de cette couleur dans la combinaison à trouver (il ne peut y avoir plus de pièces mal ou bien placées que de pièce placée), moins le nombre de pièces bien placées de cette couleur.

Code pseudocode :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
pour toutes les pièces de la combinaison proposée
   si sa couleur est dans la combinaison à trouver et que le compte de cette couleur est inférieur ou égal au nombre de cette couleur dans la combinaison à trouver
      incrémenter le compte de cette couleur
   fin si
fin pour

On obtient donc pour les couleurs présentes dans les deux combinaisons, le nombre en commun ( si joué R R V J et à trouver, R R R R, on obtient 2).
Il suffit de soustraire pour chaque couleur le nombre de pièce bien placé de cette couleur et on obtient le nombre de pièce de chaque couleur mal placé.

[Disixlis]

Un grand merci pour ta réponse ! Je vais procédé comme suit et je reviendrai pour dire si j'ai réussis (ou non x) ) à les testés correctement

Edit : J'ai donc essayé d'écrire le code à partir de ce que tu m'as écrit mais ça n'as pas fonctionné :/ j'ai essayé plusieurs méthodes mais je n'en n'est conclu à aucun résultat.

Voici le code qui se rapproche le plus de ce que tu m'as dit ( enfin je crois ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
private static int contains(PinColor pc, Vector<PinColor> psc )
{
	int c = 0;
	for( int i = 0; i < psc.size(); i++ )
		if( pc.equals(psc.get(i)))
			c++;
	return c;
}
 
private static boolean isIn( PinColor pc, Vector<PinColor> psc )
{
	for( int i = 0; i < psc.size(); i++ )
		if( !pc.equals(psc.get(i)))
			return false;
	return true;
}
 
public static int rightPinColor(Vector<Entitie> pins, ArrayList<Integer> pinsToCheck, Vector<PinColor> cwp) 
{
	int rpc = 0;
	Vector<PinColor> pc = extract(pinsById(pins, pinsToCheck));
 
	for( int i = 0; i < pc.size(); i++ )
	{
		if( isIn(pc.get(i), cwp) && contains(pc.get(i), pc ) <= contains(pc.get(i), cwp) )
		{
			rpc++;
		}
	}
	return rpc;
}

Re-Edit :
J'ai finalement réussi !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
        public static int rightPinColor(Vector<Entitie> pins, ArrayList<Integer> pinsToCheck, Vector<PinColor> cwp) 
	{
		int rpc 					= 0;
		Vector<PinColor> pc 		= extract(pinsById(pins, pinsToCheck));
		Vector<Integer> cwp_match 	= new Vector<Integer>();
		Vector<Integer> pc_match 	= new Vector<Integer>();
 
		for( int i = 0; i < cwp.size(); i++ )
			cwp_match.add(contains(cwp.get(i), pc));
		for( int i = 0; i < pc.size(); i++ )
			pc_match.add(contains(pc.get(i), cwp));
 
		for( int i = 0; i < cwp_match.size(); i++ )
		{
			if( pc.get(i) != cwp.get(i) )
			{
				if( cwp_match.get(i) < pc_match.get(i) )
					rpc += cwp_match.get(i);
				else
					rpc += cwp_match.get(i) - pc_match.get(i);
			}
		}
 
		System.out.println("[RPC][COUNT] " + rpc);
		return rpc;
	}

Merci à toi

[Disixlis]

Edit : tromper de code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
        public static int rightPinColor(Vector<Entitie> pins, ArrayList<Integer> pinsToCheck, Vector<PinColor> cwp) 
	{
		int rpc 					= 0;
		Vector<PinColor> pc 		= extract(pinsById(pins, pinsToCheck));
		Vector<Integer> cwp_match 	= new Vector<Integer>();
 
		for( int i = 0; i < cwp.size(); i++ )
		{
			cwp_match.add(contains(cwp.get(i), pc, i));
		}
 
		for( int i = 0; i < cwp.size(); i++ )
		{
			int in = containss(cwp.get(i), cwp);
			if( in < cwp_match.elementAt(i) )
			{
				cwp_match.removeElementAt(i);
				cwp_match.add(i, in);
			}	
		}
 
		for( Integer i : cwp_match )
			rpc += i;
 
		System.out.println("[RPC][COUNT] " + rpc);
		return rpc;
	}

Le jeu :