C++ 扑克牌组合判定程序实现及代码解析

题目描述

在这个挑战中，您必须确定一副五张牌中存在哪种扑克组合。每张卡片都是一个包含卡片值的字符串（正面卡片的首字母大写）和花色的小写首字母，如下例所示：

'Ah' ➞ A of 红桃 'Ks' ➞ K of 黑桃 '3d' ➞ 3 of 方块 'Qc' ➞ Q of 梅花

有 10 种不同的组合。以下列表按重要性降序排列：

Royal Flush A、K、Q、J、10，都同一套花色。
Straight Flush 五张牌依次排列，花色相同。
Four of a Kind 四张相同等级的牌。
Full House 三对一对。
Flush 任何五张相同花色的牌，不按顺序。
Straight 连续五张牌，但花色不同。
Three of a Kind 三张相同等级的牌。
Two Pair 两个不同的对。
Pair 两张相同等级的牌。
High Card 没有其他有效组合。

给定一个 hand 包含五个字符串作为卡片的列表，根据上表实现一个函数，该函数返回一个字符串，该字符串具有获得的最高组合的名称。

输入输出格式

输入格式

第一行有 5 个字符串，表示五个字符串卡片的数组；

输出格式

一行输出字符串，表示具有获得的最高组合的名称。

输入输出样例 1

输入

10h Jh Qh Ah Kh

输出

Royal Flush

代码实现

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using namespace std;

struct Card {
    char rank;
    char suit;
};

bool isStraightFlush(vector<Card> hand) {
    sort(hand.begin(), hand.end(), [](const Card& a, const Card& b) {
        return a.rank < b.rank;
    });
    char suit = hand[0].suit;
    for (int i = 1; i < 5; i++) {
        if (hand[i].suit != suit || hand[i].rank != hand[i - 1].rank + 1) {
            return false;
        }
    }
    return true;
}

bool isFourOfAKind(vector<Card> hand) {
    sort(hand.begin(), hand.end(), [](const Card& a, const Card& b) {
        return a.rank < b.rank;
    });
    if (hand[0].rank == hand[1].rank && hand[1].rank == hand[2].rank && hand[2].rank == hand[3].rank) {
        return true;
    }
    if (hand[1].rank == hand[2].rank && hand[2].rank == hand[3].rank && hand[3].rank == hand[4].rank) {
        return true;
    }
    return false;
}

bool isFullHouse(vector<Card> hand) {
    sort(hand.begin(), hand.end(), [](const Card& a, const Card& b) {
        return a.rank < b.rank;
    });
    if (hand[0].rank == hand[1].rank && hand[1].rank == hand[2].rank && hand[3].rank == hand[4].rank) {
        return true;
    }
    if (hand[0].rank == hand[1].rank && hand[2].rank == hand[3].rank && hand[3].rank == hand[4].rank) {
        return true;
    }
    return false;
}

bool isFlush(vector<Card> hand) {
    char suit = hand[0].suit;
    for (int i = 1; i < 5; i++) {
        if (hand[i].suit != suit) {
            return false;
        }
    }
    return true;
}

bool isStraight(vector<Card> hand) {
    sort(hand.begin(), hand.end(), [](const Card& a, const Card& b) {
        return a.rank < b.rank;
    });
    for (int i = 1; i < 5; i++) {
        if (hand[i].rank != hand[i - 1].rank + 1) {
            return false;
        }
    }
    return true;
}

bool isThreeOfAKind(vector<Card> hand) {
    sort(hand.begin(), hand.end(), [](const Card& a, const Card& b) {
        return a.rank < b.rank;
    });
    if (hand[0].rank == hand[1].rank && hand[1].rank == hand[2].rank) {
        return true;
    }
    if (hand[1].rank == hand[2].rank && hand[2].rank == hand[3].rank) {
        return true;
    }
    if (hand[2].rank == hand[3].rank && hand[3].rank == hand[4].rank) {
        return true;
    }
    return false;
}

bool isTwoPair(vector<Card> hand) {
    sort(hand.begin(), hand.end(), [](const Card& a, const Card& b) {
        return a.rank < b.rank;
    });
    if (hand[0].rank == hand[1].rank && hand[2].rank == hand[3].rank) {
        return true;
    }
    if (hand[0].rank == hand[1].rank && hand[3].rank == hand[4].rank) {
        return true;
    }
    if (hand[1].rank == hand[2].rank && hand[3].rank == hand[4].rank) {
        return true;
    }
    return false;
}

bool isPair(vector<Card> hand) {
    sort(hand.begin(), hand.end(), [](const Card& a, const Card& b) {
        return a.rank < b.rank;
    });
    if (hand[0].rank == hand[1].rank) {
        return true;
    }
    if (hand[1].rank == hand[2].rank) {
        return true;
    }
    if (hand[2].rank == hand[3].rank) {
        return true;
    }
    if (hand[3].rank == hand[4].rank) {
        return true;
    }
    return false;
}

string getPokerHand(vector<Card> hand) {
    if (isStraightFlush(hand)) {
        return "Straight Flush";
    }
    if (isFourOfAKind(hand)) {
        return "Four of a Kind";
    }
    if (isFullHouse(hand)) {
        return "Full House";
    }
    if (isFlush(hand)) {
        return "Flush";
    }
    if (isStraight(hand)) {
        return "Straight";
    }
    if (isThreeOfAKind(hand)) {
        return "Three of a Kind";
    }
    if (isTwoPair(hand)) {
        return "Two Pair";
    }
    if (isPair(hand)) {
        return "Pair";
    }
    return "High Card";
}

int main() {
    vector<Card> hand(5);
    for (int i = 0; i < 5; i++) {
        cin >> hand[i].rank >> hand[i].suit;
    }
    cout << getPokerHand(hand) << endl;
    return 0;
}

代码解析

结构体定义: 定义 Card 结构体，用于存储每张牌的等级和花色信息。
判断函数: 针对每种牌型，分别定义了相应的判断函数，函数名与牌型名称一致。
排序: 每个判断函数中首先使用 sort() 函数对牌面进行排序，方便后续判断。
判断逻辑: 每个判断函数根据牌型的定义，通过对牌面和花色进行逻辑判断，最终返回布尔值，表示是否满足该牌型。
getPokerHand() 函数: 该函数接收一个 Card 数组作为参数，按照牌型的重要程度依次判断，一旦满足某个牌型，就返回该牌型的名称，否则继续判断下一个牌型。
主函数: 从标准输入获取五个字符串表示的卡片信息，将其存储到 Card 数组中，然后调用 getPokerHand() 函数判断并输出结果。

运行示例

输入: 10h Jh Qh Ah Kh
输出: Royal Flush

输入: 2d 3d 4d 5d 6d
输出: Straight Flush

输入: 2h 2d 2s 2c 5d
输出: Four of a Kind

输入: 2h 2d 2s 5d 5c
输出: Full House

输入: 2h 3h 4h 5h 6h
输出: Flush

输入: 2h 3d 4s 5c 6h
输出: Straight

输入: 2h 2d 2s 7d 8c
输出: Three of a Kind

输入: 2h 2d 5d 5c 9h
输出: Two Pair

输入: 2h 2d 7d 8c 9h
输出: Pair

输入: 2h 3d 5s 7c 9h
输出: High Card

总结

本程序通过 C++ 代码实现了扑克牌组合的判定功能，并对代码逻辑进行了详细的解释，方便理解和学习。程序逻辑清晰，易于扩展，可以作为学习 C++ 数据结构和算法的参考案例。