Introduction

A simple poker-hand evaluator does not need fancy lookup tables or bit tricks. For a five-card hand, the most direct algorithm is to count card ranks, check whether all suits match, check whether the ranks form a straight, and then classify the hand in descending order.

Represent the hand in a useful way

For a basic evaluator, it helps to represent each card as a rank and a suit. Then you can derive two structures:

• a frequency count of ranks
• a list of suits

Those two pieces of information are enough to identify all standard five-card hand categories.

1from collections import Counter
2
3hand = ["AS", "KS", "QS", "JS", "TS"]
4ranks = [card[0] for card in hand]
5suits = [card[1] for card in hand]
6
7print(Counter(ranks))
8print(suits)

The core classification logic

A straightforward evaluator usually checks these conditions in order:

1. straight flush
2. four of a kind
3. full house
4. flush
5. straight
6. three of a kind
7. two pair
8. one pair
9. high card

The ordering matters because some features overlap. A straight flush is both a straight and a flush, but it should be classified at the highest matching category.

A runnable simple evaluator

Here is a compact five-card evaluator in Python.

1from collections import Counter
2
3RANK_VALUES = {r: i for i, r in enumerate("23456789TJQKA", start=2)}
4
5
6def is_straight(values):
7    values = sorted(values)
8    if values == [2, 3, 4, 5, 14]:
9        return True
10    return all(values[i] + 1 == values[i + 1] for i in range(4))
11
12
13def evaluate_hand(hand):
14    ranks = [card[0] for card in hand]
15    suits = [card[1] for card in hand]
16    values = [RANK_VALUES[r] for r in ranks]
17
18    counts = sorted(Counter(ranks).values(), reverse=True)
19    flush = len(set(suits)) == 1
20    straight = is_straight(values)
21
22    if straight and flush:
23        return "Straight Flush"
24    if counts == [4, 1]:
25        return "Four of a Kind"
26    if counts == [3, 2]:
27        return "Full House"
28    if flush:
29        return "Flush"
30    if straight:
31        return "Straight"
32    if counts == [3, 1, 1]:
33        return "Three of a Kind"
34    if counts == [2, 2, 1]:
35        return "Two Pair"
36    if counts == [2, 1, 1, 1]:
37        return "One Pair"
38    return "High Card"
39
40
41print(evaluate_hand(["AS", "KS", "QS", "JS", "TS"]))
42print(evaluate_hand(["9C", "9D", "9H", "9S", "2D"]))
43print(evaluate_hand(["2H", "4H", "6H", "8H", "TH"]))

This is not the fastest evaluator, but it is easy to read and correct for five-card hands.

Why counting works so well

Rank counts tell you almost everything about duplicate-based hands. For example:

• '[4, 1] means four of a kind'
• '[3, 2] means full house'
• '[2, 2, 1] means two pair'

That makes the duplicate-based part of poker evaluation much simpler than many beginners expect.

Then you only need two additional checks:

• are all suits identical, which means flush
• are ranks consecutive, which means straight

Limits of the simple approach

A real poker engine often needs more than the category name. It also needs tie-breaking rules such as kicker comparison.

For example, two one-pair hands are not equal just because both are one pair. You still need to compare the pair rank and then the remaining cards in order.

The simple evaluator above stops at category classification. That is fine for learning and for toy programs, but not enough for full game resolution.

Common Pitfalls

A common mistake is forgetting the Ace-low straight, where A-2-3-4-5 counts as a straight. If you treat Ace only as high, that hand is misclassified.

Another issue is checking for flush or straight before checking the higher-ranking combination of straight flush. Classification order matters.

It is also easy to assume the same evaluator works unchanged for seven-card Texas Hold'em hands. Seven-card evaluation needs extra logic because you must choose the best five-card combination.

Summary

• The simplest five-card poker evaluator counts ranks and checks for flush and straight patterns.
• Evaluate categories from strongest to weakest so overlapping cases are handled correctly.
• Rank-frequency patterns make pair-based hands easy to identify.
• A simple classifier is fine for learning, but tie-breakers need extra logic.
• Seven-card poker evaluation is a different problem from basic five-card classification.