The first test for a hand of five cards is the straight, specifically an Ace-high straight followed by a standard straight. To perform this test, I’ve concocted a special version of the program, one that has a set of pre-drawn poker hands.
\n
\nThe reason for presetting the poker hands is that random draws would take too long to test the code. It’s possible, of course, but it’s far more efficient to manually create an array of poker hands with positives and negatives and run test functions on those.<\/p>\n
You can view the full source code for this week’s Lesson on Github: click here<\/a>.<\/p>\n From last week’s Lesson<\/a>, I’ve updated the main()<\/em> function to contain an array of 6 (set by the defined constant The cards in the The function returns The first if<\/em> test is a complex logical construction that checks for the condition: Ace, 10, Jack, Queen, King — an Ace-high straight. Remember, in my playing_card<\/em> structure, the Ace is the lowest valued card, 1.<\/p>\n The second clutch of if<\/em> tests determine the sequential value for each card. Remember: They’re sorted. So if the first card, Two straights are preset in the Hand 6 is a straight, but it looks awkward because the Ace is shown low. A correction could be made later in the code, or the code could present the hands as randomly drawn and internally sort itself. This change is made later in the program’s development.<\/p>\n In next week’s Lesson<\/a>, the code is updated to check for a flush and straight flush.<\/p>\n","protected":false},"excerpt":{"rendered":" Test the straight()<\/em> function to see whether it can detect a straight draw in a hand of cards. Continue reading HANDS<\/code>) preset playing_card<\/em> structures:<\/p>\n\r\nstruct playing_card hand[HANDS][HAND_SIZE] = {\r\n { { DIAMONDS, \"5\", 5 }, { SPADES, \"5\", 5 }, { DIAMONDS, \"6\", 6 }, { DIAMONDS, \"9\", 9 }, { HEARTS, \"9\", 9 } },\r\n { { SPADES, \"4\", 4 }, { HEARTS, \"6\", 6 }, { CLUBS, \"6\", 6 }, { HEARTS, \"7\", 7 }, { DIAMONDS, \"10\", 10 } },\r\n { { SPADES, \"6\", 6 }, { CLUBS, \"7\", 7 }, { HEARTS, \"7\", 7 }, { HEARTS, \"9\", 9 }, { DIAMONDS, \"J\", 11 } },\r\n { { HEARTS, \"4\", 4 }, { CLUBS, \"5\", 5 }, { DIAMONDS, \"6\", 6}, { CLUBS, \"7\", 7 }, { SPADES, \"8\", 8 } },\r\n { { HEARTS, \"A\", 1 }, { HEARTS, \"3\", 3 }, { DIAMONDS, \"7\", 7 }, { CLUBS, \"K\", 13 }, { HEARTS, \"K\", 13 } },\r\n { { DIAMONDS, \"A\", 1 }, { CLUBS, \"10\", 10 }, { CLUBS, \"J\", 11 }, { HEARTS, \"Q\", 12 }, { CLUBS, \"K\", 13 } }\r\n};<\/pre>\nhand[]<\/code> array are pre-sorted, so the code need not sort them. Instead, the main()<\/em> function outputs each hand, then calls the straight()<\/em> function:<\/p>\nr = straight(hand[x]);<\/code><\/p>\nTRUE<\/code> or FALSE<\/code> (defined in the code) based on its evaluation. Here is the straight()<\/em> function:<\/p>\n\r\n\/* Determine a straight draw *\/<\/span>\r\n \/* This function assumes the HAND_SIZE is fixed at 5 *\/<\/span>\r\nint straight(struct playing_card p[])\r\n{\r\n \/* straight, ace high *\/<\/span>\r\n if( p[0].value==1 && p[1].value==10 && p[2].value==11 && p[3].value==12 && p[4].value==13 )\r\n return(TRUE);\r\n\r\n \/* other straight *\/<\/span>\r\n if( p[0].value != p[1].value-1 )\r\n return(FALSE);\r\n if( p[1].value != p[2].value-1 )\r\n return(FALSE);\r\n if( p[2].value != p[3].value-1 )\r\n return(FALSE);\r\n if( p[3].value != p[4].value-1 )\r\n return(FALSE);\r\n\r\n return(TRUE);\r\n}<\/pre>\np[0]<\/code>, is one less than the second card, p[1]<\/code>, the testing continues. Each successive card is tested until the fourth, p[3]<\/code>, is compared with the fifth, p[4]<\/code>. When all the tests pass, the hand is a straight.<\/p>\nhand[]<\/code> array to test the function’s accuracy. Here’s a sample run:<\/p>\nHand 1: 5♥ 5♠ 6♥ 9♥ 9♣
\nHand 2: 4♠ 6♣ 6♦ 7♣ 10♥
\nHand 3: 6♠ 7♦ 7♣ 9♣ J♥
\nHand 4: 4♣ 5♦ 6♥ 7♦ 8♠ - Straight
\nHand 5: A♣ 3♣ 7♥ K♦ K♣
\nHand 6: A♥ 10♦ J♦ Q♣ K♦ - Straight<\/code><\/p>\n