Best Poker Hand - Practice Coding Problems

Best Poker Hand - Problem

You are given an integer array ranks and a character array suits. You have 5 cards where the i-th card has a rank of ranks[i] and a suit of suits[i].

The following are the types of poker hands you can make from best to worst:

"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.

Return a string representing the best type of poker hand you can make with the given cards.

Note that the return values are case-sensitive.

Input & Output

Example 1 — Three of a Kind

$ Input: ranks = [13,2,10,10,10], suits = ["a","a","b","c","a"]

› Output: "Three of a Kind"

💡 Note: Three cards have rank 10, which gives us Three of a Kind (better than checking for flush or pair)

Example 2 — Flush

$ Input: ranks = [4,4,11,9,7], suits = ["d","d","d","d","d"]

› Output: "Flush"

💡 Note: All five cards have the same suit 'd', so we have a Flush (best possible hand in this problem)

Example 3 — Pair

$ Input: ranks = [10,10,5,3,1], suits = ["a","b","c","d","e"]

› Output: "Pair"

💡 Note: Two cards have rank 10. No flush (all different suits), no three of a kind, so we have a Pair

Constraints

ranks.length == suits.length == 5
1 ≤ ranks[i] ≤ 13
suits[i] ∈ {'a', 'b', 'c', 'd'}

Visualization

Tap to expand

Understanding the Visualization

Input Cards

5 cards with ranks and suits

Count Frequencies

Count suits for flush, ranks for pairs/three of a kind

Classify Hand

Return best hand type based on counts

Key Takeaway

🎯 Key Insight: Count frequencies and check hand types in order of precedence: Flush → Three of a Kind → Pair → High Card

Asked in

G Google 15 a Amazon 12

The key insight is to count occurrences of suits and ranks, then check in order of hand precedence: Flush → Three of a Kind → Pair → High Card. Best approach uses frequency counting in a single pass. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Check	O(1)	O(1)	Check each hand type individually with separate loops
Optimized Frequency Count	O(1)	O(1)	Single pass to count suits and ranks simultaneously

Brute Force Check — Algorithm Steps

Step 1: Check all suits for flush
Step 2: Count each rank occurrence
Step 3: Find highest count for classification

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Suits

Compare all suits for flush

Count Ranks

Count occurrences of each rank

Classify

Return best hand type found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* solution(int* ranks, char* suits, int size) {
    // Check for flush - all same suit
    char firstSuit = suits[0];
    int isFlush = 1;
    for (int i = 0; i < size; i++) {
        if (suits[i] != firstSuit) {
            isFlush = 0;
            break;
        }
    }
    
    if (isFlush) {
        char* result = malloc(6);
        strcpy(result, "Flush");
        return result;
    }
    
    // Count rank occurrences (assuming ranks 1-13)
    int rankCounts[14] = {0};
    for (int i = 0; i < size; i++) {
        rankCounts[ranks[i]]++;
    }
    
    int maxCount = 0;
    for (int i = 0; i < 14; i++) {
        if (rankCounts[i] > maxCount) {
            maxCount = rankCounts[i];
        }
    }
    
    char* result = malloc(15);
    if (maxCount >= 3) {
        strcpy(result, "Three of a Kind");
    } else if (maxCount == 2) {
        strcpy(result, "Pair");
    } else {
        strcpy(result, "High Card");
    }
    
    return result;
}

int main() {
    int ranks[5];
    char suits[5];
    
    // Simple parsing for fixed size arrays
    scanf("%d,%d,%d,%d,%d]", &ranks[0], &ranks[1], &ranks[2], &ranks[3], &ranks[4]);
    scanf("[\"%c\",\"%c\",\"%c\",\"%c\",\"%c\"]", &suits[0], &suits[1], &suits[2], &suits[3], &suits[4]);
    
    char* result = solution(ranks, suits, 5);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Always process exactly 5 cards, constant operations

✓ Linear Growth

Space Complexity

O(1)

Only use variables for counting, no extra data structures

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler