ansaurus

Question

Poker code cleanup modification from book...not quite right...

Answer 1

+2 A:

EDIT: I figured I'd would first answer your question directly. Lets first clear up how the original algorithm worked. Basically it loops from 1 to 13, and each time it sees a card in that slot, it adds to count. If anything ever breaks the sequence, it resets the counter. Finally, if the counter reaches 5, you have a straight.

I can't say off hand if your solution would work, I say give it a go. However, a simple quick patch to the original would probably go something like this:

//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;
}

Basically what that does is say "if we already have 4 in a row, and we've just looked at the very last card (the loop is over), then check an ace is there, if so, we do have a straight and it is ace high".

ORIGINAL ANSWER: I think the easiest way to handle ace high and low is to have the "get rank" function have two modes, one which returns ace high, the other which returns ace low. Then just calculate the hand value for each case and take the better one.

Also, your get rank could be way simpler :-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;
    }
}

so if you want to have a get_rank which has an ace_high or an ace_low, you could do this:

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:

for fun, i've made a quick and dirty program which detects straights (handling both high and low ace). It is fairly simple, but could be shorter (also note that there is no attempt at buffer safety with these arrays, something of production quality should use something safer such as 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;
}

Evan Teran 2009-06-15 18:25:45

The value of count should be checked only when it is incremented, which is not every time through the loop.

Mark Ruzon 2009-06-16 00:22:57

While you are that's a pretty minor optimization. The check is where it is, because that's where it was in the original code.

Evan Teran 2009-06-16 01:43:13

I take this answer and see where it goes...

iwanttoprogram 2009-06-19 23:05:58

Answer 2

+1 A:

The case where an ace-high straight exists can be found by changing the final test:

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

It's a special case, so it must be handled separately.

Mark Ruzon 2009-06-15 18:53:29

close, but not quite correct. That will return true if they have something like this: A,3,4,5,6 (note 4 in a row with ace). If you look at my most recent answer, it has a variation on this which does work (basically it does that same check *after* the loop is complete since if the loop just ended and we have a count of 4, then that means we have T,J,Q,K).

Evan Teran 2009-06-15 18:58:42

I disagree. When i == 7 count will revert to 0, so it will only be 4 in the case of [~9],T,J,Q,K

Mark Ruzon 2009-06-16 00:19:58

Oh, darn, I didn't see that it was inside the for loop.

Mark Ruzon 2009-06-16 00:20:45

Thanks for the feedback here...

iwanttoprogram 2009-06-19 23:03:46

ansaurus

tags:

views:

answers:

Poker code cleanup modification from book...not quite right...

related questions