【华为OD-E卷 -38 优秀学员统计 100分（python、java、c++、js、c）】

id="article_content" class="article_content clearfix" style="height: 2000px; overflow: hidden;"> id="content_views" class="markdown_views prism-tomorrow-night">

【华为OD-E卷 - 优秀学员统计 100分（python、java、c++、js、c）】

题目

公司某部门软件教导团正在组织新员工每日打卡学习活动，他们开展这项学习活动已经一个月了，所以想统计下这个月优秀的打卡员工。每个员工会对应一个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
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 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
输出：
10 0 1 7 6
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 1
用例二：
输入：
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
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
  • 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
输出：
0 1 2 3 4
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
用例三：
输入：
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
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">
输出：
1 0
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

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))

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

java解法

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

使用一个 TreeMap 来存储每个员工的登录数据：
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;
    }
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

C++解法

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

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

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

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

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

#include 
#include 
#include 
#include 
#include 

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;
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

C解法

更新中
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

JS解法

更新中
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

注意：

如果发现代码有用例覆盖不到的情况，欢迎反馈！会在第一时间修正，更新。
解题不易，如对您有帮助，欢迎点赞/收藏

注：本文转载自blog.csdn.net的CodeClimb的文章"https://blog.csdn.net/CodeClimb/article/details/144834225"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！