modification de nettoyage de code Poker du livre ... pas tout à fait

Question

à travers plus de travail livre examples- celui-ci est un poker partiel PROGRAM- Ce segment traite la main droite ....

d'abord ce qui a été given- seulement parties pertinentes .... fournira le code entier si nécessaire ...

int suits[5]; //index 1..4- value start at 1 
int values[14]; //index 1..13- value same as rank, A = 1, K = 13 

cin.get(rankCh); 
switch (toUpper(rankCh)) { 
case 'A': values = 1; break; 
case '2': values = 2; break; 
case '3': values = 3; break; 
case '4': values = 4; break; 
case '5': values = 5; break; 
case '6': values = 6; break; 
case '7': values = 7; break; 
case '8': values = 8; break; 
case '9': values = 9; break; 
case 'T': values = 10; break; 
case 'J': values = 11; break; 
case 'Q': values = 12; break; 
case 'K': values = 13; break; 
default: 
badCard = true; 
} 

Autres fonctions:

bool isFlush(int suits[]) { 
    for(i = 1; i <= 4; i++) 
     if (suits[i] == 5)  //5 here is Number of Cards 
      return true; 
    return false; 
} 

Ouais, je sais au sujet des déclarations de tableau, mais qui est ho w il est défini- belle justification pour cela dans le texte ... commencer à numéroter à 1 Je veux que ma main droite gère à la fois Ace haut et bas - comme défini ci-dessus aces sont faibles ...

Deux versions: 1er ne semble pas que correcte avec aces bas ...

CODE

bool isStraight(int values[]) //Version one only straight- low aces only 
{ 
    int count = 0; 

    for (i = 1; i <= 13; i++) { 
     if (values[i] != 1) { 
      count++; 
     } else 
      count = 0; 

     if (count == 5) //5 is NUMCARDS 
      return true; 
    } 
    return false; 
} 

maintenant, c'est là où je besoin d'une recommandation: d'avoir une fonction pour gérer à la fois ace haute et basse:

bool isStraight(int values[]) //Version handles both high and low 
{ 
    int count = 0; 

    for (i = 1; i <= 13; i++) { 
     if (values[i] != 1) { 
      count++; 
      // if(i == 1 && values[1] != 0) //Check for high and low 
      // count++; 
     } else 
      count = 0; 

     if (count == 5) //5 is NUMCARDS 
      return true; 
    } 
    return false; 
} 

Est-ce que ce que j'ai dans les commentaires fonctionne pour gérer ace haut et bas ...

Puisque i = 1 est représenté comme as et ne sais pas quelles valeurs [1] est correct devrait-il être des valeurs [13] ou quoi ... peut-être quelque chose comme

if (i == 1) 
    values[13] //not sure... 

Recommendations-

• ne veulent pas de gros Modifications- juste pour avoir des changements mineurs avec ce que j'ai ... Je ne veux pas trier ou résoudre par la force brute c'est-à-dire des valeurs similaires [1] == 1 & & valeurs [2] == 1 vous obtenez le Point- le texte fait déjà, mais je suis en train de réécrire cette façon ...

Merci ... L'espoir que je reçois sur ma modification je voudrais ...

Answer 1

EDIT: Je me suis dit que je répondrais d'abord directement à votre question. Permet de clarifier d'abord comment l'algorithme original a fonctionné. Fondamentalement, il boucle de 1 à 13, et chaque fois qu'il voit une carte dans cette fente, il ajoute à compter. Si quelque chose casse la séquence, il réinitialise le compteur. Enfin, si le compteur atteint 5, vous avez une ligne droite.

Je ne peux pas dire si votre solution fonctionnerait, je dis essayer. Cependant, un simple correctif rapide à l'original serait probablement quelque chose comme ceci:

