题目
公司某部门软件教导团正在组织新员工每日打卡学习活动，他们开展这项学习活动已经一个月了，所以想统计下这个月优秀的打卡员工。每个员工会对应一个id，每天的打卡记录记录当天打卡员工的id集合，一共30天。请你实现代码帮助统计出打卡次数top5的员工。加入打卡次数相同，将较早参与打卡的员工排在前面，如果开始参与打卡的时间还是一样，将id较小的员工排在前面。注：不考虑并列的情况，按规则返回前5名员工的id即可，如果当月打卡的员工少于5个，按规则排序返回所有有打卡记录的员工id

输入描述
第一行输入为新员工数量N，表示新员工编号id为0到N-1，N的范围为[1,100]

第二行输入为30个整数，表示每天打卡的员工数量，每天至少有1名员工打卡。

之后30行为每天打卡的员工id集合，id不会重复。

输出描述
按顺序输出打卡top5员工的id，用空格隔开

用例
用例一：
 

输入：
11
4 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2
0 1 7 10
0 1 6 10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
6 10
7 10
输出：
10 0 1 7 6

用例二：
 

输入：
7
6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
输出：
0 1 2 3 4

用例三：
 

输入：
2
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
0 1
0 1
输出：
1 0

python解法
解题思路：

输入数据：

第一个输入是员工的总人数 n。第二个输入是员工的出勤情况，每个员工有一个唯一的 ID。接下来，输入 30 天的员工登录数据，每一天登录的员工 ID 被记录在一个列表中。统计每个员工的出勤天数：

对于每一天的登录记录，遍历每个登录的员工 ID，统计他们的出勤天数。如果员工 ID 是第一次出现，则记录下这个员工的出勤天数为 1，同时记录下第一次出勤的天数。排序：

根据出勤天数排序，首先按照出勤天数（从多到少）排序，若出勤天数相同，则按照第一次出勤的天数排序（从早到晚），如果还相同，则按照员工 ID 排序（从小到大）。输出前 5 名员工的 ID：

最后，返回排名前 5 的员工 ID，按要求输出。

# 输入员工人数
n = int(input())
# 输入员工的出勤情况（员工 ID 列表）
attendance = list(map(int, input().split()))
# 输入每天的登录员工记录（30天的登录数据）
logins = []
for _ in range(30):
    logins.append(list(map(int, input().split())))
# 定义一个函数来找出出勤最多的前五名员工
def find_top(logins):
    # 存储每个员工的出勤信息
    workers_data = {}
    # 遍历每一天的登录记录
    for day_idx in range(len(logins)):
        daily_ids = logins[day_idx]
        for emp_id in daily_ids:
            # 如果员工已经存在于字典中，更新出勤天数
            if emp_id in workers_data:
                workers_data[emp_id]["attended_days"] += 1
            # 如果员工是第一次出现，初始化出勤天数，并记录第一次出勤的天数
            else:
                workers_data[emp_id] = {
                    'attended_days': 1,
                    'first_day': day_idx
                }
    # 将员工的出勤数据转化为元组列表，格式为 (员工ID, 出勤天数, 第一次出勤的天数)
    rankings = []
    for emp_id, data in workers_data.items():
        rankings.append((emp_id, data["attended_days"], data["first_day"]))
    # 按照出勤天数（从多到少）、第一次出勤天数（从早到晚）、员工ID（从小到大）排序
    rankings.sort(key=lambda x: (-x[1], x[2], x[0]))
    # 返回前5名员工的ID，并将结果拼接为一个字符串输出
    return " ".join([str(x[0]) for x in rankings[:5]])
# 调用函数并打印结果
print(find_top(logins))

java解法
解题思路

输入数据：

第一个输入是员工的总人数 n（虽然在代码中没有直接用到）。第二个输入是一个包含 30 天数据的数组，表示每一天登录的员工人数。接下来，输入每天的员工 ID，用来记录当天哪些员工登录了。数据结构：

使用一个 TreeMap<Integer, Integer[]> 来存储每个员工的登录数据：Integer 为员工的 ID。Integer[] 数组包含两个元素：[0] 表示员工的出勤天数，[1] 表示员工第一次出勤的天数（即对应的天数索引）。数据处理：

对于每一天的登录记录，遍历员工 ID，更新该员工的出勤天数。如果是第一次登录，记录第一次出勤的天数。排序：

根据出勤天数（降序）进行排序；若出勤天数相同，则按照第一次出勤天数（升序）排序；若两者还相同，则按照员工 ID（升序）排序。输出前 5 名：

排序完成后，返回排名前 5 的员工 ID，输出结果

