秋招日寄|vivo2025届秋招软件类笔试试卷

仅此一轮，题目都一样的，很简单。

第一题：单选题×6；

第二题：不定向选择×4；

第三题：编程题×3，核心代码模式。

编程题1：

项目组新老员工分组完成任务，员工数组staff，其中0表示新员工，1表示老员工，分组规则如下：
1、一个小组至多3个员工；
2、一个小组中最多有1个老员工；
3、如果一个小组中有1个老员工，那么这组最多有2个员工；
求最小的分组数。

输入描述：
输入员工数组 staff，元素只包含0,1；
输出描述：
输出一个整数，表示最小分组数。

示例输入：
[1,0,0,0,1]

输出：
3

示例输入：
[1,1]

输出：
2

答案：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 获取最小分组数
     * @param staff int整型vector 员工数组，其中0表示新员工，1表示老员工
     * @return int整型
     */
    int staffGroup(vector<int>& staff) {
        // write code here
        int newstaff = 0;
        int oldstaff = 0;
        for (int a : staff) {
            if (a == 0) newstaff++;
            else oldstaff++;
        }

        int count = 0;
        while (newstaff > 0 || oldstaff > 0) {
            if (oldstaff > 0) {
                oldstaff--;
                if (newstaff > 0) newstaff--;
                count++;
            } 
            
            else {
                count++;
                if (newstaff >= 0) newstaff -= 3;
            }
        }
        return count;
    }
};

编程题2：

你是一名手机应用开发工程师，需要分析应用在手机上的内存使用情况。你有一个数组 memoryUsage，其中 memoryUsage[i]表示应用在第i秒的内存使用量（以MB为单位）。为了评估应用的稳定性，你需要找出每个连续k秒内的内存使用量的波动范围（即最大值与最小值的差值），并返回这些波动范围。

输入：
[80, 100, 70, 90, 60, 85, 75, 95, 110],4
输出：
[30,40,30,30,35,35]

输入：
[120, 150, 110, 180, 130, 160, 140, 170],3

输出：
[40,70,70,50,30,30]

答案：

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可。
     * 
     * @param memoryUsage int 整型 vector，数组 memoryUsage，其中 memoryUsage[i] 表示应用在第 i 秒的内存使用量（以 MB 为单位）。
     * @param k int 整型，整数 k。
     * @return int 整型 vector。
     */
    vector<int> findFluctuations(vector<int>& memoryUsage, int k) {
        // write code here
        vector<int> result;
        deque<int> minDeque;
        deque<int> maxDeque;

        for (int i = 0; i < memoryUsage.size(); i++) {
            while (!minDeque.empty() && memoryUsage[minDeque.back()] >= memoryUsage[i]) minDeque.pop_back();
            minDeque.push_back(i);

            while (!maxDeque.empty() && memoryUsage[maxDeque.back()] <= memoryUsage[i]) maxDeque.pop_back();
            maxDeque.push_back(i);

            if (i >= k - 1) {
                result.push_back(memoryUsage[maxDeque.front()] - memoryUsage[minDeque.front()]);

                if (minDeque.front() <= i - k + 1) minDeque.pop_front();
                if (maxDeque.front() <= i - k + 1) maxDeque.pop_front();
            }
        }

        return result;
    }
};

编程题3：

（限制语言为C、Java、Python）

为回馈粉丝，进行礼品派发活动，不同礼品价格不同，为公平起见，需要将全部的礼品公平的分配到粉丝手中，且每位粉丝拿到的礼品总价格相同。请帮忙确认以下的礼品数量和价格是否可以满足公平的分配原则，可以则返回true，否则返回false。

例如：
价格分别为5，4，1，3，2，3，2的礼物是否可以公平分配到4名粉丝手？答案是可以的，按(5)、(2,3)、(2,3)、(1,4)组合，第一位粉丝分配到价格为5的礼物，第二位分配到价格为2和3的礼物，第三位分配到价格为2和3的礼物，第四位分配到价格为1和4的礼物，全部礼物分配完，最后返回true，代表可以公平分配。

程序需要输入的参数是价格数组和粉丝人数（数组元素和粉丝人数均小于1000）

示例输入：
[5,4,1,3,2,3,2],4

输出：
true

输入：
[1,2,2,2,2],3
输出：
false

答案：

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param prices int整型一维数组 礼物的价格
 * @param pricesLen int prices数组长度
 * @param k int整型 粉丝人数
 * @return bool布尔型
 */
int cmp(const void* a, const void* b) {
    return *(int*)b - *(int*)a;
}

bool canPartition(int* prices, int pricesLen, int* subsets, int k, int target, int idx) {
    if (idx == pricesLen) return true;

    for (int i = 0; i < k; i++) {
        if (subsets[i] + prices[idx] <= target) {
            subsets[i] += prices[idx];

            if (canPartition(prices, pricesLen, subsets, k, target, idx + 1)) {
                return true;
            }
            subsets[i] -= prices[idx];
        }
        
        if (subsets[i] == 0) break;
    }

    return false;
}

bool canEqualDistribution(int* prices, int pricesLen, int k) {
    int sum = 0;
    for (int i = 0; i < pricesLen; i++) {
        sum += prices[i];
    }

    if (sum % k != 0) return false;

    int target = sum / k;
    qsort(prices, pricesLen, sizeof(int), cmp);

    if (prices[0] > target) return false;

    int subsets[k];
    for (int i = 0; i < k; i++) {
        subsets[i] = 0;
    }

    return canPartition(prices, pricesLen, subsets, k, target, 0);
}