【华为OD-E卷 - 找出两个整数数组中同时出现的整数 100分（python、java、c++、js、c）】

题目

现有两个整数数组，需要你找出两个数组中同时出现的整数，并按照如下要求输出:
有同时出现的整数时，先按照同时出现次数（整数在两个数组中都出现并目出现次数较少的那个）进行归类，然后按照出现次数从小到大依次按行输出。 没有同时出现的整数时，输出NULL

输入描述

• 第一行为第一个整数数组，第二行为第二个整数数组，每行数中整数与整数之间以英文号分，整数的取值范用为[-200, 200]，数组长度的范用为[1, 10000]之间的整数

输出描述

• 按照出现次数从小到大依次按行输出，每行输出的格式为：

出现次数:该出现次数下的整数升序排序的结果

格式中的":"为英文冒号，整数间以英文逗号分隔

用例

用例一：

输入：

5,3,6,-8,0,11
2,8,8,8,-1,15

• 1
• 2

输出：

NULL

• 1

用例二：

输入：

5,8,11,3,6,8,8,-1,11,2,11,11
11,2,11,8,6,8,8,-1,8,15,3,-9,11

• 1
• 2

输出：

1:-1,2,3,6
3:8,11

• 1
• 2

说明 两整数数组中同时出现的整数为-12、3、6、8、11,其中同时出现次数为1的整数为-1,2,3,6(升序排序),同时出现次数为3的整数为8,11(升序排序),先升序输出出现次数为1的整数，再升序输出出现次数为3的整数

python解法

• 解题思路：
• 本题目是通过两组整数的输入来计算它们的公共元素和各自的频率，并输出每个频率下的公共元素。具体来说，我们需要完成以下几步：

输入处理：

用户输入两行整数序列，每个整数序列是由逗号分隔的。
统计频率：

对每个序列中的整数，统计它们的出现次数。
寻找公共元素及其频率：

找出两个序列中共同出现的元素，并记录它们在每个序列中出现的次数。对于每个公共元素，记录它们在两个序列中出现的最小次数。
输出结果：

根据每个公共元素的最小次数，按从小到大的顺序输出这些元素

# 将输入字符串解析为整数列表
def parse(input_str):
    return list(map(int, input_str.split(',')))

# 计算列表中每个元素出现的频率
def count_freq(arr):
    freq = {}  # 用字典存储频率
    for n in arr:
        if n in freq:
            freq[n] += 1  # 如果元素已经存在，增加计数
        else:
            freq[n] = 1   # 如果元素不存在，初始化为1
    return freq

# 找出两个频率字典中的共同元素，并记录最小出现次数
def find_common(m1, m2):
    result = {}  # 存储公共元素和它们的最小出现次数
    for n, count in m1.items():  # 遍历第一个频率字典
        if n in m2:  # 如果元素在第二个频率字典中也有
            min_count = min(count, m2[n])  # 取两个字典中最小的出现次数
            if min_count in result:
                result[min_count].add(n)  # 如果该次数已经存在，添加元素
            else:
                result[min_count] = {n}   # 否则初始化为一个集合
    return result

# 打印结果，按出现次数排序
def print_result(res_map):
    if not res_map:  # 如果没有公共元素
        print("NULL")
    else:
        for count, nums in sorted(res_map.items()):  # 按出现次数排序
            print(f"{count}:{','.join(map(str, sorted(nums)))}")  # 按元素大小排序输出

# 主函数
def main():
    l1 = input()  # 输入第一个整数序列
    l2 = input()  # 输入第二个整数序列

    a1 = parse(l1)  # 将第一个输入解析为整数列表
    a2 = parse(l2)  # 将第二个输入解析为整数列表

    m1 = count_freq(a1)  # 统计第一个列表的频率
    m2 = count_freq(a2)  # 统计第二个列表的频率

    res_map = find_common(m1, m2)  # 查找两个频率字典中的公共元素

    print_result(res_map)  # 输出结果

if __name__ == "__main__":
    main()  # 执行主函数

• 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

java解法

• 解题思路

更新中

• 1

C++解法

• 解题思路
• 本题目要求从两组由逗号分隔的整数列表中找出它们的公共元素，并按照每个公共元素在两个列表中出现的最小次数进行排序输出。具体思路如下：

