/F(Jb
class Carte :
'''represente une carte a j ouer'''
def init (self, valeur, couleur):
" '(Carte,str,str)->None
initialise la valeur et la couleur de la ca rte'''
[Link]= valeur
[Link] l eur= couleur # pi que, coeu r, t refle ou carreau
def _repr_ (self):
'' '( Carte)->str
retourne une representation de l'objet de class Carte'"
return 'Carte(' +[Link]+ ', ' +[Link]+ ')'
def -~q_ (self, autre):
'' '( Carte,Carte)->bool ,,,
self== autre si la valeur et la couleur sont les memes
return [Link]== [Link] and [Link]== [Link]
def lt (self, autre):
77 •(Carte,Carte)->bool
self< autre si la valeur de sel f est i nferieure a la valeur de l'o bjet autre
Necessaire pour la fonction sort()
return [Link]< [Link]
class JeuDeCartes :
'' 'represente une jeu de 52 cartes' ' ' I
# valeurs et couleurs sont des variables de classe
valeurs= [ 2 1 1
,
1
3 1
,
1
4 1
,
1
5 1
1
1
6 1
, '7' , 8 , 19
1 1 1
, '1 0' , 'J' , 'Q' , K
1 1
,
1
A
1
]
couleurs = [ ' \u2660' , '\ u2661' , '\u2662' , '\u2663' l
# couleurs est un set de 4 symboles Unicode qui representent les 4 couleurs
# pique, coeur , trefle ou carreau
def _init_ (self):
'''
(JeudeCartes)->None
~~~structeur qui i nitialise le paquet de 52 cartes
[Link]= [] # paquet vide au debut
for couleur in [Link] rs:
for valeu r in [Link] rs: # variables de classe
if va l eur == 'J' and couleur == '\ u2663' : # pas le valet noir (le valet de trèfle)
pass
else :
# ajoute une Carte de valeur et couleur
[Link]( Carte (valeu r ,co ule ur ) )
det attend_le_joueur (self):
' ' ' (JeuDeCarte s)->None
le programme jusqu'au l'usager appui Enter
try :
input ("Appuyez Enter pour continuer. " )
except SyntaxError :
pass
def melange_paquet (s elf):
'' '(lP110pf;irtp~)->Nnn P
\ J~ UV'C \.O 1 1..t;;:.:, 1 - ..>- P~ Ullt:
~?~se l e programme jusqu'au l'usager appui Enter
try :
input ("Appuyez Enter pour continuer. ")
except SyntaxError :
pass
def melange_paquet (self):
' ' '(JeuDeCa rt es )->None
~~~ange la liste des chaines des caractères qui représente le paquet des cartes
[Link]([Link])
def _ repr_ (self):
'' '_(JeuDeCartes)->str
retourne une representation de l'objet JeuDeCartes ' ''
return 'Paquet( ' +str ([Link])+ ')'
def _ eq_ (self, autre):
(JeudeCartes , JeuDeCartes) - >bool
retourne True si les paquets ont les meme cartes
dans la meme ordre''' ·
ret urn [Link]== [Link]
def entrez_position_valid e (self, n):
(Je uDeCa rtes,int)->in t
Retourne un entier du clavier, de 1 à n (1 et n i nclus).
Co ntinue a demander si l'usager entre un entier qui n'est pas dans l'i nte rval [l,n]
Preco ndition: n>=l
print ("J'ai" , n, "cartes. Si 1 es t la pos ition de ma premiè re carte et" )
print (n, "est la position de ma dernière carte, laquelle de mes cartes vous voulez?" )
position =int (input ("SVP ent rer un entier de 1 à "+str (n )+": " ).strip(l l
wh i l e not (position>=l and position <=n i:
posit i on= int ( input ("Position i nvalide. SVP enter un entier de 1 à "+str (n)+": " ) .s t r i p( ) l
re t urn positio n
de f donne cartes (self):
'' '(JeuDeCartes) - > t uple of (list of Ca rte,list of Carte)
Retournes de ux listes qui re présentent les deux mains des cartes.
Le donneur don ne une carte à l'autre joueur, une à lui-même,
et ça contin ue j usqu'à la fin du paquet p.
1,'
donneur=[]
au t r e=[]
p = sel f. pa qu et
wh ile len (p) >l :
au [Link] pe nd( p. pop( ) )
donneur . appen d( [Link] p( ) )
aut r e . app e nd([Link]( ) ) # donn e l a dernie re ca rt e
re tu rn (donneur , au t re)
class Joueur (obiect ):
: lass Joueur (obj ect ):
'' 'represe nte une main des cartes a jouer'''
def _init_ (self, jo ueur):
'''(Joueur , str)-> None
constructeur qui initialise le nom du joueur avec la chaine des caracteres joueur
et la liste de cartes avec lis te vide'''
# A COMPLETER
se l f. nom= joueur
se lf . cardList=[l
def ajqute_carte (self, carte):
'''(Joueur, Carte) -> None
ajoute une carte a la liste main'''
# A COMPLETER
[Link] eList .append (ca rte )
def affiche_cartes (self ) :
(Joueur) - > Non e
Affiche le nom et les éléments de la main du joueur séparées par d'espaces
# A COMPLETER
I
print ( "le nom du joueur:" , sel f . nom )
print ("la main du joueur:" , end= "" )
for ca rte in se lf . ca rte Li s t :
pr i nt (carte , e nd=" " )
p ri nt ( "\n" )
def remov e carte ( sel f , car te ):
'''(Joueur , Carte) -> None
elimine une carte de la liste [Link]'''
# A COMPLETER
1f ca rte i n se lf .ca r t eLi s t :
sel f. cart [Link] ve (carte )
else :
print ("la carte n'est pas en main" )
def _ eq_ (se l f , au t re ) :
'' '(Joueur,Joueur)->bool
retourne True si les main ont les meme cartes
dans la meme ordre'''
# A COMPLETER
if len ( sel f .c a rte Li s t)= =len (au t re . carteList):
flag =True
for i i n range (len ([Link] rte l i s t))
. 1 .ç. r n l-f .--. .-+ ,-, 1 .; ,-+ r..:11 _ .., ,, + ... .-.. ,.. ... ... + ..-.. 1 ..: ... +r ..: 1.
elimine une carte de la liste [Link]'''
# A COMPLETER
if carte in [Link]:
[Link]. remove(carte)
else :
print ("la carte n'est pas en main" )
def _ eq_ (self, aut re):
• '' (Joueur,Joueur)->bool
retourne True si les main ont les meme cartes
dans la meme ord re' ' '
# A COMPLETER
if len ([Link] st)==len ([Link]):
flag =True
for i in range (len ([Link]))
1f [Link][il !=[Link][i]:
flag= False
break
return flag
else :
retu rn Fa lse
l
def _re pr_ (self):
'''
{Jo ueur) -> str
retourne une representation de l ' objet de classe Joueur'''
# A COMPLETER
s="nom du joueur : "+[Link]"\nMain du joueur:"
for carte in se l t,carteList:
s+=carte+" 11
return s+"\n\n"
def elimine_paires (self):
'''
(Joueur)->None
Elimine les paires de la liste [Link]
Fait une copie de la liste avec to us les paires éliminées
et mis la nouvelle liste en [Link]
L'ordre des éléments dans le résultat pourrait être différent, ils sont mélange .
resultat= 11
l = [Link]
l. sort()
i=0
while i< len (l )- 1:
cartel=lli l
carte2=ll i +l ]
if ca rt [Link] l e ur== ca r te [Link] l eu r :
PIIWII
resultat=[l
l = [Link]
l . so rt ()
i=0
while i< len (l )-1:
cartel=l [il
carte2=l [i+ll
if [Link]==[Link]:
i=i+l # avance a l a carte prochaine
else :
[Link](l[il)
i=i+l
if i== len (l)-1: # True si la derniere carte n'a pas une paire
[Link](l[il)
[Link](resultat)
[Link]= resultat
def joue ():
' • '(Joueur)->None
Cette fonction joue le jeu' ' '
d = JeuDeCartes()
d.melange_paquet()
donneur= Joueur( 'Robot' )
humain= Joueur( 'Humain ' )
I
tmp=d.donne_cartes()
[Link]=tmp[0]
[Link]=tmp[l]
print ("Bonjour. Je m'appelle Robot et je distribue les cartes." )
print ("Votre main est:" )
[Link] cartes()
print ( "Ne vous- inquiétez pas , je ne peux pas voir vos cartes ni leur ordre . " )
print ( "Maintenant défaussez toutes les paires de votre ma i n. Je vais le faire moi aussi." )
d.attend_le_joueur()
donneur.elimine_paires()
humain.elimine_paires()
ordinales=[ "ère" , "ème" ] # terminaisons pour les numérales ordinale s en français
tour=0
while len ([Link] i n)>0 and l e n([Link] n)>0:
if tour==0: # donneur offres ses cartes
print ( "***********************************************************" )
print ( "Votre tour." )
print ( "Votre main est:" )
humain.affiche_cartes()
position=d.entrez_position_valide( len (don neur . main) )
elem=[Link] in[position - 1]
donneur.remove_carte( elem) # ca marche parce que chaque carte est unique
if position>l:
o rd_index=l
, , , , .
t,,tLe Len\[Link]>~ ana ,en1numaÎ[Link])%!
1. f t a u r==0: # donneur offres ses cartes "
print ("*********************************************************** )
print ("Votre to ur." )
print ( "Votre ma i n es t:" )
humai n.affiche_ca r tes()
position=d.entrez_position_valide( len ([Link]))
elem=[Link][position - 1]
donneur. remove_carte(elem) # ca marche parce que chaque carte est unique
if position>l:
ord_index=l
else :
ord_index=position-1
print ( "Vous avez demande ma " +str (position)+ordinales[ord_index]+" ca r te . " )
print ( "La voila. C'est un" , elem)
humain.a j oute_ca r te(elem)
print ( "Avec" , elem , "ajouté, votre main est:" )
humain.affiche_cartes()
print ( "Aprè s défauss é ·toutes les paires et méla nge r le s ca rtes , votre main est : " )
humain.elimine_paires()
humain.affiche_cartes()
d.attend_l e_joueur()
tour=l
I
else :
print ("***********************************************************" )
print ( "Mon t our." )
index=[Link](0, len ([Link] i n)-1)
elem=humain . main[index]
humain.remove_carte (elem )
do nne u r.ajoute_carte(elem)
donneur.elimine_pai r es()
if index>l:
ord_index=l
else :
o rd_index=index
print ( " J 'ai p ris vo t re " +str (index+l)+ordinales [o r d_i ndex] +" carte." )
d.attend_ le_ joueur()
to u r=0
if len (don [Link])==0:
print ( " J'ai terminé t outes l es cartes. " )
print ( " Vo us avez pe r du! Mo i , Robo t , j'ai gagné." )
else :
print ("***********************************************************" l
print ( "J'ai terminé toutes les ca r tes. " )
print ("Felicitations! Vo us , Humain , vous a vez gagné . " )
# programme pr incipale
j oue ( )