Best Poker Hand - Practice Coding Problems

Best Poker Hand - Problem

Poker Hand Evaluator

You're given two arrays representing a 5-card poker hand:

• ranks: An integer array where ranks[i] represents the rank of the i-th card
• suits: A character array where suits[i] represents the suit of the i-th card

Your task is to determine the best possible poker hand you can make from these 5 cards. The poker hands are ranked from best to worst as follows:

🏆 "Flush": Five cards of the same suit
🥈 "Three of a Kind": Three cards of the same rank
🥉 "Pair": Two cards of the same rank
💳 "High Card": Any single card (when no other pattern exists)

Goal: Return a string representing the best poker hand type you can form.

Note: The return values are case-sensitive and must match exactly.

Input & Output

example_1.py — Basic Three of a Kind

$ Input: ranks = [13,2,13,13,3], suits = ["c","d","c","h","d"]

› Output: "Three of a Kind"

💡 Note: We have three cards with rank 13 (three Kings), which forms a Three of a Kind - the second-best possible hand type.

example_2.py — Flush Hand

$ Input: ranks = [4,4,2,4,4], suits = ["d","d","d","d","d"]

› Output: "Flush"

💡 Note: All five cards have the same suit 'd' (diamonds), making this a Flush - the best possible hand type, even though we also have a four of a kind in ranks.

example_3.py — Simple Pair

$ Input: ranks = [10,10,2,12,9], suits = ["a","b","c","a","d"]

› Output: "Pair"

💡 Note: We have two cards with rank 10, forming a Pair. The suits are all different, so no flush is possible.

Visualization

Tap to expand

Understanding the Visualization

Count Frequencies

Scan through all 5 cards once, counting how many of each suit and rank we have

Check Flush

If we have only 1 unique suit, all cards match - that's a Flush!

Check Three of a Kind

If any rank appears 3+ times, we have Three of a Kind

Check Pair

If any rank appears 2+ times, we have at least a Pair

Key Takeaway

🎯 Key Insight: Instead of comparing every card with every other card, we count frequencies once and analyze the counts - much more efficient and easier to extend for additional hand types!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n cards to count frequencies

✓ Linear Growth

Space Complexity

O(n)

Hash maps store at most n different suits and ranks

⚡ Linearithmic Space

Constraints

ranks.length == suits.length == 5
1 ≤ ranks[i] ≤ 13
suits[i] is one of 'a', 'b', 'c', 'd'
Return values are case-sensitive

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal approach uses a hash table to count suit and rank frequencies in O(n) time with a single pass. Check for flush first (all same suit), then three of a kind (3+ same rank), then pair (2+ same rank), defaulting to High Card.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check each card against every other card multiple times
One-Pass Hash Table (Optimal)	O(n)	O(n)	Count suits and ranks simultaneously in a single pass

Brute Force (Nested Loops) — Algorithm Steps

Check all cards for flush by comparing each suit with every other suit
Check for three of a kind by comparing each rank with all other ranks
Check for pairs by comparing each rank with remaining ranks
Return the best hand found, defaulting to High Card

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Flush

Compare each suit with every other suit using nested loops

Check Three of Kind

For each rank, count matches by comparing with all other ranks

Check Pairs

Compare each rank with remaining ranks to find pairs

Code -

solution.c — C

char* bestHand(int* ranks, int ranksSize, char* suits, int suitsSize) {
    // Check for flush
    int flushCount = 0;
    for (int i = 0; i < ranksSize; i++) {
        for (int j = i + 1; j < ranksSize; j++) {
            if (suits[i] == suits[j]) {
                flushCount++;
            }
        }
    }
    if (flushCount == 10) {
        return "Flush";
    }
    
    // Check for three of a kind
    for (int i = 0; i < ranksSize; i++) {
        int count = 1;
        for (int j = 0; j < ranksSize; j++) {
            if (i != j && ranks[i] == ranks[j]) {
                count++;
            }
        }
        if (count >= 3) {
            return "Three of a Kind";
        }
    }
    
    // Check for pair
    for (int i = 0; i < ranksSize; i++) {
        for (int j = i + 1; j < ranksSize; j++) {
            if (ranks[i] == ranks[j]) {
                return "Pair";
            }
        }
    }
    
    return "High Card";
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple nested loops checking each card against others

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for counting, no additional data structures

✓ Linear Space

Constraints

ranks.length == suits.length == 5
1 ≤ ranks[i] ≤ 13
suits[i] is one of 'a', 'b', 'c', 'd'
Return values are case-sensitive

28.7K Views

Medium Frequency

~12 min Avg. Time

845 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler