Algo pour gérer les AS au blackjack!Résolu

Question

Hello la communauté, Dans le carde du développement d'un balckjack en java, je me vois confronté à un problème d'algorithmie. Je veut créer une méthode qui me rend la valeur d'une main au balckjack. Voici ma classe carte qui est déjà complétement implémentée. Elle contient la classe interne "HashMapCartesBlackjack" qui étend HashMap. Ceci pour gérer les valeur des cartes. Vous remarquerez que pour l'as je décide de lui assigner la valeur 11. import java.util.HashMap; import javax.swing.ImageIcon; /** * * @author nurty */ public class Carte { private final HashMapCartesBlackjack mapValeurPoint = new HashMapCartesBlackjack(); public enum CouleurCarte{Pique,Coeur,Carreau,Trefle}; public enum ValeurCarte{as,deux,trois,quatre,cinq,six,sept,huit,neuf,dix,valet,dame,roi}; private ImageIcon icone; private ValeurCarte valeur; private CouleurCarte couleur; private int point; public Carte(CouleurCarte couleur, ValeurCarte valeur){ this.couleur = couleur; this.valeur = valeur; this.point = this.mapValeurPoint.get(this.valeur); System.out.println("/images/"+this.couleur+"_"+this.valeur+".jpg"); this.icone = new ImageIcon(this.getClass().getResource("/images/"+this.couleur+"_"+this.valeur+".jpg")); } public CouleurCarte getCouleur() { return couleur; } public ImageIcon getIcone() { return icone; } public HashMapCartesBlackjack getMapValeurPoint() { return mapValeurPoint; } public int getPoint() { return point; } public ValeurCarte getValeur() { return valeur; } /** * Classe statique permettan d'initialiser un HashMap ayant pour clé la valeur de la carte * (deux , dame, valet, ..) et comme value, le nombre de point associé à la valeur de la carte */ public static class HashMapCartesBlackjack extends HashMap { /** * permet d'initialiser un HashMap ayant pour clé la valeur de la carte * (deux , dame, valet, ..) et comme value, le nombre de point associé à la valeur de la carte */ private HashMapCartesBlackjack() { this.put(ValeurCarte.as, 11); this.put(ValeurCarte.deux, 2); this.put(ValeurCarte.trois, 3); this.put(ValeurCarte.quatre, 4); this.put(ValeurCarte.cinq, 5); this.put(ValeurCarte.six, 6); this.put(ValeurCarte.sept, 7); this.put(ValeurCarte.huit, 8); this.put(ValeurCarte.neuf, 9); this.put(ValeurCarte.dix, 10); this.put(ValeurCarte.valet, 10); this.put(ValeurCarte.dame, 10); this.put(ValeurCarte.roi, 10); } } } Et ici voici la classe Main qui étend simplement une ArrayList de carte. C'est dans cette classe que je veux faire ma méthode permettant de calculer la valeur de la main en tenant compte des règles du blackjack : J'aimerai que cette méthode me donne la valeur de la main en optimisant les AS. Un AS peut valoir 1 ou 11 le but étant de se rapprocher le plus de 21 (21 étant le must). Cette méthode peut me retourner un nombre supérieur à 21 mais devrai me retourner 12 si j'ai deux As et un 2. import java.util.ArrayList; /** * * @author nurty */ public class Main extends ArrayList { /** * METHODE A IMPLEMENTER!!!!!!!!! * @return la valeur de la main */ public int getValeur(){ int somme = 0; boolean aUnAs = false; if(this.size() > 0){ for(Carte maCarte : this){ if(maCarte.getPoint() == 11){ aUnAs = true; } if(somme + maCarte.getPoint() > 21 && aUnAs){ somme = somme + maCarte.getPoint() - 10; }else{ somme = somme + maCarte.getPoint(); } } } return somme; } } Actuellement la methode getValeur() fonctionne si le joueur tire 1 ou aucun AS mais des qu'il en a 2 il y a problème... Merci d'avance pour vos réponses

cs_jojolemariole · Accepted Answer

Salut,

