Programmation du jeu Poker en python (2.7.5)
Répondre à la discussion
Affichage des résultats 1 à 17 sur 17

Programmation du jeu Poker en python (2.7.5)



  1. #1
    inviteafd1c9ef

    Programmation du jeu Poker en python (2.7.5)


    ------

    Bonjour !
    Voila je me suis lancée dans la programmation, je débute tout juste ! Grace à un ami et au prof d'info a la fac, j'ai pu assez vite maîtriser les fonctions de base (if, else, def,...), par contre mon vocabulaire est plus approximatif que vigoureux, et mon programme est j'en suis sure loin d'être optimal, je m'en excuse a l'avance. Je précise aussi que j'utilise l'avant dernière (il me semble) version de python car c'est celle imposée à la fac pour les cours d'infos, question de simplicité donc. Bref, mon but est de simuler le jeu, (pas la donne par exemple), d'ailleurs j'ai utilisé random pour ca. Ne sachant pas utiliser les fonctions relatives aux objets, j'ai fait comme tel: le valet =11, la dame = 12 et le roi =13 (comme je l'ai dit je débute...). En fait tout va plutot bien jusqu'au moment où il faut que je programme la comparaison des cartes sorties avec les combinaisons gagnantes (paire, double paire, triple paire, brelan, carré, full, quinte flush et quinte flush royale). Je précise aussi que j'ai fait abstraction du paramètre couleur.

    En premier lieu, voilà la première partie:

    Code:
    # -*- coding: cp1252 -*-
    
    import random
    
    def poker():
      x=random.randint(1, 13)
      y=random.randint(1, 13)
      a=random.randint(1, 13)
      b=random.randint(1, 13)
      c=random.randint(1, 13)
      d=random.randint(1, 13)
      e=random.randint(1, 13)
      S=0
      quinteFlush1=(2, 3, 4, 5, 6)
      quinteFlush2=(3, 4, 5, 6, 7)
      quinteFlush3=(4, 5, 6, 7, 8)
      quinteFlush4=(5, 6, 7, 8, 9)
      quinteFlush5=(6, 7, 8, 9, 10)
      quinteFlush6=(7, 8, 9, 10, 11)
      quinteFlush7=(8, 9, 10, 11, 12)
      quinteFlush8=(9, 10, 11, 12, 13)
      quinteFlushRoyale=(10, 11, 12, 13, 1)
      cartesMains=(x, y)
      sortie1=(a, b, c)
      sortie2=(a, b, c, d)
      sortie3=(a, b, c, d, e)
      carteSorties= cartesMains + sortie3
      banque= 1000
      print 'Bienvenue! Vous allez jouer au poker.'
      print ['Banque:'] + [banque]
      print 'Votre blind de départ est de 25:'
      print ['Banque:'] + [banque-25]
      banque=banque-25
      print 'Voici vos deux cartes et les trois premières cartes de la Main:'
      print [cartesMains] + [sortie1]
      print 'Combien misez-vous ?'
      u=input()
      while u>banque:
        print 'Vous n\'avez pas assez de sous! Veuillez choisir une autre mise:'
        u=input()
      print ['Banque:'] + [banque - u]
      banque=banque-u
      print 'Voici la carte suivante:'
      print [cartesMains] + [sortie2]
      print 'Combien misez-vous ? Veuillez choisir une mise comprise dans', [u,banque]
      v=input()
      while v<u:
        print 'Veuillez choisir une mise comprise dans', [u,banque]
        v=input()
        while v>banque:
          print 'Vous n\'avez pas assez de sous! Veuillez choisir une autre mise:'
          v=input()
      print ['Banque:'] + [banque - v]
      banque=banque-v
      if v>banque:
        print 'Vous avez perdu ! En effet:', [v,banque], 'Vous ne pouvez pas miser dans cet intervalle !'
        return
      print 'Voici vos cartes et la Main complète:'
      print [cartesMains] + [sortie3]
      print 'Que misez-vous ? Veuillez choisir une mise comprise dans', [v,banque]
      w=input()
      while w>banque:
        print 'Vous n\'avez pas assez de sous! Veuillez choisir une autre mise:'
        w=input()
      while w<v:
        print 'Veuillez choisir une mise comprise dans', [u,banque]
        w=input()
      print ['Banque:'] + [banque - w]
      banque=banque-w
      if w>banque:
        print 'Vous avez perdu ! En effet, vous ne pouvez pas miser dans cet intervalle:', [w, banque]
        return
      print 'Je vous rappelle votre Main et vos cartes:'
      print [cartesMains] + [sortie3]
    Si vous avez des conseils à me donner pour cette partie je suis prenante, que ce soit des nouvelles fonctions ou des conseils d'optimisation

    Je vous présente maintenant ma deuxième partie... S'il vous plait ne me lapidez pas et ne vous arrachez pas les cheveux je sais que c'est du n'importe quoi mais c'est pour que vous voyez le raisonnement que j'ai voulu employer.

    Code:
    for i in carteSorties:
        for j in carteSorties:
          for k in carteSorties:
            for l in carteSorties:
              for m in carteSorties:
                for n in carteSorties:
                  for o in carteSorties:
                    if i != j :
                      if j != k:
                        if k != l:
                          if l != m:
                            if m != n:
                              if n != o:
                                if (cartesMains + sortie3) == (n, o, 10, 11, 12, 13, 1):
                                  print 'Vous avez une quinte flush royale ! Vous gagner 800.'
                                  banque = banque + 800
                                  print ['Banque:'] + [banque]
                                  return
                                else:
                                  if (cartesMains + sortie3) == (o, j, n, n+1, n+2, n+3, n+4):
                                    print 'Vous avez une quinte flush ! Vous gagner 600.'
                                    banque = banque + 600
                                    print ['Banque:'] + [banque]
                                    return
                    if i != j:
                      if j != k:
                        if k != l:
                          if l != m:
                            if m != n:
                              if n == o:
                                S =S+1
                                print ['Vous avez']+[S]+['paires! Vous gagnez:']+[S*100]
                                banque = banque + S*100
                                print ['Banque:'] + [banque]
                                return
                    if i != j :
                      if j != k:
                        if k != l:
                          if l != m:
                            if m == n:
                              if n == o:
                                if (cartesMains + sortie3) == (i, j, k, n, n, n, l):
                                  print 'Vous avez un brelan ! Vous gagnez 300.'
                                  banque = banque + 300
                                  print ['Banque:'] + [banque]
                                  return
                    if i != j :
                      if j != k:
                        if k != l:
                          if l == m:
                            if m == n:
                              if n == o:
                                if (cartesMains + sortie3) == (j, i, n, n, n, n, k):
                                  print 'Vous avez un carré ! Vous gagnez 400.'
                                  banque = banque + 400
                                  print ['Banque:'] + [banque]
                                  return
                    if i != o :
                      if i != n:
                        if k != o:
                          if k != n:
                            if i != k:
                              if i == j:
                                if k == l:
                                  if l == m:
                                    if (cartesMains + sortie3) == (o, n, i, i, k, k, k):
                                      print 'Vous avez un full ! Vous gagnez 500.'
                                      banque=banque+500
                                      print ['Banque:'] + [banque]
                                      return                    
      print ['Vous avez perdu:'] + [u+v+w]
      print ['Banque:'] + [banque]
      return
    Voilà, d'abord je ne pense pas employer le bon raisonnement puisque ça ne marche pas (il me sort un full quand ya aucune carte qui se ressemble...). J'ai voulu que ma combinaison de cartes sorties soit comparée une a une avec chacune des combinaisons gagnantes. J'ai essayé de faire différemment: je compare a une combinaison, je rajoute un parametre, je compare, je rajoute, je compare...) et ca ne marchait pas non plus. De plus il y a très probablement plein d'erreurs, mais c'est pour vous montrer comment j'ai voulu raisonner.

    Je rappelle que je débute donc s'il vous plait ne me jeter pas la pierre a propos de mon vocabulaire ou quoi que ce soit d'autre, merci
    Le but de tout ca est que vous me dites si ya 2 ou 3 trucs de bon dans mon programme, et que éventuellement si vous n'êtes pas trop dégoutés que vous me donniez des conseils et ou que vous me recommandiez des fonctions à utiliser (à part append et lengh, elles y sont toutes).
    Merci pour vos aides et réponses !

    Le concombre

    -----
    Dernière modification par JPL ; 28/10/2013 à 14h40. Motif: Ajout de la balise Code (#) pour garder l'indentation

  2. #2
    Arzhur

    Re : Programmation du jeu Poker en python (2.7.5)

    Bonjour,


    Ca c'est du Brute Force !!!!!


    Code:
    if (cartesMains + sortie3) == (n, o, 10, 11, 12, 13, 1):
    Pas bon ça : l'ordre est important
    si tu as (cartesMains + sortie3)= (11,13,10,9,12,1) tu ne détectera jamais la quinte puisque (11,13,10,9,12,1)!=(9,10,11,12 ,13,1)


    Pour info une paire c'est quand y'a 2 cartes identiques....tu peux ptet juste chercher les chiffres en double pour déterminer si y'a une paire ou pas dans la main (et faire de même pour brelan/carre/full)

  3. #3
    azad

    Re : Programmation du jeu Poker en python (2.7.5)

    Salut
    Avec ta notation, l'As vaut 1 et le Roi 13. Mieux vaut prendre 2 pour le Deux, et 14 pour l'As et bien sûr 3,4... pour les cartes intermédiaires. Tu peux faire précéder ces valeurs par T, C,K,P pour les couleurs. Ensuite quand la distribution est terminée (pas de doublons) tu tries tes cartes par ordre de valeurs (du 2 au 14)
    1er test- Y a-t-til une couleur ?
    Oui si toutes les cartes commencent par la même lettre (T,C,K,P)
    Si oui et si la valeur de la plus petite vaut x, celle de la seconde x+1, celle de la troisième x+2 et ainsi de suite…. si ce test est positif, alors, c'est une Quinte Flush, et si la valeur de la cinquième est As alors c'est la Quinte Flush Royale.
    Pour ne pas oublier la Quinte As,2,3,4,5 on regarde simplement si la première est un deux et qu'en ajoutant 1 à chaque carte on tombe bien soit sur un six pour la derrière soit sur un 13 dans les deux cas c'est encore une Quinte.
    L'avantage du tri des cartes est que les autres jeux ne peuvent avoir qu'un nombre réduit d'agencement.
    Le Full par exemple est obligatoirement de la forme x,x,y,y,y ou x,x,x,y,y
    Un carré sera sous la forme x,x,x,x,y ou x,y,y,y,y
    Deux paires : x,x,y,y,z ou x,x,z,y,y ou z,x,x,y,y
    Le reste à l'avenant. Brelan par ex : x,y,z,z,z ou x,z,z,z,y ou z,z,z,x,y.
    Bien entendu, une fois la détermination du jeu effectuée, on affiche les cartes dans le désordre. Sinon le joueur hurlera à la supercherie.
    Pour la gestion du crédit c'est relativement simple : pas question de miser plus que ce que l'on a. Donc tu boucles de la mise minimum, à la mise maximum tant que cette dernière n'atteint pas le crédit disponible.
    Si tu veux je peux t'envoyer quelques méthodes (sous-programmes, en RealBasic assez proche de Python) pour justement cette partie d'un programme de Poker 5 cartes. Seule subtilité celui que j'ai fais a en prime le Joker, ce qui ne manque pas de compliquer sérieusement l'analyse. Et aussi (pour approcher au mieux ce qui se fait dans les Casinos) une aide à la décision offerte au joueur. Par exemple si tu as la donne 7,8,9,10 et As, les quatre premières cartes sont sélectionnées car il y a espoir de Quinte. Pour deux paires servies, on sélectionne les cartes des deux paires en rejetant l'étrangère. Un peu comme le ferait un joueur normal.
    Mais les joueurs, sont-ils normaux ?
    Dernière modification par azad ; 28/10/2013 à 17h21.

  4. #4
    Arzhur

    Re : Programmation du jeu Poker en python (2.7.5)

    Tu peux faire précéder ces valeurs par T, C,K,P pour les couleurs
    Autant manipuler un doublet, ça évite de parser la chaine.

    Si tu veux je peux t'envoyer quelques méthodes (sous-programmes, en RealBasic assez proche de Python) pour justement cette partie d'un programme de Poker 5 cartes
    Euh...ça m'intéresse aussi si c'est possible.

  5. A voir en vidéo sur Futura
  6. #5
    inviteafd1c9ef

    Re : Programmation du jeu Poker en python (2.7.5)

    Arzhur; tu veux dire qu'au lieu de quinteFlush1=(2, 3, 4, 5, 6), quinteFlush2=(3, 4, 5, 6, 7)... j'utilise donc range(2, 7), range(3, 8),... ?
    Je retiens ton conseil pour TCPK azad. Tu veux dire aussi que je n'ai pas besoin d'utiliser 7 fois range avec i, j, k, l, m, n,, mais seulement 3 fois avec x, y, z ?
    Je vais essayer d'intégrer progressivement ce que vous m'avez dit et je vous montre ce que j'ai.
    Je suis interessée par les quelques méthodes dont tu parles.
    Pour la gestion du crédit n'est-ce pas ce que j'ai déja fait ?
    Azad pour ta dernière partie, j'ai pas compris ce que tu veux dire par 'les quatre première cartes sont selectionnées car il y a espoir de quinte', que veux-tu dire par selectionner ?

  7. #6
    Arzhur

    Re : Programmation du jeu Poker en python (2.7.5)

    Ce que je veux dire c'est que tu fais une égalité entre 2 listes, il faut au moins que les 2 listes soient strictement identiques pour que le == retourne True.

    Le problème est que d'un côté tu as [main + sortie ] qui est completement aléatoire et de l'autre tu as (o, j, n, n+1, n+2, n+3, n+4) qui est (presque) toute bien triée. Donc tu peux avoir 2 listes identiques (ie avec le même contenu) mais pas égale (dans le sens ==) parce que l'ordre n'est pas respectée.

    Il faut que tu tries tes listes comme azad le suggère : ca simplifie grandement l'algo pour la détection de suite/quinte. Pour les autres combinaisons une simple recherche de doublon suffira.

    ps : Essaye d'enlever cette méga-imbrication de for...ça pique un peu les yeux.

  8. #7
    azad

    Re : Programmation du jeu Poker en python (2.7.5)

    Bon, voilà la routine qui évalue le jeu distribué. Elle retourne la chaine resultat.
    Les variables principales sont ColC(j) et ValC(j) respectivement les couleurs et les valeurs des cartes en jeu. Deux tableaux dimensionnés à 5. J'ai supprimé dans cette copie la gestion de l'éventuel Joker.
    Les ValC(j) sont les valeurs des cartes du deux (2) à l'as (14)
    Resultat retourne QFM, QF, Carre, Full, Couleur, Quinte, Brelan, DPaires, PaireM, Paire, Rien
    (en effet dans mon jeu, une paire de valets, de dames, de rois ou d'as payent une fois la mise, d'ou la PaireM )


    Code:
      resultat=""
    /* cherche pour couleur, quintes flush et quintes
    if ColC(1)=ColC(2) and ColC(2)=ColC(3) and ColC(3)=ColC(4) and ColC(4)=ColC(5) then     /* il y a une couleur
    
     	if (ValC(1) +1 = ValC(2)  and ValC(2) +1 = ValC(3) and ValC(3) + 1= ValC(4) and ValC(4)+ 1 = ValC(5)) or 
     		(ValC(1)=2 and ValC(2)=3 and ValC(3)=4 and ValC(4)=5 and ValC(5)=14) then     
          		resultat="QF"
    	end
    	if resultat="QF" and ValC(1) =10 then
    		resultat="QFM"
    	end
    	If resultat = "" then
    		resultat="Couleur"
    	end
    	return resultat     /*on sort de la routine
    else  /* on n'a pas de couleur, voyons s'il y a une quinte
    	if (ValC(1) +1 = ValC(2)  and ValC(2) +1 = ValC(3) and ValC(3) + 1= ValC(4) and ValC(4)+ 1 = ValC(5)) or 
     		(ValC(1)=2 and ValC(2)=3 and ValC(3)=4 and ValC(4)=5 and ValC(5)=14) then     
          		resultat="Quinte"
    		return resultat  /* et sort de la routine
    	end
    end
    
    /*cherche pour carre
     if (ValC(1)=ValC(2) and ValC(2)=ValC(3) and ValC(3)=ValC(4))  or  (ValC(2)=ValC(3) and ValC(3)=ValC(4) and ValC(4)=ValC(5)) then
        resultat="carre"
        return resultat  /* on sort
    end
    
    /*cherche Full et DPaires
    
    if ValC(1)=ValC(2) and ValC(2)=ValC(3) and ValC(3)<>ValC(4) and ValC(4)=ValC(5)  or 
      ValC(1)=ValC(2) and ValC(2)<>ValC(3) and ValC(3)=ValC(4) and ValC(4)=ValC(5)  then
    	resultat="full"
    	return resultat
    end
      if ValC(1)=ValC(2) and ValC(2)<>ValC(3) and ValC(3)<>ValC(4) and ValC(4)=ValC(5) then
       	 resultat="Dpaires"
       	 /* de la forme yyXzz
    	Return resultat
      end
      if ValC(1)<>ValC(2) and ValC(2)=ValC(3) and ValC(3)<>ValC(4) and ValC(4)=ValC(5) then
       	 resultat="Dpaires"
       	 /* de la forme Xyyzz
    	Return resultat
      end
      if ValC(1)=ValC(2) and ValC(2)<>ValC(3) and ValC(3)=ValC(4) and ValC(4)<>ValC(5) then
        	resultat="Dpaires"
       	 /* de la forme yyzzX
    	Return resultat
      end
    /*cherche pour  brelan
      if ValC(1)=ValC(2) and ValC(2)=ValC(3) and ValC(3)<>ValC(4) and ValC(4)<>ValC(5) then
        resultat="brelan"
       	 /* de la forme yyyXZ
    	Return resultat
      end
      if ValC(1)<>ValC(2) and ValC(2)=ValC(3) and ValC(3)=ValC(4) and ValC(4)<>ValC(5) then
        resultat="brelan"
       	 /* de la forme XyyyZ
    	Return resultat
      end
      if ValC(1)<>ValC(2) and ValC(2)<>ValC(3) and ValC(3)=ValC(4) and ValC(4)=ValC(5) then
        resultat="brelan"
       	 /* de la forme XZyyy
    	Return resultat
      end
    
    /* cherche paires et pairesM
    /* n'oublions pas que les cartes sont rangées par valeurs croissantes
    /* si la plus petite carte est un plus grande qu'un dix, alors la paire présente est une PaireM 
    
    /* de la forme XXabc
     if ValC(1)=ValC(2) and ValC(2)<>ValC(3) and ValC(3)<>ValC(4) and ValC(4)<>ValC(5) then
       	resultat="paire"
        	if ValC(1)>10 then
          		resultat="paireM"
    	 end
          	Return resultat
     end
    
    /* de la forme aXXbc
      if ValC(1)<>ValC(2) and ValC(2)=ValC(3) and ValC(3)<>ValC(4) and ValC(4)<>ValC(5) then
        	resultat="paire"
        	if ValC(2)>10 then
          		resultat="paireM"
       	end
          	Return resultat
    end
    
     /* de la forme abXXc
      if ValC(1)<>ValC(2) and ValC(2)<>ValC(3) and ValC(3)=ValC(4) and ValC(4)<>ValC(5) then
        	resultat="paire"
    	if ValC(3)>10 then
          		resultat="paireM"
       	 end
    	 Return resultat
      end
    
    /* de la forme abcXX
      if ValC(1)<>ValC(2) and ValC(2)<>ValC(3) and ValC(3)<>ValC(4) and ValC(4)=ValC(5) then
      	 resultat="paire"
        	if ValC(4)>10 then
         		 resultat="paireM"
         
       	 end
          	Return resultat
      end
    /* et en fin de la procédure, si résultat est resté vide alors resultat= "Rien"
    Voilà, c'est le principe que j'ai utilisé, ici je ne vous montre pas la version où existe le Joker, j'ai donc amputé mon code de pas mal de lignes
    et il se pourrait qu'il y ait une erreur ou deux, mais ce devrait être clair. Et quand il y a un Joker une nouvelle main existe, c'est le carré complet + le Joker que les joueurs appellent le Five..... et qui paie 1100 fois la mise.
    A noter que pour chaque jeu trouvé je sauve également un tableau qui indique au joueur les cartes à garder, pour cela j'ai une tableau "aide" qui ressemble à
    00111 où les 1 indiquent l'index de la carte à marquer.
    Dernière modification par azad ; 28/10/2013 à 23h01.

  9. #8
    azad

    Re : Programmation du jeu Poker en python (2.7.5)

    Azad pour ta dernière partie, j'ai pas compris ce que tu veux dire par 'les quatre première cartes sont selectionnées car il y a espoir de quinte', que veux-tu dire par selectionner ?
    Mon jeu est un draw Poker
    Il distribue 5 cartes, le joueur clique sur les cartes qu'il veut garder. Quand cela est fait, les cartes non gardées sont remplacées par de nouvelles cartes. Le programme "conseille" le joueur ainsi s'il y a par exemple deux paires affichées à la première donne alors ces deux paires sont automatiquement sélectionnées et appuyer sur le bouton "Start" efface la carte non sélectionnée et fait apparaître la carte de la seconde donne.
    Bien sûr, à la deuxième donne pas question de distribuer une carte déjà sortie à la première et rejetée par le joueur.

  10. #9
    inviteafd1c9ef

    Re : Programmation du jeu Poker en python (2.7.5)

    Je suis en train de mettre en place tout ca, j'ai vraiment tout compris mais azad pourquoi tu ne tiens comptes que de 5 cartes au lieu de 7 ?

  11. #10
    inviteafd1c9ef

    Re : Programmation du jeu Poker en python (2.7.5)

    En fait oui j'avais mal lu ce que tu avais dit pour les 5 cartes. Mais je suis larguée parce que je ne vois absolument pas comment trier les cartes une fois qu'elles sont sorties, et je vois pas comment "dire en algo" que si 'valeur(première carte)+1=valeur(deuxieme carte) ....' alors QF. J'ai essayé plusieurs trucs dont (une fois que les cartes serait prétenduement triées par ordre de grandeur), affecter les valeurs des cartes triées a de nouvelles variables ( en tenant toujours compte de l'ordre de croissance), et dire plutot: si x+1=y et si y+1=z etc...
    Et pour le tri j'ai essayé une comparaison mais elle est pas trop au point parce que finalement elle me ressort tous les élément de la liste mais en triple. En fait je désespère un peu ^^

  12. #11
    Arzhur

    Re : Programmation du jeu Poker en python (2.7.5)

    comment "dire en algo" que si 'valeur(première carte)+1=valeur(deuxieme carte)
    Soit list = (10,35,51,27) alors list[0] te retourne la première valeur et list[1] la deuxième.

    Et pour le tri j'ai essayé une comparaison mais elle est pas trop au point parce que finalement elle me ressort tous les élément de la liste mais en triple. En fait je désespère un peu ^^
    Fais nous voir ton algo de tri.

  13. #12
    azad

    Re : Programmation du jeu Poker en python (2.7.5)

    Pour trier en ordre croissant les 7 variables d'un tableau x(7), on crée une variable intermédiaire c et on peut (en RealBasic) écrire
    for i=1 to 7
    for j=1 to 6
    if x(j) > x(j+1) then
    c=x(j)
    xx(j)=xx(j+1)
    xx(j+1)=c
    end
    next
    next
    En fait c'est plus facile à écrire en Python puisque ce langage utilise les Listes, et que List admet la fonction List.sort qui trie de façon plus claire qu'en basic.

    Pour le reste puisque tu as opté pour un HoldHem Poker, il faut raisonner sur 7 cartes triées et voir comment les jeux gagnants peuvent se présenter avec 7 cartes au lieu de 5. C'est un peu plus compliqué car plus de combinaisons, mais le principe reste le même.
    Mais en Python, encore, c'est plus facile car les listes permettent aussi bien plus élégamment la recherche parmi les éléments qui la composent.
    Pour ma part, j'ai été forcé d'utiliser RealBasic (qui s'appelle maintenant Xojo) car c'est à ma connaissance le seul outil de développement (abordable financièrement) qui permette de programmer à partir d'un système d'exploitation quelconque parmi les MacOS, Linux ou Windows une application et de la tester en mode IDE, puis une fois opérationnelle de lui demander de générer l'exécutable pour le système que l'on à choisi comme destination. (Cross compilator)
    Cela me permet de générer des applications PC à partir du Mac, sans avoir à me soucier des subtilités de Windows.
    Dernière modification par azad ; 30/10/2013 à 09h53.

  14. #13
    inviteafd1c9ef

    Re : Programmation du jeu Poker en python (2.7.5)

    Ah d'accord je connaissais pas cette fonction, merci ! Mon algo de tri ressemble a ça:

    Code:
    Code:
    liste=(2, 9, 7, 3, 8)
    cartes_Sup_A_I=[]
    cartes_Sup_A_II=[]
    cartes_Sup_A_III= []
    cartes_Sup_A_IIII= []
    print 'PREMIERE PARTIE, ISOLER 2'
    for i in liste:
      for j in liste:
        if i < j:
          cartes_Sup_A_I= cartes_Sup_A_I + [j]
          plusPetit = list(set(liste) - set(cartes_Sup_A_I))
          w = list(set(liste) - set(plusPetit))
    print w
    print plusPetit
    print cartes_Sup_A_I
    
    print 'DEUXIEME PARTIE, ISOLER 3'
    
    for ii in w:
      for jj in w:
        if ii < jj:
          cartes_Sup_A_II = cartes_Sup_A_II + [jj]
          plusPetit2 = list(set(liste) - set(cartes_Sup_A_II))
          x = list(set(w) - set(plusPetit2))
    print x
    print plusPetit2
    print cartes_Sup_A_II
    
    print 'TROISIEME PARTIE, ISOLER 7'
    
    for iii in x:
      for jjj in x:
        if iii < jjj:
          cartes_Sup_A_III= cartes_Sup_A_III + [jjj]
          plusPetit3 = list(set(liste) - set(cartes_Sup_A_III))
          y = list(set(x) - set(plusPetit3))
    print y
    print plusPetit3
    print cartes_Sup_A_III
    
    print 'QUATRIEME PARTIE, ISOLER 8'
    
    for iiii in y:
      for jjjj in y:
        if iiii < jjjj:
          cartes_Sup_A_IIII= cartes_Sup_A_IIII + [jjjj]
          plusPetit4 = list(set(y) - set(cartes_Sup_A_IIII))
          z = list(set(y) - set(plusPetit4))
    print z
    print plusPetit4
    print cartes_Sup_A_IIII
    
    print liste
    listeAprès = plusPetit3 + plusPetit4 + z
    print listeAprès
    Le dernier print est le résultat final. Bien sur il est adapté qu'à une liste de 5 éléments, et absolument pas optimal mais bon il trie. Par contre j'arrive pas du tout à intégrer les couleurs, mais pas du tout, j'ai écrit un truc du genre listeK = K*range(2, 15) mais il me dit K est pas définit, alors sans etre convaincue du résultat j'ai écrit K=carreau mais bon ahah je me doutais que ca marcherait pas et je sais pourquoi, mais je vois pas d'autres solutions, a moins de mettre les valeurs sous '', mais dans ce cas on ne pourra plus calculer avec, si ?
    (Non je n'arrive pas a utiliser la balise Code(#))
    Dernière modification par JPL ; 30/10/2013 à 15h15. Motif: Ajout de la balise Code (#) pour garder l'indentation

  15. #14
    inviteafd1c9ef

    Re : Programmation du jeu Poker en python (2.7.5)

    Les autres print étaient a titre d'indication pour ne pas que je m'embrouille, j'ai oublié de les enlever ^^

  16. #15
    Arzhur

    Re : Programmation du jeu Poker en python (2.7.5)

    Avant de se lancer dans la programmation d'un jeu de Poker complet, ça serait pas mal de savoir implémenter un tri "standard"...genre bulle/selection/fusion.


    listeK = K*range(2, 15)
    Je sais pas si c'est possible en Python de concaténer comme ça d'un coup...a confirmer, sinon parcours la liste élément par élément.

  17. #16
    inviteafd1c9ef

    Re : Programmation du jeu Poker en python (2.7.5)

    Non ca ne marche pas pour la liste élément par élément. Tu as raison, je viens de voir le tri par bulle, qui marche certes, et je sais le principe mais je ne comprends pas trop l'algo mais bon. Du coup je vais l'intégrer a mon algo, vous m'avez bien aidée ! Avez vous un dernier conseil pour les couleurs a intégrer ? Je vous montrerai le résultat final si ca vous intéresse Merci !!

  18. #17
    azad

    Re : Programmation du jeu Poker en python (2.7.5)

    Pour les couleurs tu peux :
    - soit comme j'ai fait, donner à tes cartes un nom qui contient l'info couleur (T4, P11... pour 4 trèfle, valet de pique...). Les avantages entre autre sont qu'il est très facile de repérer une couleur, et une fois éliminée la lettre, on a la valeur de la carte, et enfin une fois les calculs faits on peut afficher la carte simplement en envoyant son nom à la routine d'affichage.
    - soit au tirage initial de la carte. Comme on peut supposer que tu tires avec une fonction random un nombre de 1 à 52, alors les couleurs sont groupées dans les intervalles (1 à 13, 14 à 26, 27 à 39, 40 à 52).
    L'exemple de tri que je t'ai donné est un tri à bulles, pour des tri de quelques éléments, c'est amplement suffisant.
    Mais Python a au moins deux fonctions de tri intégrées:
    Par exemple
    >>> MaListe =[ 12,5,8,4,6,3,7]
    >>> sorted(MaListe) retourne 3,4,5,6,7,8,12

    ou encore

    >>> MaListe.sort ..... qui retourne le même résultat comme tu t'en doute.
    Inutile (sauf pour s'instruire) de réinventer la roue.
    Je t'aurais bien envoyé mon programme complet, mais on ne peut pas coller des pièces jointes dans les messages privés.
    Dernière modification par azad ; 30/10/2013 à 20h07.

Discussions similaires

  1. Programmation sous python
    Par inviteb8a16c2c dans le forum Programmation et langages, Algorithmique
    Réponses: 45
    Dernier message: 15/05/2013, 11h13
  2. Problème programmation C++/Python
    Par invite63cfe518 dans le forum Programmation et langages, Algorithmique
    Réponses: 12
    Dernier message: 31/08/2011, 19h24
  3. Programmation python
    Par invite559d53a0 dans le forum Programmation et langages, Algorithmique
    Réponses: 11
    Dernier message: 05/05/2011, 15h29
  4. Programmation d'un modem en python
    Par invitea0da0615 dans le forum Programmation et langages, Algorithmique
    Réponses: 3
    Dernier message: 26/04/2011, 16h22
  5. Programmation python : objets
    Par invite559d53a0 dans le forum Programmation et langages, Algorithmique
    Réponses: 5
    Dernier message: 13/02/2011, 14h22