华为OD机试11月24日

以下是解题分享, 仅供参考.

1. 给人排队 按照身高顺序排队, 身高一样, 就按照体重排队. 输出排队后的序号(序号从1开始).

参考牛客网题目1第十题：t10

---

2. 求公共面积 给三个矩形(x, y, w, h), x, y是矩形左下点的坐标, w,h分别是矩阵宽和高. 求三个矩形的公共面积.
0 0 2 4
3 1 2 5
1 2 4 8

求中心线条围成的面积. 有空研究一下

3. 炸金花, 输入五组数字, 代表牌(第一个是数字, 第二个是花色), 求牌型. 不会出现相同的牌, A2345是顺子, KA234不是, 多种牌型, 输出最大牌型.
牌型1是 同花顺 
牌型2是 四张一样 + 一单
牌型3是 三张一样 + 一对
牌型4是 同花牌
牌型5是 顺子, 花色不一样
牌型6是 三张一样 + 两张单
牌型7 其他

破题思路：
利用HashMap把牌的大小分组一下，key是牌大小，value是牌大小出现次数
那么就可以得到如下五种情况：
长度等于5：①(1 1 1 1 1) ——五张不一样的牌
长度等于4：②(2 1 1 1) ——两张一样的牌，三张单排
长度等于3：③(2 2 1)、(3 1 1)——两对加一单牌，或者三张一样加两张单
长度等于2：④( 2 3 )、(4 1)——两张一样加三张一样，或者四张一样加一张单
第一种情况：可能是顺子, 可能是同花, 可能是同花顺. 在此基础上进行是不是顺子是不是同花的判断得出结果即可；
第二种情况：牌型7；
第三种情况：判断value中有没有2（牌型7）或者有没有3（牌型6）
第四种情况：判断value中有没有4（牌型2）或者有没有2或者3（牌型3）
参考代码如下：

public class Main {
    private static final HashMap<String, Integer> map = new HashMap<>();

    static {
        map.put("2", 2);
        map.put("3", 3);
        map.put("4", 4);
        map.put("5", 5);
        map.put("6", 6);
        map.put("7", 7);
        map.put("8", 8);
        map.put("9", 9);
        map.put("10", 10);
        map.put("J", 11);
        map.put("Q", 12);
        map.put("K", 13);
        map.put("A", 14);
    }

    public static void main(String[] aggs) {
        Scanner sc = new Scanner(System.in);

        List<P> list = new ArrayList<>(10);
        for (int i = 0; i < 5; i++) {
            P p = new P();
            String s = sc.nextLine().trim();
            p.size = s.substring(0, 2).trim();
            p.color = s.charAt(s.length() - 1);
            list.add(p);
        }
        // 排序
        Collections.sort(list, new Comparator<P>() {
            @Override
            public int compare(P o1, P o2) {
                return map.get(o1.size) - map.get(o2.size);
            }
        });
        Map<String, Integer> map = getMap(list);
        int size = map.size();
        if (size == 2) {
            // 2 3 或者 4 1
            int length;
            for (Map.Entry<String, Integer> entry : map.entrySet()) {
                length = entry.getValue();
                if (length == 3 || length == 2) {
                    System.out.println(3);
                    return;
                } else {
                    System.out.println(2);
                    return;
                }
            }
        } else if (size == 3) {
            // 3 1 1 或者 2 2 1
            int length;
            for (Map.Entry<String, Integer> entry : map.entrySet()) {
                length = entry.getValue();
                if (length == 3) {
                    System.out.println(6);
                    return;
                } else if (length == 2) {
                    System.out.println(7);
                    return;
                }
            }
        } else if (size == 4) {
            // 2 1 1 1
            System.out.println(7);
        } else if (size == 5) {
            // 5
            if (isStraight(list)) {
                if (isSameColor(list)) {
                    // 同花顺子
                    System.out.println(1);
                } else {
                    // 彩色顺子
                    System.out.println(5);
                }
            } else {
                if (isSameColor(list)) {
                    System.out.println(4);
                    return;
                }
                // 1 1 1 1 1
                System.out.println(7);
            }
        }
    }

    static class P {
        public String size;
        public char color;

        @Override
        public String toString() {
            return "{size: " + size + ",color:" + color + "}";
        }
    }

    public static boolean isStraight(List<P> list) {
        int cur, last = 0;
        boolean flag = false;
        // 前面四张是不是顺子
        for (int i = 0; i < 4; i++) {
            if (last == 0) {
                last = map.get(list.get(i).size);
            } else {
                cur = map.get(list.get(i).size);
                if (cur - last == 1) {
                    flag = true;
                    last = cur;
                } else {
                    return false;
                }
            }
        }

        if (flag) {
            int differ = map.get(list.get(4).size) - last;
            if (differ == 1 || differ == 9) {
                return true;
            }
        }
        return false;
    }

    public static boolean isSameColor(List<P> list) {
        char cur, last = ' ';
        boolean flag = false;
        for (int i = 0; i < 5; i++) {
            if (last == ' ') {
                last = list.get(i).color;
            } else {
                cur = list.get(i).color;
                if (cur == last) {
                    flag = true;
                } else {
                    return false;
                }
            }
        }
        if (flag) {
            return true;
        }
        return false;
    }

    // 获取重复元素个数. 如果是2, 那么牌型就是 4 1 或者2 3, 如果是3, 牌型就是2 2 1 或者3 1 1
    public static Map<String, Integer> getMap(List<P> list) {
        Map<String, Integer> map = new HashMap<>();
        for (int i = 0; i < 5; i++) {
            map.merge(list.get(i).size, 1, Integer::sum);
        }
        return map;
    }
}

over~ 如果你有更好的解题思路或者不懂的地方，请及时跟我讨论哦

喜欢就点个赞赞吧