//Version handles both high and low 
bool isStraight(int values[]) { 
    int count = 0; 

    for (i = 1; i <= 13; i++) { 
     if (values[i] != 1) { 
       count++; 
     } else 
       count = 0; 

     if (count == 5) //5 is NUMCARDS 
       return true; 
    } 

     // handle ace high. 
     if(count == 4 && values[1] != 0) { 
      return true; 
     } 

    return false; 
} 

Fondamentalement, ce que cela fait est de dire « si nous avons déjà 4 dans une rangée, et nous avons juste regardé la dernière carte (la boucle est terminée), alors vérifiez qu'un as est là, si c'est le cas, nous avons une ligne droite et c'est un as haut ".

RÉPONSE ORIGINAL: Je pense que la meilleure façon de gérer ace haut et bas est d'avoir la fonction « get rang » ont deux modes, l'un qui retourne ace élevé, l'autre qui retourne ace faible.Ensuite, il suffit de calculer la valeur de la main pour chaque cas et prendre le meilleur.

De plus, votre classement peut être beaucoup plus simple :-P.

int get_rank(char card) { 
    static const char *cards = "A23456789TJQK"; 
    char *p = strchr(cards, toupper(card)); 
    if(p) { 
     return (p - cards) + 1; 
    } else { 
     return -1; 
    } 
} 

donc si vous voulez avoir un get_rank qui a un ace_high ou un ace_low, vous pouvez le faire:

int get_rank(char card, bool ace_high) { 
    static const char *cards_high = "23456789TJQKA"; 
    static const char *cards_low = "A23456789TJQK"; 

    const char *cards = ace_high ? cards_high : cards_low; 

    char *p = strchr(cards, toupper(card)); 
    if(p) { 
     return (p - cards) + 1; 
    } else { 
     return -1; 
    } 
} 

EDIT:

pour le plaisir, je l'ai fait un programme rapide et sale qui détecte les lignes droites (manipulant à la fois l'as haute et basse). Il est assez simple, mais pourrait être plus courte (noter également qu'il n'y a aucune tentative de sécurité tampon avec ces tableaux, quelque chose de la qualité de la production devrait utiliser quelque chose de plus sûr, comme std::vector:

#include <algorithm> 
#include <iostream> 
#include <cstring> 

int get_rank(char card, bool ace_high) { 
    static const char *cards_high = "23456789TJQKA"; 
    static const char *cards_low = "A23456789TJQK"; 
    const char *cards = ace_high ? cards_high : cards_low; 

    char *p = strchr(cards, toupper(card)); 
    if(p) { 
     return (p - cards) + 1; 
    } else { 
     return -1; 
    } 
} 

bool is_rank_less_low(int card1, int card2) { 
    return get_rank(card1, false) < get_rank(card2, false); 
} 

bool is_rank_less_high(int card1, int card2) { 
    return get_rank(card1, true) < get_rank(card2, true); 
} 

bool is_straight(int hand[], bool ace_high) { 

    std::sort(hand, hand + 5, ace_high ? is_rank_less_high : is_rank_less_low); 
    int rank = get_rank(hand[0], ace_high); 
    for(int i = 1; i < 5; ++i) { 
     int new_rank = get_rank(hand[i], ace_high); 
     if(new_rank != rank + 1) { 
      return false; 
     } 
     rank = new_rank; 
    } 
    return true; 
} 

bool is_straight(int hand[]) { 
    return is_straight(hand, false) || is_straight(hand, true); 
} 

int main() { 
    int hand1[5] = { 'T', 'J', 'Q', 'K', 'A' }; 
    int hand2[5] = { 'A', '2', '3', '4', '5' }; 
    std::cout << is_straight(hand1) << std::endl; 
    std::cout << is_straight(hand2) << std::endl; 
} 

Answer 2

Le cas où un haut as eXISTE droite se trouve en changeant le test final.

if (count == 5 || count == 4 && values[1] == 1) // 2nd case handles ace-high straight 
    return true; 

il est un cas particulier, il doit être traité séparément