Donc a priori ça donne un truc comme ça :


    /**
     * @return la valeur de la main
     */
    public int getValeur() {

        int totalSansAs = 0;
        int total;
        int maximumAs;
        int nombreAs = 0;
        int nombreAs1;
        int nombreAs11;

        /*
         * on compte le total sans les as et on compte les as par la meme
         * occasion
         */

        for (Carte carte : this) {

            if (carte.getValeur() == Carte.ValeurCarte.as) {
                nombreAs++;
            } else {
                totalSansAs += carte.getPoint();
            }

        }

        /*
         * on etablit le nombre de points a marquer avec les as pour atteindre
         * 21 exactement
         */

        maximumAs = 21 - totalSansAs;

        /*
         * nombre d'as a 11 points pour se rapprocher le plus possible de 21
         * attention, ce resultat peut etre inferieur a 0 ou bien superieur au
         * nombre d'as dans la main
         */

        nombreAs11 = (maximumAs - nombreAs) / 10;

        /*
         * on borne le nombre d'as a 11 points par le nombre d'as dans la main
         */

        nombreAs11 = Math.min(nombreAs, nombreAs11);

        /*
         * on borne le nombre d'as a 11 points par 0
         */

        nombreAs11 = Math.max(0, nombreAs11);

        /*
         * on calcule le total de la main
         */

        nombreAs1 = nombreAs - nombreAs11;

        total = totalSansAs + nombreAs11 * 11 + nombreAs1 * 1;

        return total;

    }

nurty · Answer

EDIT : 
Cette méthode peut me retourner un nombre supérieur à 21 mais devrai me retourner : 14 si j'ai deux As et un 2 / 21 si j'ai deux AS et un neuf / 17 si j' ai un DIX , un SIX et un AS / etc....

cs_jojolemariole · Answer

Salut, Je te propose une solution assez simple : - tu sommes d'abord toutes les cartes qui ne sont pas des AS -> TOTAL_SANS_AS - tu regardes combien de points tu peux faire avec les AS au maximum 21 - TOTAL_SANS_AS -> MAXIMUM_AS - tu regardes combien d'AS tu as dans la main -> NOMBRE_AS - ensuite tu dois juste déterminer combien d'AS à 1 point tu veux -> NOMBRE_AS_1 et combien d'AS à 11 points -> NOMBRE_AS_11 - on sait que NOMBRE_AS_1 + NOMBRE_AS_11 = NOMBRE_AS - on veut que (NOMBRE_AS_1 * 1 + NOMBRE_AS_11 * 11) <= MAXIMUM_AS - on remplace NOMBRE_AS_1 par (NOMBRE_AS - NOMBRE_AS_11) - ça donne ((NOMBRE_AS - NOMBRE_AS_11) * 1 + NOMBRE_AS_11 * 11) <= MAXIMUM_AS - en simplifiant (NOMBRE_AS + NOMBRE_AS_11 * 10) <= MAXIMUM_AS - on passe de l'autre côté NOMBRE_AS_11 * 10 <= MAXIMUM_AS - NOMBRE_AS EXEMPLES j'ai 3 AS, et 8 points sans les AS MAXIMUM_AS = 13 NOMBRE_AS = 3 NOMBRE_AS_11 * 10 <= MAXIMUM_AS - NOMBRE_AS <=> NOMBRE_AS_11 * 10 <= 10 <=> NOMBRE_AS_11 = 0 ou NOMBRE_AS_11 = 1 <=> on prend le max bien sûr NOMBRE_AS_11 = 1 Pour résumer : si MAXIMUM_AS - NOMBRE_AS est inférieur à 0, pas de solution (même si tu prends tous les AS à 1 point tu dépasses les 21) sinon tu fais la division entière (MAXIMUM_AS - NOMBRE_AS) / 10 et ça te donnes le nombre d'AS à 11 points voilà, j'espère avoir été clair et surtout ne pas avoir fait d'erreur!

nurty · Answer

Hello,

Merci pour le temps que tu as consacré à me répondre, pas mal de boulot cette semaine donc pas eu le temps de me pencher dessus.
J'implémente tout ça demain et je te fait un feedback!

nurty · Answer

Voila, j'ai implémenter ma méthode et ca m'a l'air de fonctionner au poil! 

Merci!!

Algo pour gérer les AS au blackjack!

5 réponses

Votre réponse

Discussions similaires