import java.util.*;
public class Main {
    public static void main(String[] args) {
        // 创建Scanner对象，读取输入
        Scanner sc = new Scanner(System.in);
        // 输入员工总数 n（在这题中其实没有用到）
        int n = sc.nextInt();
        // 输入每一天登录的员工数量
        int[] days = new int[30];
        for (int i = 0; i < 30; i++) {
            days[i] = sc.nextInt();
        }
        // 创建一个TreeMap存储每个员工的出勤情况
        // Key: 员工 ID, Value: [出勤天数, 第一次出勤的天数（索引）]
        Map<Integer, Integer[]> records = new TreeMap<>();
        for (int i = 0; i < 30; i++) {
            // 对每一天的登录记录进行遍历
            for (int j = 0; j < days[i]; j++) {
                // 输入当天登录的员工ID
                int id = sc.nextInt();
                
                // 如果该员工的记录不存在，初始化该员工的出勤天数为0，第一次出勤的天数为当前天数
                if (!records.containsKey(id)) {
                    records.put(id, new Integer[] {0, i});
                }
                
                // 更新员工的出勤天数
                records.get(id)[0]++;
            }
        }
        // 获取出勤最多的前五名员工，并输出
        List<Integer> top5 = getTop5(records);
        for (int i = 0; i < top5.size(); i++) {
            if (i > 0) System.out.print(" ");
            System.out.print(top5.get(i));
        }
    }
    // 根据出勤情况获取前5名员工
    public static List<Integer> getTop5(Map<Integer, Integer[]> records) {
        // 将Map转换为List，便于排序
        List<Map.Entry<Integer, Integer[]>> list = new ArrayList<>(records.entrySet());
        
        // 对List进行排序：
        // 1. 按照出勤天数降序排序
        // 2. 如果出勤天数相同，则按照第一次出勤的天数升序排序
        // 3. 如果出勤天数和第一次出勤天数都相同，则按员工ID升序排序
        list.sort((a, b) -> {
            if (b.getValue()[0].equals(a.getValue()[0])) {
                return a.getValue()[1].equals(b.getValue()[1]) ? a.getKey() - b.getKey() : a.getValue()[1] - b.getValue()[1];
            }
            return b.getValue()[0] - a.getValue()[0];
        });
        // 提取前五名员工的ID，返回一个列表
        List<Integer> result = new ArrayList<>();
        for (int i = 0; i < Math.min(5, list.size()); i++) {
            result.add(list.get(i).getKey());
        }
        return result;
    }
}

C++解法
解题思路

输入数据：

第一个输入是员工总数 n（但在此题中并未直接使用）。第二个输入是一个包含 30 天数据的数组 dailyCounts，表示每天登录的员工人数。接下来是 30 天的具体员工登录记录，每天的登录员工 ID 存储在二维数组 dailyIds 中。记录员工出勤情况：

使用 unordered_map<int, pair<int, int>> recordMap 来存储每个员工的出勤信息。int 是员工的 ID。pair<int, int> 中，first 是该员工的出勤天数，second 是员工第一次出勤的天数（索引）。更新出勤记录：

遍历每一天的登录记录，更新每个员工的出勤天数。如果是该员工第一次出勤，则记录其第一次出勤的天数。排序：

将员工的出勤数据从 unordered_map 转换为 vector<tuple<int, int, int>>，每个元素是一个包含员工 ID、出勤天数和第一次出勤天数的元组。按照以下优先顺序排序：出勤天数（降序）。如果出勤天数相同，则按照第一次出勤天数（升序）。如果两者都相同，则按照员工 ID（升序）。输出前 5 名：

排序后，输出排名前 5 的员工 ID，按要求输出。

#include <iostream>
#include <vector>
#include <unordered_map>
#include <algorithm>
#include <string>
using namespace std;
// 计算前5名的函数，输入参数为一个二维数组 dailyIds，表示每天的登录员工ID列表
string calculateTop5(const vector<vector<int>>& dailyIds) {
    // 使用unordered_map存储员工的出勤情况
    // key: 员工ID，value: pair(first: 出勤天数, second: 第一次出勤的天数索引)
    unordered_map<int, pair<int, int>> recordMap;
    // 遍历每天的员工登录情况
    for (int i = 0; i < dailyIds.size(); i++) {
        // 遍历每天的员工ID
        for (int id : dailyIds[i]) {
            // 如果员工第一次出现，初始化出勤天数为1，并记录第一次出勤的天数
            if (recordMap.find(id) == recordMap.end()) {
                recordMap[id] = { 1, i };
            }
            // 如果员工已经出现，更新该员工的出勤天数
            else {
                recordMap[id].first++;
            }
        }
    }
    // 将unordered_map转化为vector，方便排序
    vector<tuple<int, int, int>> resultList;
    for (const auto& entry : recordMap) {
        int id = entry.first;
        int count = entry.second.first;
        int day = entry.second.second;
        resultList.push_back(make_tuple(id, count, day));
    }
    // 对结果进行排序：
    // 1. 根据出勤天数（降序）排序
    // 2. 如果出勤天数相同，按第一次出勤的天数（升序）排序
    // 3. 如果两者都相同，按员工ID（升序）排序
    sort(resultList.begin(), resultList.end(), [](const tuple<int, int, int>& a, const tuple<int, int, int>& b) {
        if (get<1>(a) != get<1>(b)) {
            return get<1>(a) > get<1>(b);  // 出勤天数多的排前面
        }
        else if (get<2>(a) != get<2>(b)) {
            return get<2>(a) < get<2>(b);  // 第一次出勤早的排前面
        }
        else {
            return get<0>(a) < get<0>(b);  // 出勤天数和第一次出勤天数相同，按ID排序
        }
    });
    // 将前5名员工的ID拼接成结果字符串
    string result;
    for (int i = 0; i < min(5, (int)resultList.size()); i++) {
        result += to_string(get<0>(resultList[i])) + " ";
    }
    // 移除末尾的多余空格
    if (!result.empty() && result.back() == ' ') {
        result.pop_back();
    }
    return result;
}
int main() {
    int n;
    cin >> n;  // 读取员工总数n，虽然在代码中未使用该值
    // 读取30天内每一天的员工登录数量
    vector<int> dailyCounts(30);
    for (int i = 0; i < 30; i++) {
        cin >> dailyCounts[i];
    }
    // 读取每一天的员工登录ID
    vector<vector<int>> dailyIds(30);
    for (int i = 0; i < 30; i++) {
        dailyIds[i].resize(dailyCounts[i]);
        for (int j = 0; j < dailyCounts[i]; j++) {
            cin >> dailyIds[i][j];
        }
    }
    // 计算并输出前5名员工ID
    cout << calculateTop5(dailyIds) << endl;
    return 0;
}