输入处理：

用户输入两行包含逗号分隔的整数序列。
统计频率：

对每个序列中的整数，统计它们的出现次数。
查找公共元素：

找出两个序列中共同出现的元素，并记录它们在每个序列中出现的次数。对于每个公共元素，记录它们在两个序列中出现的最小次数。
输出结果：

根据每个公共元素的最小次数，按从小到大的顺序输出这些元素。

#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

// 解析输入的逗号分隔的字符串并返回整数数组
vector<int> parse(const string& in) {
    vector<int> res;
    stringstream ss(in);  // 将字符串流化，便于逐个读取数字
    string itm;
    while (getline(ss, itm, ',')) {  // 按逗号分割字符串
        res.push_back(stoi(itm));  // 将每个分割的部分转为整数并加入结果数组
    }
    return res;
}

// 统计数组中元素的出现次数
map<int, int> countFreq(const vector<int>& arr) {
    map<int, int> freq;
    for (int n : arr) {
        freq[n]++;  // 将每个元素出现的次数存入频率字典
    }
    return freq;
}

// 生成两数组的共同元素及其最小出现次数的映射
map<int, set<int>> findCommon(const map<int, int>& m1, const map<int, int>& m2) {
    map<int, set<int>> res;
    for (const auto& it : m1) {  // 遍历第一个数组的频率字典
        int n = it.first;  // 获取元素
        if (m2.count(n)) {  // 如果该元素在第二个数组中也出现
            int cnt = min(it.second, m2.at(n));  // 取该元素在两个数组中出现的最小次数
            res[cnt].insert(n);  // 将该元素和最小次数插入到结果字典中
        }
    }
    return res;
}

// 打印结果
void printResult(const map<int, set<int>>& resMap) {
    if (resMap.empty()) {  // 如果结果为空，表示没有公共元素
        cout << "NULL" << endl;
    }
    else {
        // 遍历结果字典，按次数升序输出
        for (const auto& it : resMap) {
            cout << it.first << ":";  // 输出出现次数
            bool fst = true;  // 用于控制元素之间的分隔符
            for (int n : it.second) {  // 输出每个最小次数对应的公共元素
                if (!fst) cout << ",";
                cout << n;
                fst = false;
            }
            cout << endl;  // 每个结果后换行
        }
    }
}

// 主函数
int main() {
    string l1, l2;
    getline(cin, l1);  // 读取第一行输入
    getline(cin, l2);  // 读取第二行输入

    vector<int> a1 = parse(l1);  // 将第一行输入解析为整数数组
    vector<int> a2 = parse(l2);  // 将第二行输入解析为整数数组

    map<int, int> m1 = countFreq(a1);  // 统计第一个数组中每个元素的频率
    map<int, int> m2 = countFreq(a2);  // 统计第二个数组中每个元素的频率

    map<int, set<int>> resMap = findCommon(m1, m2);  // 查找两个数组中的共同元素及其最小出现次数

    printResult(resMap);  // 打印结果

    return 0;  // 程序执行完毕，返回
}

• 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

C解法

• 解题思路

• 本题目要求比较两个由逗号分隔的整数列表，找出它们的公共元素，并按出现次数的最小值以及元素值进行排序输出。具体思路如下：

输入处理：

用户输入两行包含逗号分隔的整数序列，分别转换为两个整数数组。
统计频率：

对每个序列中的整数，统计它们的出现次数。
查找公共元素：

找出两个序列中共同出现的元素，并记录它们的最小出现次数。
排序并输出结果：

根据每个公共元素的最小出现次数，按从小到大的顺序输出这些元素

#include 
#include 
#include 

#define MAX_SIZE 1000

// 解析输入的逗号分隔的字符串并返回整数数组，返回数组的长度
int parse(const char* str, int* arr) {
    int count = 0;
    // 使用strdup复制字符串并按逗号分割
    char* token = strtok(strdup(str), ",");
    while (token != NULL) {
        arr[count++] = atoi(token);  // 将分割出的数字字符串转为整数并存入数组
        token = strtok(NULL, ",");
    }
    return count;  // 返回数组长度
}

