The Puzzling Quirks of Regular Expressions

  1. Acknowledgments
  2. Rights of (Wo)Man
  3. Credits
  4. Preface
  5. Quantifiers and Special Sub-Patterns
    1. Wildcard Scope
    2. Words and Sequences
    3. Endpoint Classes
    4. A Configuration Format
    5. The Human Genome
  6. Pitfalls and Sand in the Gears
    1. Catastrophic Backtracking
    2. Playing Dominoes
    3. Advanced Dominoes
    4. Sensor Art
  7. Creating Functions using Regexen
    1. Reimplementing str.count()
    2. Reimplementing str.count() (stricter)
    3. Finding a Name for a Function
    4. Playing Poker (Part 1)
    5. Playing Poker (Part 2)
    6. Playing Poker (Part 3)
    7. Playing Poker (Part 4)
    8. Playing Poker (Part 5)
  8. Easy, Difficult, and Impossible Tasks
    1. Identifying Equal Counts
    2. Matching Before Duplicate Words
    3. Testing an IPv4 Address
    4. Matching a Numeric Sequence
    5. Matching the Fibonacci Sequence
    6. Matching the Prime Numbers
    7. Matching Relative Prime Numbers

Support the author!
Lulu Editions
Paypal Donation
Other Publications

Playing Poker (Part 2)

In the last puzzle, you converted “poker hands” from ASCII to Unicode suit symbols, and you also made sure that hands are listed in canonical descending card order.

For this puzzle, you want to start using regular expressions to figure out whether hands belong to various kinds. Here’s an obvious trick we can use as a shortcut:

def is_straight_flush(hand):
    return is_straight(hand) and is_flush(hand)

For this puzzle, you wish to write the functions is_flush(hand) and is_straight(hand), continuing with the assumption that hands are represented in the same manner as the last puzzle (including the cards being in descending order). Feel free to use the prettify() function you wrote if it makes entering test cases easier.

Before you turn the page…

Large buildings are built from small bricks.

Identifying a flush is somewhat easier. Moreover, if we are clever, we can add two features to the function not specifically required in the puzzle. We can make it work identically with the ASCII codes like ‘S’ for spaces and ‘H’ for hearts simultaneously with the Unicode special symbols.

But while we are creating the function, we can also return extra “truthy” information in the return value. Namely, if it is a flush, let’s return the suit also.

>>> def is_flush(hand):
...     match ='^.(.)(.*\1){4}$', hand)
...     return if match else False

>>> is_flush('J♣ T♣ 9♣ 8♣ 7♣')
>>> is_flush('J♦ 9♦ 6♦ 5♦ 2♦')
>>> is_flush('J♦ 9♥ 6♦ 5♦ 2♦')
>>> is_flush('JD 9H 6D 5D 2D')
>>> is_flush('JD 9D 6D 5D 2D')

For checking for straights, let’s add a similar bit of extra information in the return value. Obviously, if the hand is not a straight, we should return False. But if it is one, we can return the high card number for later use. Those are all “truthy” values (like all strings).

>>> def is_straight(hand):
...     pat = r'[ SHDC\u2660\u2665\u2666\u2663]'
...     h = re.sub(pat, '', hand)
...     match =, 'AKQJT98765432') 
...     return h[0] if match else False

As with the first function, we might as well be friendly in accepting the ASCII version of suits, even though they could always be improved with prettify() if necessary. The pattern looks for everything that is a suit character or a space, and strips it out to create a simplified “hand.”

With the simplified hand of just “numbers,” we know that any straight must be a substring of the run of all numbers. We do not check again that the length is 5, trusting that other functions have validated this. We could easily add that if we wanted, of course.

At this point, you might consider a richer implementation of is_straight_flush(). Perhaps this:

>>> def is_straight_flush(hand):
...     s = is_straight(hand)
...     f = is_flush(hand)
...     return s+f if s and f else False

>>> is_straight_flush('JD TD 9D 8D 7D')
>>> is_straight_flush('JD TD 9H 8D 7D')