题解 | #扑克牌大小#

/*****************************************
 3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
基本规则：
（1）输入每手牌可能是个子、对子、顺子（连续5张）、三个、炸弹（四个）和对王中的一种，不存在其他情况，由输入保证两手牌都是合法的，顺子已经从小到大排列；
（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系（如，对子跟对子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）；
（3）大小规则跟大家平时了解的常见规则相同，个子、对子、三个比较牌面大小；顺子比较最小牌大小；炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；

（4）输入的两手牌不会出现相等的情况。

 数据范围：字符串长度：3≤s≤10
*/

#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;

#define ERROR_POKER 9999
enum {
    ERR_TYPE = 0,
    SINGLE,
    PAIRS,
    THREE,
    STRAIGHT,
    BOOM,
    ROCKET
};

map<string, int> poker = {
    {"3", 3},
    {"4", 4},
    {"5", 5},
    {"6", 6},
    {"7", 7},
    {"8", 8},
    {"9", 9},
    {"10", 10},
    {"J", 11},
    {"Q", 12},
    {"K", 13},
    {"A", 14},
    {"2", 15},
    {"joker", 16},
    {"JOKER", 17}
};

int GetPokerType(vector<string>& v) {
    size_t len = v.size();

    switch (len) {
        case 1:
            return SINGLE;
        case 2:
            if (v[0] == v[1]) {
                return PAIRS;
            } else
                return ROCKET;
        case 3:
            return THREE;
        case 4:
            return BOOM;
        case 5:
            return STRAIGHT;
        default:
            return ERR_TYPE;
    }
}

void GetPoker(string s, vector<string>& p1, vector<string>& p2) {
    size_t off = s.find('-');
    string s1, s2;

    s1 = s.substr(0, off);
    s2 = s.substr(off + 1);

    while (1) {
        size_t i = s1.find(' ');
        string tmp;

        if (i == string::npos) {
            tmp = s1.substr(0);
            p1.push_back(tmp);
            break;
        }

        tmp = s1.substr(0, i);
        p1.push_back(tmp);
        s1 = s1.substr(i + 1);
    }

    while (1) {
        size_t i = s2.find(' ');
        string tmp;

        if (i == string::npos) {
            tmp = s2.substr(0);
            p2.push_back(tmp);
            break;
        }

        tmp = s2.substr(0, i);
        p2.push_back(tmp);
        s2 = s2.substr(i + 1);
    }
}

int PokerCmp(vector<string>& p1, vector<string>& p2) {
    int type1, type2;

    type1 = GetPokerType(p1);
    type2 = GetPokerType(p2);

    if (type1 == type2) {
        switch (type1) {
            case SINGLE:
            case PAIRS:
            case THREE:
            case BOOM:
            case STRAIGHT:
                return poker[p1[0]] - poker[p2[0]];

            case ROCKET:
                return 0;
            default:
                return ERROR_POKER;
        }
    }

    if (type1 != type2) {
        if (type1 >= BOOM || type2 >= BOOM) {
            return type1 - type2;
        } else {
            return ERROR_POKER;
        }
    }

    return ERROR_POKER;
}

void display(vector<string> p) {
    for (auto it : p) {
        cout << it << " ";
    }

    cout << endl;
}

int main() {
    string s;
    vector<string> p1, p2;

    while (getline(cin, s, '\n')) {
        p1.clear();
        p2.clear();
        GetPoker(s, p1, p2);
        int result = PokerCmp(p1, p2);
        if (result < 0) {
            display(p2);
        } else if (result == ERROR_POKER) {
            cout << "ERROR" << endl;
        } else {
            display(p1);
        }
    }
}