// 统计数组中每个元素出现的频率，频率存储在freq数组中
void count_freq(int* arr, int n, int* freq, int* count) {
    for (int i = 0; i < n; i++) {
        int found = 0;
        // 遍历freq数组，查找当前元素是否已经出现过
        for (int j = 0; j < *count; j++) {
            if (freq[2 * j] == arr[i]) {  // 如果该元素已经存在
                freq[2 * j + 1]++;  // 频率加一
                found = 1;
                break;
            }
        }
        if (!found) {  // 如果当前元素是新元素
            freq[2 * (*count)] = arr[i];  // 存储元素值
            freq[2 * (*count) + 1] = 1;  // 初始化频率为1
            (*count)++;  // 更新频率数组的元素数量
        }
    }
}

// 查找两个数组中公共元素及其最小频率，结果存储在result数组中
void find_common(int* freq1, int count1, int* freq2, int count2, int* result, int* result_count) {
    for (int i = 0; i < count1; i++) {
        for (int j = 0; j < count2; j++) {
            // 如果两个频率数组中的元素相同
            if (freq1[2 * i] == freq2[2 * j]) {
                int min_count = freq1[2 * i + 1] < freq2[2 * j + 1] ? freq1[2 * i + 1] : freq2[2 * j + 1];
                result[2 * (*result_count)] = min_count;  // 存储最小出现次数
                result[2 * (*result_count) + 1] = freq1[2 * i];  // 存储元素值
                (*result_count)++;  // 更新结果数组中的元素数量
                break;
            }
        }
    }
}

// 打印结果，按照频率升序，并且按元素升序输出
void print_result(int* result, int result_count) {
    if (result_count == 0) {  // 如果没有公共元素
        printf("NULL\n");
    }
    else {
        // 对结果进行排序，首先按出现次数排序，然后按元素值排序
        for (int i = 0; i < result_count - 1; i++) {
            for (int j = i + 1; j < result_count; j++) {
                if (result[2 * i] > result[2 * j] ||  // 如果次数较大则交换
                    (result[2 * i] == result[2 * j] && result[2 * i + 1] > result[2 * j + 1])) {
                    int temp1 = result[2 * i];
                    int temp2 = result[2 * i + 1];
                    result[2 * i] = result[2 * j];
                    result[2 * i + 1] = result[2 * j + 1];
                    result[2 * j] = temp1;
                    result[2 * j + 1] = temp2;
                }
            }
        }

        // 按照排序后的结果输出
        for (int i = 0; i < result_count; i++) {
            // 按照次数分组，每个次数对应的元素放在一起
            if (i == 0 || result[2 * i] != result[2 * (i - 1)]) {
                if (i > 0) {
                    printf("\n");
                }
                printf("%d:", result[2 * i]);  // 输出出现次数
            }
            printf("%d", result[2 * i + 1]);  // 输出对应的元素
            if (i != result_count - 1 && result[2 * (i + 1)] == result[2 * i]) {
                printf(",");  // 如果下一个元素属于同一组，则打印逗号
            }
        }
        printf("\n");
    }
}

// 主函数
int main() {
    char line1[MAX_SIZE], line2[MAX_SIZE];
    fgets(line1, MAX_SIZE, stdin);  // 读取第一行输入
    fgets(line2, MAX_SIZE, stdin);  // 读取第二行输入

    int arr1[MAX_SIZE], arr2[MAX_SIZE];
    int n1 = parse(line1, arr1);  // 解析第一个输入数组
    int n2 = parse(line2, arr2);  // 解析第二个输入数组

    int freq1[2 * MAX_SIZE], freq2[2 * MAX_SIZE];  // 存储频率信息的数组
    int count1 = 0, count2 = 0;

    count_freq(arr1, n1, freq1, &count1);  // 统计第一个数组中每个元素的频率
    count_freq(arr2, n2, freq2, &count2);  // 统计第二个数组中每个元素的频率

    int result[2 * MAX_SIZE];  // 存储公共元素及其最小出现次数
    int result_count = 0;

    find_common(freq1, count1, freq2, count2, result, &result_count);  // 查找公共元素及其最小出现次数

    print_result(result, result_count);  // 打印结果

    return 0;
}

• 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
• 119

JS解法

• 解题思路

更新中

• 1

注意：

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