最大N个数与最小N个数的和 - 华为OD统一考试（C卷）

OD统一考试（C卷）

分值： 100分

题解： Java / Python / C++

题目描述

给定一个数组，编写一个函数来计算它的最大N个数与最小N个数的和。你需要对数组进行去重。

说明:

• 数组中数字范围[0,1000]
• 最大N个数与最小N个数不能有重叠，如有重叠，输入非法返回-1
• 输入非法返回-1

输入描述

第一行输入M, M标识数组大小

第二行输入M个数，标识数组内容

第三行输入N，N表示需要计算的最大、最小的N个数

输出描述

输出最大N个数与最小N个数的和。

示例1

输入：
5
95 88 83 64 100
2

输出：
342

说明：
最大2个数[100,95],最小2个数[83,64],输出为342

示例2

输入：
5
3 2 3 4 2
2

输出：
-1

说明：
最大2个数[4,3] 最小2个数[3,2], 有重叠输出为-1

题解

这是一道模拟题，解法可以分为以下几个步骤：

1. 输入处理：读取数组大小 M，然后读取数组内容，标识为 nums，再读取 N 表示需要计算的最大、最小的 N 个数。
2. 非法检测：检查输入是否非法，包括数组元素大小是否在规定范围内，以及最大、最小的 N 个数是否有重叠。若非法，则输出 -1。
3. 数组去重：将数组 nums 转化为集合 unums，实现数组去重。
4. 数组排序：将去重后的集合 unums 转化为列表，并进行排序。
5. 计算和：计算最大 N 个数与最小 N 个数的和，输出结果。

代码中使用了集合（Set）来实现数组去重，并对数字进行排序。

在Python中，使用 set() 和 sorted() 函数实现。

在Java中，使用 HashSet 来存储去重后的数字，然后将其转化为列表，并使用 Collections.sort() 进行排序。

在C++中，使用 unordered_set 实现去重，然后将其转化为向量，并使用 sort 函数进行排序。

最后，根据输入的合法性和计算的结果，输出相应的值。

Java

import java.util.*;
/**
 * @author code5bug
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();

        // 是否非法
        boolean illegal = false;
        List<Integer> nums = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            int t = scanner.nextInt();
            if (t < 0 || t > 1000) illegal = true;
            nums.add(t);
        }

        int n = scanner.nextInt();
        Set<Integer> unums = new HashSet<>(nums); // 去重

        // 检测最大N个数与最小N个数不能有重叠
        if (unums.size() < 2 * n) illegal = true;

        if (illegal) {
            System.out.println(-1);
        } else {
            int result = 0;
            // 对数字进行排序
            List<Integer> sortedNums = new ArrayList<>(unums);
            Collections.sort(sortedNums);
            for (int i = 0; i < n; i++) {
                // 计算的最大、最小的N个数 的和
                result += sortedNums.get(i) + sortedNums.get(sortedNums.size() - i - 1);
            }
            System.out.println(result);
        }
    }
}

Python

m = int(input())


nums = list(map(int, input().split()))
# 是否非法
illegal = any(t < 0 or t > 1000 for t in nums)

n = int(input())
unums = set(nums)  # 去重

# 检测最大N个数与最小N个数不能有重叠
if len(unums) < 2 * n:
    illegal = True

if illegal:
    print(-1)
else:
    maxsum = 0
    # 对数字进行排序
    sortedNums = sorted(list(unums))
    for i in range(n):
        # 计算的最大、最小的N个数的和
        maxsum += sortedNums[i] + sortedNums[-i-1]

    print(maxsum)

C++

#include <iostream>
#include <vector>
#include <unordered_set>
#include <algorithm>

using namespace std;

int main() {
    int m;
    cin >> m;

    // 是否非法
    bool illegal = false;
    vector<int> nums;
    int t;
    for(int i=0; i<m; i++) {
        cin >> t;
        if(t < 0 || t > 1000) illegal = true;
        nums.push_back(t);
    }

    int n;
    cin >> n;
    unordered_set<int> unums(nums.begin(), nums.end()); // 去重

    // 检测最大N个数与最小N个数不能有重叠
    if(unums.size() < 2 * n) {
        illegal = true;
    }

    if(illegal) {
        cout << -1 << endl;
        return 0;
    }

    int maxsum = 0;
    // 对数字进行排序
    vector<int> sortedNums(unums.begin(), unums.end());
    sort(sortedNums.begin(), sortedNums.end());
    for(int i=0; i<n; i++) {
        // 计算的最大、最小的N个数 的和
        maxsum += sortedNums[i] + sortedNums[sortedNums.size()-i-1];
    }

    cout << maxsum << endl;


    return 0;
}

🙏整理题解不易， 如果有帮助到您，请给点个赞 ‍❤️‍ 和收藏 ⭐，让更多的人看到。🙏🙏🙏