1
2
3
4
5
6
7
8
enum Couleur {coeur,carreau,trefle,pique} ;
enum Rang {deux,trois, quatre, cinq, six, sept, huit, neuf, dix, valet, dame, roi, as} ;
 
// struct car assemblage de données publiques sans méthodes
struct Carte { 
	Couleur couleur ;
	Rang rang ; 
}

1
2
3
4
5
6
enum QuiGagne {moi, personne, lui} ;
 
class Jeu {
	Carte cartes[5]; // ou un vector si vous voulez…
	QuiGagne Compare(const Jeu &j) const;
}

1
2
3
Jeu j1,j2 ;
// chargement des données à comparer
return j1.Compare(j2) ;

1
2
3
bool EstQuinteFlush() ;
bool EstCarre() ;
bool EstFlush() ;

1
2
QuiGagne CompareQuintesFlush(Jeu&j) ; 
QuiGagne CompareCarres(Jeu &j) ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
QuiGagne Compare(Jeu &j) {
	// quintes flush
	bool qf1=EstQuinteFlush() ;
	bool qf2=j.EstQuinteFlush() ;
	if(qf1 && !qf2) return moi ;
	if(!qf1 && qf2) return lui ;
	if(qf1 && qf2) return CompareQuintesFlush(j)
	// carres
	bool c1=EstCarre();
	bool c2=j.EstCarrre();
	if(c1 && !c2) return moi ;
	if(!c1 && c2) return lui ;
	if(c1 && c2) return CompareCarres(j)
// et ainsi de suite en descendant
}

1
2
3
4
5
6
7
8
9
10
11
12
class figure {
	bool EstUn(Jeu &j) ;  
	int ExAequo(Jeu &j1Jeu &j2) ;
        int Compare(Jeu &j1,Jeu &j2)  {
		bool b1=EstUn(j1) ;
		bool b2=EstUn(j2) ;
		if(b1 && !b2) return 1;
		if(b2 && !b1) return 2
		if(b1 && b2) return ExAequo(j1,j2) ;
		return -1;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
typedef Jeu  vector<pair<int,int> > ;
 
int Compare(Jeu &j1,Jeu &j2) 
{
int sz1=j1.size() ;
int sz2=j2.cartes.size() ;
int sz=min(sz1,sz2) ;
for(int i=0 ;i<sz ;i++) {
    if(j1[i].first>j2[i].first) return 1;
    if(j1[i].first<j2[i].first) return 2;
}
for(int i=0 ;i<sz ;i++) {
    if(j1[i].second>j2[i].second) return 1;
    if(j1[i].second<j2[i].second) return 2;
}
return 0;
}

1
2
3
4
5
6
7
class Jeu {
private :
	vector<pair<int,int> > _cartes ;
public :
	Trie() ;
	Compare(Jeu &j) ;
}