(华为机试）扑克牌大小

扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A、2各4张，小王1张，大王1张。
牌面从小到大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）：
3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER
输入两手牌，两手牌之间用"-“连接，每手牌的每张牌以空格分隔，”-"两边没有空格，如：4 4 4 4-joker JOKER。
请比较两手牌大小，输出较大的牌，如果不存在比较关系则输出ERROR。

基本规则：
（1）输入每手牌可能是个子、对子、顺子（连续5张）、三个、炸弹（四个）和对王中的一种，不存在其他情况，
由输入保证两手牌都是合法的，顺子已经从小到大排列；
（2）除了炸弹和对王可以和所有牌比较之外，其他类型的牌只能跟相同类型的存在比较关系
（如，对子跟对子比较，三个跟三个比较），不考虑拆牌情况（如：将对子拆分成个子）；
（3）大小规则跟大家平时了解的常见规则相同，个子、对子、三个比较牌面大小；顺子比较最小牌大小；
炸弹大于前面所有的牌，炸弹之间比较牌面大小；对王是最大的牌；
（4）输入的两手牌不会出现相等的情况。
答案提示：
（1）除了炸弹和对王之外，其他必须同类型比较。
（2）输入已经保证合法性，不用检查输入是否是合法的牌。
（3）输入的顺子已经经过从小到大排序，因此不用再排序了.
输入描述：
输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如4 4 4 4-joker JOKER。
输出描述：
输出两手牌中较大的那手，不含连接符，扑克牌顺序不变，仍以空格隔开；如果不存在比较关系则输出ERROR。
示例1

输入例子：
4 4 4 4-joker JOKER
输出例子：
joker JOKER

> 标准答案

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
class compare
{
public:
	string GetBig(const string str)
	{
		string result;
		string s1, s2;
		string comper("3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER");
		//当有大小王时候，一定是大小王最大
		if (str.find("joker JOKER")!=string::npos)
		{
			result = "joker JOKER";
			return result;
		}

		//将两副牌分开,存于不同的string中
		int mid = str.find('-');
		s1 = str.substr(0, mid);
		s2 = str.substr(mid + 1);

		//得到两副牌的' '数量，以此判断是否为相同类型。注意不能使用长度判断，会因为joker产生bug
		int s1_count = count(s1.begin(), s1.end(), ' ');
		int s2_count = count(s2.begin(), s2.end(), ' ');

		//两副牌为相同的类型，比较最小的大小即可
		if (s1_count == s2_count)
		{
			//得到最小的的牌
			string s1_first = s1.substr(0, s1.find(' '));
			string s2_first = s2.substr(0, s2.find(' '));
			
			if (comper.find(s1_first) < comper.find(s2_first))
			{
				result = s2;
				return result;
			}
			else
			{
				result = s1;
				return result;
			}
		}

		//两副牌不相同，有炸弹或者不符合条件
		else
		{
			if (s1_count == 3 && s1[0] == s1[2] && s1[2]== s1[4] && s1[4]== s1[6])
			{
				result = s1;
			}
			else if (s2_count == 3 && s2[0] == s2[2] && s1[2] == s2[4] && s2[4] == s2[6])
			{
				result = s2;
			}
			else
				result = "ERROR";
			return result;
		}
	}
};
int main()
{
	string str;
	compare c;
	while(getline(cin, str))
	{
		str = c.GetBig(str);
		cout << str<<endl;
	}
	return 0;
}

> 我的答案

#include <iostream>
#include <string>

using namespace std;

string judge(string p1,string p2);

int get_kind(string &p);

int main() {
    string p1,p2,tmp;
    int count = 1;
    //输入
	while (cin >> tmp) {
		if(count == 1){
            auto it = tmp.find('-');
            if(it == string::npos){
                p1 += tmp;
            }
            else{
                p1 += tmp.substr(0,it-1);
                p2 += tmp.substr(it+1);
                count++;
            }
        }
        else{
            p2 += tmp;
        }
	}
    //比较p1 p2的大小
    string res = judge(p1,p2);
    cout << res;
	return 0;
}
//得到权重 并把字符转为对应的十六进制
int get_kind(string &p){
    int len = p.size();
    int kind =0;
    if(len == 1){
        kind = 1;
    }
    else if(len == 2){
        if(p[0] == '1'){
            kind = 1;
            //p[0] = 'A';
        }
        else{
            kind = 2;
        }
    }
    else if(len == 3){
        kind = 3;
    }
    else if(len == 4){
        if(p[0] == '1'){
            kind = 2;
        }
        kind = 5;
    }
    else if(len == 5){
        kind = 4;
    }
    else if(len == 6){
        if(p[0] == '1' && p[2] == '1'){
            kind = 3;
        }
        else{
            kind = 4;
        }
    }
    else if(len == 8){
        kind = 5;
    }

    //修改16进制
    if(p[0] == '1'){
        p[0] = 'A';
    }
    else if(p[0] == 'A'){
        p[0] = 'L';
    }
    else if(p[0] == '2'){
        p[0] = 'M';
    }
    return kind;
}

string judge(string p1,string p2){
    int len1 = p1.size();
    int len2 = p2.size();
    if(len1 > 8) return p1;
    if(len2 > 8) return p2;
    int kind1 = get_kind(p1);
    int kind2 = get_kind(p2);
    // kind = 1：单牌 2：对牌 3：三张 4：顺子 5：炸弹
    char num1,num2;
    if(kind1 == 5 && kind2 == 5){
        return p1[0] > p2[0] ? p1:p2;
    }
    if(kind1 == 5 || kind2 == 5){
        return kind1 == 5 ? p1:p2;
    }
    if(kind1 != kind2) return "ERROR";
    //同类型比较
    return p1[0] > p2[0] ? p1:p2;
}