5,3,6,-8,0,11
2,8,8,8,-1,15
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

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

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
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

1:-1,2,3,6
3:8,11
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

# 将输入字符串解析为整数列表
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()  # 执行主函数

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

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

• 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;  // 程序执行完毕，返回
}

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

 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
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解法

• 解题思路

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

注意：

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

发表评论

登录后才能发表评论和回复 注册

/ 登录

提交评论

评论记录：

未查询到任何数据！

回复评论：

×

关闭 提交评论