Discussion :

[new_wave]

Bonjour,

La situation est la suivante
Dans un tableau tabJoueur, il y a des éléments de type joueur.
Un joueur est caractérisé par sa variable « nom » et sa variable « totalPoints ».
Il existe donc une classe joueur qui contient ces deux variables.
Un croupier est un joueur qui ne fait pas partie du tableau tabJoueur .

Il faut pouvoir dire quel est le joueur qui a obtenu le maximum de points.
La démarche est la suivante :
-on détermine d’abord le nombre de points maximum dans le tableau tabJoueur( quelle est la valeur de totalpoints la plus importante) , puis on le compare à la variable totalPoints du croupier.
La règle suivante est établie :

-si après avoir parcouru tout le tableau tabJoueur, il s’avère

A-qu’il existe des execaux(2 ou plus) dans le tableau mais il existe un élément dans le tableau qui possède un nombre de points supérieur à celui de ces joueurs execaux.
-le nombre de joueurs execaux nous importe donc peu et on le reinitalise à 1, qui est sa valeur première
-on retient l’index de l’élement( joueur) qui possède le nombre maximal de points dans le tableau(instruction if(this.tabJoueur[i].totalPoint> max_tabJoueur_points_obtenus){
index_maximum_total_points_1=i; }
et on compare son nombre de points à celui du croupier

-si c’est le croupier qui possède un nombre plus important de points, il est le gagnant.
-si le joueur du tableau tabJoueur qui possède le nombre maximal de points ,a un nombre de points > totalPoints du croupier, c’est lui qui est gagnant.
-si les deux joueurs sont à égalité ils sont tous les 2 gagnants.


B-qu’il existe +2 execaux dans le tableau qui ont obtenu le nombre maximal de points,
on compare le nombre de points maximum obtenus par ces joueurs execaux avec celui du croupier
-si c’est le croupier qui a obtenu un nombre +important de points, il est le gagnant
-sinon, si ce sont les execaux qui ont obtenu un nombre de points +important , du fait qu’il y a + de deux execaux, on considère qu’il n’y a pas de gagnant de la partie
-si les execuaux dans le tableau qui ont obtenu le nombre maximal de points et le croupier sont à égalité, on estime qu’il n’y a pas de gagnant.

B-il existe deux execaux dans le tableau qui ont obtenu le nombre maximal de points
A chaque passage dans la boucle for, la variable nombre_joueurs_execaux est incrémentée au niveau de cette condition :
If (this.tabJoueur[i].totalPoint== max_tabJoueur_points_obtenus)
{ nbre_joueurs_execaux++;et l’index de l’élément du tableau qui a obtenu un nombre de points équivalent à celui du maximum est retenu grâce à cette instruction
if (nbre_joueurs_execaux==2)
index_maximum_total_points_2=i;


-1er cas :le nombre de points maximum est celui du premier élement du tableau, donc de celui d’index 0.
On a recupéré l’index du deuxième élément qui possède le même nombre de points maximum grâce à la variable index_maximum_total_points_2=i;

on compare alors la valeur de max_tabJoueur_points_obtenus avec celle de la variable totalPoint du croupier

· si (max_tabJoueur_points_obtenus > this.croupier.totalPoint) alors les deux ganants sont les deux execaux du tableau tabJoueur
· si (max_tabJoueur_points_obtenus < this.croupier.totalPoint) alors c’est le croupeir qui est gagnant
· max_tabJoueur_points_obtenus == this.croupier.totalPoint, les trois joeurs sont à égalité et on récupère leur nom par l’instruction

System.out.println("les trois joueurs"+ this.tabJoueur[0].nom +" "+this.tabJoueur[index_maximum_total_points_2].nom+" "+this.croupier.nom+ "sont à égalité");

-2ème cas :le nombre de points maximum n’est pas celui du premier élement du tableau,
on récupère donc les index des deux éléments execaux dans le tableau grâce aux variables
index_maximum_total_points_1 et index_maximum_total_points_2.

on compare alors la valeur de max_tabJoueur_points_obtenus avec celle de la variable totalPoint du croupier

· si (max_tabJoueur_points_obtenus > this.croupier.totalPoint) alors les deux ganants sont les deux execaux du tableau tabJoueur
· si (max_tabJoueur_points_obtenus < this.croupier.totalPoint) alors c’est le croupeir qui est gagnant
· max_tabJoueur_points_obtenus == this.croupier.totalPoint, les trois joueurs sont à égalité et on récupère leur nom par l’instruction

System.out.println("les trois joueurs"+ this.tabJoueur[index_maximum_total_points_1].nom +" "+this.tabJoueur[index_maximum_total_points_2].nom+" "+this.croupier.nom+ "sont à égalité");


pouvez vous me dire si le code de la procedure afficher gagnant vous semble corect ou incomplet etégalement s'il est possible de faire plus court par exemple en remplaçant certaines instructions if imbriquées.

Merci vraiement beaucoup de votre aide.

Cordialement.

Natahlie

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

public void affichergagnant(){
	
	int i ; 
	int max_tabJoueur_points_obtenus= this.tabJoueur[0].totalPoint;
	int index_maximum_total_points_1=0;
	int index_maximum_total_points_2=0;
	int index_maximum_total_points_3=0;
	

	

		

			

			
				]on est obligé d'initialiser à 1 la valeur de cetre variable pour qu'elle puisse passer à 2 dès qu'il y aura deux joueurs qui obtiendront le même nombre de points
			
		
	
	int nbre_joueurs_execaux=1;
	
	boucle for qui parcourt le tableau tabJoueur de la partie en cours pour déterminer le joueur qui a obtenu le plus de points	

for(i=1;i<this.tabJoueur.length;i++ ){
		
	if(this.tabJoueur[i].totalPoint> max_tabJoueur_points_obtenus)
{
	max_tabJoueur_points_obtenus=this.tabJoueur[i].totalPoint;
on retient l'index de l'élément pour lequel on a obtenu le nombre maximum de points
	index_maximum_total_points_1=i;
Si, auparavant il y eu des execaux , le fait qu'il existe un nombre de points supérieur à celui des joueurs execaux annule le fait qu'il y ait des execaux et la variable nbre_joueurs_execaux est réinitialisée à sa valeur première

nbre_joueurs_execaux=1;
			
		
}// fin de if this.tabJoueur[i].totalPoint> max_tabJoueur_points_obtenus
	
 si on est dans le cas où le joueur courant a un  nombre de points==max_tabJoueur_points_obtenus 
	
	else if (this.tabJoueur[i].totalPoint> max_tabJoueur_points_obtenus)
	{
		nbre_joueurs_execaux++;
on ne veut pas retenir les données de plus de deux joueurs execaux

Dès que  le nombre de joueurs execaux est =2  on retient l'index de l'element du tableau pour lequel le nombre de points est == max_tabJoueur_points_obtenus.
Si,  arrivés à la fin du tableau il s'avère qu'il y a en tout et pour tout 
2 execaux, on pourra alors retrouver l'élément du tableau pour lequel
 cette égalité est vérifiée
		
	if (nbre_joueurs_execaux==2)
			index_maximum_total_points_2=i;
					
	}// fin de else if (this.tabJoueur[i].totalPoint> max_tabJoueur_points_obtenus)
 
			
		
	}//fin de boucle for	
	
si le nombre de joueurs execaux est > 2( nbre_joueurs_execaux>2)et max_tabJoueur_points_obtenus est > au nombre total de points du croupier(this.croupier.totalPoint), alors la partie n'a pas de gagnant 

if (nbre_joueurs_execaux>2 && max_tabJoueur_points_obtenus>this.croupier.totalPoint)
 
		{
			System.out.println("il ya trop de joueurs execaux, cette partie n' a pas de gagnant");
		}// fin de if (nbre_joueurs_execaux>2  && max_tabJoueur_points_obtenus>this.croupier.totalPoint)	
	
 si le nombre d'execaux est > 2 et que le contenu de la variable max_tabJoueur_points_obtenus est < nombre total de points du croupier	

if (nbre_joueurs_execaux>2 && max_tabJoueur_points_obtenus<this.croupier.totalPoint)
		{
			System.out.println("le gagnant est le croupier");
		}
		if (nbre_joueurs_execaux==2 )
S'il y a deux execaux,  il y a deux cas possibles 
	         			

{// debut des instructions liées au if  (nbre_joueurs_execaux==2 )
	
			
			
premier cas :  il s'agit du premier joueur du tableau et d'un autre joueur du tableau qui possède le même nombre de points 			
	if  (max_tabJoueur_points_obtenus== this.tabJoueur[0].totalPoint)
		{// début du code pour la condition  if  
(max_tabJoueur_points_obtenus== this.tabJoueur[0].totalPoint)
				
	// on écrit les index des deux éléments execaux
System.out.println( "l' index du premier execaux est 0  et l'index du deuxième execaux est "+ index_maximum_total_points_2);
//on compare alors la valeur de max_tabJoueur_points_obtenus avec celle de la variable totalPoint du croupier
	if (max_tabJoueur_points_obtenus > this.croupier.totalPoint)
					
	{System.out.println("les deux gagnants sont "  +this.tabJoueur[0].nom +"   " + this.tabJoueur[index_maximum_total_points_2].nom);
				}//fin de if (max_tabJoueur_points_obtenus > this.croupier.totalPoint)				
else if (max_tabJoueur_points_obtenus < this.croupier.totalPoint)
{System.out.println (" le gagnant est le croupier");
			    }//fin de if max_tabJoueur_points_obtenus < this.croupier.totalPoint)				
else 
{System.out.println("les trois joueurs"+ this.tabJoueur[0].nom +"  "+
this.tabJoueur[index_maximum_total_points_2].nom+"  "+this.croupier.nom+
 "sont à égalité");
				}// fin de else
				
	}// fin de if  (max_tabJoueur_points_obtenus== this.tabJoueur[0].totalPoint)
			
			
			// deuxième cas: le nombre maximal de points n'est pas celui du premier joueur du tableau tabJoueur
					
if (max_tabJoueur_points_obtenus!= this.tabJoueur[0].totalPoint)
				
			{//	 on écrit les index des deux éléments execaux

System.out.println( "l' index du premier execaux est "+this.tabJoueur[index_maximum_total_points_1].nom +" et l'index du deuxième execaux est "+ index_maximum_total_points_2);
							
			
//on compare alors la valeur de max_tabJoueur_points_obtenus avec celle de la variable totalPoint du croupier
			if (max_tabJoueur_points_obtenus > this.croupier.totalPoint)
			{
				System.out.println("les deux gagnants sont "  +this.tabJoueur[index_maximum_total_points_1].nom +"   " + this.tabJoueur[index_maximum_total_points_2].nom);
			}//fin de if (max_tabJoueur_points_obtenus > this.croupier.totalPoint)
			
			else if (max_tabJoueur_points_obtenus < this.croupier.totalPoint)
			{System.out.println (" le gagnant est le croupier");
			}//fin de if max_tabJoueur_points_obtenus < this.croupier.totalPoint)

			
			else 
			{System.out.println("les trois joueurs"+ this.tabJoueur[index_maximum_total_points_1].nom +"  "+this.tabJoueur[index_maximum_total_points_2].nom+"  "+this.croupier.nom+ "sont à égalité");
			}
		}// fin de if (max_tabJoueur_points_obtenus!= this.tabJoueur[0].totalPoint)
	}// fin de if (nbre_joueurs_execaux==2 )
			
}// fin de afficher gagnant

[BsT]

Ton code me parait bien compliqué...

Pour simplifier il faut que tu te poses les questions suivantes :
Quand est ce que le croupier gagne ?
Quand est ce que 2 joueurs gagnent ? etc...
Quand est ce qu'il n'y pas de gagnant.

L'algo que tu dois obtenir devrait, au final, ne pas contenir de doublon dans le System.out.println (ex : une seule fois le message "Le croupier à gagner")

Quelques remarques :
* Mettre la déclaration du int i dans le for.
* Les conditions du bloc if - elseif dans le for sont les mêmes.
* Il te manque un cas de test : nbre_joueurs_execaux>2 && max_tabJoueur_points_obtenus == this.croupier.totalPoint
* Je pense que tu peux te passer de tout ce qui concernent le Joueur 0 dans ton algo de découverte du gagnant (pas dans la partie initialisation des variables int max_scores = this.tabJoueur[0].totalPoints c'est très bien)
* Tu ne traite pas le cas ou il n'y pas d'ex-aequo