【华为机试】挑选出扑克牌最大牌型

题目描述

给定一组扑克牌，总共有5张。每张牌有四种花色，分别是红桃、黑桃、红方片、黑麻花。每张牌可取值在【A，1，2，3，4，5，6，7，8，9，10，J，Q，K】范围内。现在给定一组判定逻辑，求出其最大牌型。

• 牌型一：五张牌连续出现，且花色相同，则称其为同花顺。注意，包含A时，只允许A，1，2，3，4和10，J，Q，K，A这两种同花顺组合，不允许出现类似于Q，K，A，1，2。
• 牌型二：如果出现四张一样大小的牌，则称其为四元。
• 牌型三：如果五张牌的花色一样，则称其为同花。
• 牌型四：如果出现五张连续的牌，则称其为顺子【tip: 要求五张牌花色不能相同，否则为同花顺】。
• 牌型五：如果出现三张相同大小的牌和另外两张相同的牌，则称其为三元二目。
• 牌型六：如果出现三张相同大小的牌和另外两张不同的牌，则称其为三元。
• 牌型七：其它组合。

---

现在用V表示红桃，B表示黑桃，N表示方片，M表示麻花。现在输入5行字符串，每行字符串包含两个字字符串，之间用空格隔开。例如：

输入：
1 N
2 N
3 N
4 N
5 N
输出：
1

要求按照输入进行解析，输出组合最大牌面【牌型越小，牌面越大】，牌面用1…7数字表示。例如，牌型一用1表示。

---

题目解析

public class Main {
    public static void main(String[] args) {
    	p3()
    }
	static void resolve() {
        Map<String, Integer> map = new HashMap<>();
        map.put("J", 11);
        map.put("Q", 12);
        map.put("K", 13);
        Map<Integer, List<String>> cardMap = new HashMap<>();
        Scanner in = new Scanner(System.in);
        boolean hasA = Boolean.FALSE;
        for (int i = 0; i < 5; ++i) {
            String[] split = in.nextLine().split(" ");
            String s1 = split[0];
            String s2 = split[1];
            if (s1.equals("A")) {
                hasA = Boolean.TRUE;
                if (cardMap.containsKey(1) && cardMap.containsKey(14)) {
                    cardMap.get(1).add(s2);
                    cardMap.get(14).add(s2);
                    continue;
                }
                if (cardMap.containsKey(1) && !cardMap.containsKey(14)) {
                    cardMap.get(1).add(s2);
                    List<String> list = new ArrayList<>();
                    list.add(s2);
                    cardMap.put(14, list);
                    continue;
                }
                if (!cardMap.containsKey(1) && cardMap.containsKey(14)) {
                    cardMap.get(14).add(s2);
                    List<String> list = new ArrayList<>();
                    list.add(s2);
                    cardMap.put(1, list);
                    continue;
                }
                List<String> list1 = new ArrayList<>();
                list1.add(s2);
                List<String> list2 = new ArrayList<>();
                list2.add(s2);
                cardMap.put(1, list1);
                cardMap.put(14, list2);
                continue;
            }
            if (map.containsKey(s1)) {
                Integer key = map.get(s1);
                if (cardMap.containsKey(key)) {
                    cardMap.get(key).add(s2);
                } else {
                    List<String> list = new ArrayList<>();
                    list.add(s2);
                    cardMap.put(key, list);
                }
                continue;
            }
            int key = Integer.parseInt(s1);
            if (cardMap.containsKey(key)) {
                cardMap.get(key).add(s2);
            } else {
                List<String> list = new ArrayList<>();
                list.add(s2);
                cardMap.put(key, list);
            }
        }
        in.close();
        // 判断牌型
        // 同花顺 5 1 同花 5 4 顺子 5 5 其它 5 7
        // 四条 2 2 葫芦 2 3
        // 三条 3 6
        int res = 7;
        int len = cardMap.size();
        if (hasA) len -= 1;
        if (len == 3) {
            res = Math.min(res, 6);
        }
        if (len == 2) {
            for (Map.Entry<Integer, List<String>> item : cardMap.entrySet()) {
                int size = item.getValue().size();
                if (size == 1 || size == 4) {
                    res = Math.min(res, 2);
                } else {
                    res = Math.min(res, 3);
                }
            }
        }
        if (len == 5) {
            Boolean shunzi;
            // 判断是不是顺子
            List<Integer> collect = cardMap.keySet().stream().sorted().collect(Collectors.toList());
            if (hasA) {
                List<Integer> integers1 = collect.subList(0, 5);
                List<Integer> integers2 = collect.subList(1, 6);
                int i1 = integers1.get(4) - integers1.get(0);
                int i2 = integers2.get(4) - integers2.get(0);
                shunzi = i1 == 4 || i2 == 4;
            } else {
                int i = collect.get(4) - collect.get(0);
                shunzi = i == 4;
            }
            if (shunzi) res = Math.min(res, 5);
            // 判断是不是同花
            boolean tonghua = Boolean.FALSE;
            Set<String> set = new HashSet<>();
            cardMap.values().forEach(set::addAll);
            if (set.size() == 1){
                tonghua = true;
            }
            if (tonghua) {
                res = Math.min(res, 4);
            }
            if (tonghua && shunzi) {
                res = Math.min(res, 1);
            }
        }
        System.out.println(res);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

---

不算太难的一个题，其实解析就在代码中，看看就明白了。