🍭 大家好这里是清隆学长 ，一枚热爱算法的程序员

✨ 本系列打算持续跟新华为OD-C/D卷的三语言AC题解

💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导

👏 感谢大家的订阅➕ 和 喜欢💗

📎在线评测链接

https://app5938.acapp.acwing.com.cn/contest/2/problem/OD1079

🌍 评测功能需要 ⇒ 订阅专栏 ⇐ 后私信联系清隆解锁～

🍓OJ题目截图

🍄 LYA的数字游戏

问题描述

LYA发明了一个有趣的数字游戏。给定一组数字，先找出其中出现次数最多的数字，称为众数。如果有多个众数，就把它们按从小到大的顺序排列，组成一个新的数组。最后，求这个新数组的中位数作为游戏的结果。

中位数的定义如下：把一组数从小到大排列，如果数的个数是奇数，那么中间那个数就是中位数；如果数的个数是偶数，那么中间两个数的平均值就是中位数。

现在，LYA给了你一组数字，请你帮她找出游戏的结果。

输入格式

输入一行，包含若干个用空格分隔的整数，表示给定的数字序列。数字个数不超过 $1000$，每个数字大于 $0$ 且小于 $1000$。

输出格式

输出一个整数，表示新数组的中位数。

样例输入1

10 11 21 19 21 17 21 16 21 18 15

样例输出1

21

样例输入2

2 1 5 4 3 3 9 2 7 4 2 15 4 2 4

样例输出2

3

样例输入3

5 1 5 3 5 2 5 5 7 6 7 3 7 11 7 55 7 9 98 9 17 9 15 9 9 1 39

样例输出3

7

数据范围

• 数字个数不超过 $1000$。
• 每个数字大于 $0$ 且小于 $1000$。

题解

首先，我们需要统计每个数字出现的次数，可以用一个哈希表来实现。然后，找出出现次数最多的数字，即为众数。如果有多个众数，就把它们按从小到大的顺序排列，组成一个新的数组。最后，求这个新数组的中位数即可。

求中位数时，如果数组长度为奇数，直接返回中间那个数；如果数组长度为偶数，返回中间两个数的平均值。

参考代码

• Python

from collections import Counter

nums = list(map(int, input().split()))
cnt = Counter(nums)
max_cnt = max(cnt.values())
modes = sorted(k for k, v in cnt.items() if v == max_cnt)

n = len(modes)
if n % 2 == 1:
    print(modes[n // 2])
else:
    print((modes[n // 2 - 1] + modes[n // 2]) // 2)

• Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] input = sc.nextLine().split(" ");
        Map<Integer, Integer> cnt = new HashMap<>();
        for (String s : input) {
            int num = Integer.parseInt(s);
            cnt.put(num, cnt.getOrDefault(num, 0) + 1);
        }
        
        int maxCnt = Collections.max(cnt.values());
        List<Integer> modes = new ArrayList<>();
        for (int num : cnt.keySet()) {
            if (cnt.get(num) == maxCnt) {
                modes.add(num);
            }
        }
        
        Collections.sort(modes);
        int n = modes.size();
        if (n % 2 == 1) {
            System.out.println(modes.get(n / 2));
        } else {
            System.out.println((modes.get(n / 2 - 1) + modes.get(n / 2)) / 2);
        }
    }
}

• Cpp

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>

using namespace std;

int main() {
    string s;
    getline(cin, s);
    
    unordered_map<int, int> cnt;
    int num = 0;
    for (char c : s) {
        if (c == ' ') {
            cnt[num]++;
            num = 0;
        } else {
            num = num * 10 + (c - '0');
        }
    }
    cnt[num]++;
    
    int maxCnt = 0;
    for (auto p : cnt) {
        maxCnt = max(maxCnt, p.second);
    }
    
    vector<int> modes;
    for (auto p : cnt) {
        if (p.second == maxCnt) {
            modes.push_back(p.first);
        }
    }
    
    sort(modes.begin(), modes.end());
    int n = modes.size();
    if (n % 2 == 1) {
        cout << modes[n / 2] << endl;
    } else {
        cout << (modes[n / 2 - 1] + modes[n / 2]) / 2 << endl;
    }
    
    return 0;
}