用友笔试用友笔试题 0819

笔试时间：2025年8月19日

往年笔试合集：

2023春招秋招笔试合集

2024春招秋招笔试合集

第一题

某电商平台要搞营销活动，对一批优质用户发放优惠券，每个用户只能领1张。平台对用户的账号进行了ID映射，用户id从0开始自增。比如:第一个用户A的ID为0，第二个用户B的ID为1，第三个是2，...…第n个是n-1。相邻的用户不能同时领到优惠券。假设给定一个整数数组，由若干0和1组成，其中 0表示未领取优惠券，1表示领取了优惠券。另有一个数n，判断能否在遵循领取规则的情况下再发放 n张优惠券?能返回 true，不能返回 false。

输入描述

输入两个参数: 1、一个int的一维数组coupons，该数组由0,1组成，0表示未领取优惠券，1表示领取了优惠券; 2、准备再发放优惠券的张数n

输出描述

输出为布尔值，如果能发放n张优惠券，则返回true，否则返回false。

样例输入

1，0，0，0，1

1

样例输出

true

参考题解

该代码采用贪心策略来解决问题。核心思路是：遍历一遍用户列表（数组），只要遇到一个可以发放优惠券的位置，就立即发放一张。一个位置可以发放优惠券的判断条件是：该用户当前没有优惠券（值为0）。其左边相邻的用户没有优惠券（或者该用户是第一个用户）。其右边相邻的用户没有优惠券（或者该用户是最后一个用户）。在遍历过程中，每成功发放一张，就更新该位置的状态并进行计数。遍历完成后，比较成功发放的总数是否大于或等于需要发放的数量 n，从而得出最终结果。

C++：

#include <bits/stdc++.h>
using namespace std;

bool canPlaceMoreCoupons(vector<int>& coupons, int n) {
    if (n <= 0) return true;
    int count = 0, len = (int)coupons.size();
    for (int i = 0; i < len; ++i) {
        if (coupons[i] == 0) {
            bool leftOk = (i == 0) || (coupons[i - 1] == 0);
            bool rightOk = (i == len - 1) || (coupons[i + 1] == 0);
            if (leftOk && rightOk) {
                coupons[i] = 1;
                ++count;
            }
        }
    }
    return count >= n;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    string line;
    if (!getline(cin, line)) return 0;   // 第一行: 逗号分隔的数组
    int n; cin >> n;                     // 第二行: 整数 n

    vector<int> coupons;
    {
        stringstream ss(line);
        string part;
        while (getline(ss, part, ',')) {
            if (!part.empty()) coupons.push_back(stoi(part));
            else coupons.push_back(0); // 若出现空片段，按 0 处理（与 Java 的 Integer.parseInt 不同，通常无空片段）
        }
    }

    bool ok = canPlaceMoreCoupons(coupons, n);
    cout << (ok ? "true" : "false") << "\n";
    return 0;
}

Java：

import java.util.Scanner;

public class Main {
   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       String line = sc.nextLine();
       int n = sc.nextInt();
       sc.close();

       String[] parts = line.split(",");
       int[] coupons = new int[parts.length];
       for (int i = 0; i < parts.length; i++) {
           coupons[i] = Integer.parseInt(parts[i]);
       }

       System.out.println(canPlaceMoreCoupons(coupons, n));
   }

   public static boolean canPlaceMoreCoupons(int[] coupons, int n) {
       if (n <= 0) {
           return true;
       }

       int count = 0;
       int len = coupons.length;

       for (int i = 0; i < len; i++) {
           if (coupons[i] == 0) {
               boolean leftOk = (i == 0) || (coupons[i - 1] == 0);
               boolean rightOk = (i == len - 1) || (coupons[i + 1] == 0);

               if (leftOk && rightOk) {
                   coupons[i] = 1;
                   count++;
               }
           }
       }

       return count >= n;
   }
}

Python：

import sys

def can_place_more_coupons(coupons, n):
    if n <= 0:
        return True
    count = 0
    length = len(coupons)
    for i in range(length):
        if coupons[i] == 0:
            left_ok = (i == 0) or (coupons[i - 1] == 0)
            right_ok = (i == length - 1) or (coupons[i + 1] == 0)
            if left_ok and right_ok:
                coupons[i] = 1
                count += 1
    return count >= n

def main():
    line = sys.stdin.readline().strip()   # 第一行: 逗号分隔的数组
    n_line = sys.stdin.readline().strip() # 第二行: 整数 n
    n = int(n_line)

    parts = line.split(",")
    coupons = [int(p) for p in parts if p != ""]  # 简单处理空片段
    res = can_place_more_coupons(coupons, n)
    # 与 Java 输出一致（小写）
    print("true" if res else "false")

if __name__ == "__main__":
    main()

第二题

小友产业园中有一个电动汽车充电站，充电站中有 k 个充电桩，编号从 1 ~ k。

现在有一个长度为n的二维数组，其中第 i 个元素为[arrivalTime, chargingTime]，表示第 i 辆车在时间 arrivalTime 到达充电站需要充电 chargingTime小时。

调度规则:先到先服务: 按到达时间顺序安排充电充电桩分配: 优先使用编号最小的空闲充电桩等待机制: 如果所有充电桩都被占用，车辆需要排队等待同时到达: 如果多辆车同时到达，按车辆编号（输入顺序）优先请你模拟出该充电站的充电桩调度过程。按车辆编号顺序，每行输出一辆车的充电信息，格式为：

车辆编号开始充电时间结束充电时间充电桩编号

输入描述

第一行2个整数n和k，含义如题干所述。

接下来n行，每行2个整数arrivalTime和chargingTime，含义如题干所述。200>=k>=1200>=n>=1arrivalTime>=010>=chargingTime>=1

输出描述

输出n行，每行4个整数，分别表示车辆编号，开始充电时间，结束充电时间，充电桩编号。

样例输入

4 2

0 5

1 1

2 2

6 3

样例输出

0 0 5 1

1 1 2 2

2 2 4 2

3 6 9 1

说明：时间0: 车0到达，用桩1(0-5)时间1: 车1到达，用桩2(1-2)时间2: 车2到达，车1完成，车2用桩2(2-4)时间4: 车2完成时间5: 车0完成时间6: 车3到达，用桩1(6-9)

参考题解

数据结构：创建一个 Car 类来存储每辆车的所有信息，包括其原始编号（ID）、到达时间、充电时长，以及后续计算出的开始充电时间、结束充电时间、和使用的充电桩编号。确定处理顺序：将所有车辆信息读入一个 Car 对象列表。对这个列表进行排序。排序规则完全遵循题目的调度优先级：首先按到达时间升序，如果到达时间相同，则按车辆原始编号升序。这样排序后，列表中的车辆顺序就是它们被处理的先后顺序。模拟调度过程：对于当前车辆，遍历所有充电桩（从1到k）。计算该车在每个桩上可能的最早开始充电时间。这个时间点是车辆到达时间和充电桩当前可用时间中的较大值。在所有充电桩中，选择一个能提供最早开始充电时间的桩。如果多个桩都能提供相同的最早开始时间，由于遍历顺序是从小到大，自然会选中编号最小的那个。确定了最佳充电桩和开始时间后，计算出结束时间，并将这些结果存入当前车辆对象中。最后，更新所选充电桩的 pileFreeTime 为该车的结束充电时间，表示它在该时间点之前都处于占用状态。创建一个数组 pileFreeTime 来记录每个充电桩下一次可用的时间点，初始时所有值都为0。遍历排好序的车辆列表，为每辆车分配充电桩：格式化输出：所有车辆都处理完毕后，Car 列表中已经包含了所有结果，但列表当前是按处理顺序排列的。为了按车辆原始编号顺序输出，需要对列表再次排序，这次的排序规则仅依据车辆的原始ID。最后，遍历排序后的列表，按题目要求的格式输出每辆车的信息。

C++：

#include <bits/stdc++.h>
using namespace std;

struct Car {
    int id;
    int arrivalTime;
    int chargingTime;
    int startChargeTime = 0;
    int endChargeTime = 0;
    int pileId = 0;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, k;
    if (!(cin >> n >> k)) return 0;

    vector<Car> cars;
    cars.reserve(n);
    for (int i = 0; i < n; ++i) {
        int at, ct;
        cin >> at >> ct;
        cars.push_back(Car{i, at, ct});
    }

    // 按到达时间、id排序
    sort(cars.begin(), cars.end(), [](const Car& a, const Car& b){
        if (a.arrivalTime != b.arrivalTime) return a.arrivalTime < b.arrivalTime;
        return a.id < b.id;
    });

    // 桩的空闲时间（1..k）
    vector<int> pileFreeTime(k + 1, 0);

    for (auto& car : cars) {
        int bestPileIndex = -1;
        int earliestStartTime = INT_MAX;
        for (int i = 1; i <= k; ++i) {
            int currentStartTime = max(car.arrivalTime, pileFreeTime[i]);
            if (currentStartTime < earliestStartTime) {
                earliestStartTime = currentStartTime;
                bestPileIndex = i;
            }
        }
        car.startChargeTime = earliestStartTime;
        car.endChargeTime = car.startChargeTime + car.chargingTime;
        car.pileId = bestPileIndex;
        pileFreeTime[bestPileIndex] = car.endChargeTime;
    }

    // 按id输出
    sort(cars.begin(), cars.end(), [](const Car& a, const Car& b){
        return a.id < b.id;
    });

    for (const auto& car : cars) {
        cout << car.id << ' ' << car.startChargeTime << ' ' << car.endChargeTime << ' ' << car.pileId << '\n';
    }
    return 0;
}

Java：

import java.util.Scanner;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Main {

   static class Car {
       int id;
       int arrivalTime;
       int chargingTime;
       int startChargeTime;
       int endChargeTime;
       int pileId;

       public Car(int id, int arrivalTime, int chargingTime) {
           this.id = id;
           this.arrivalTime = arrivalTime;
           this.chargingTime = chargingTime;
       }
   }

   public static void main(String[] args) {
       Scanner sc = new Scanner(System.in);
       int n = sc.nextInt();
       int k = sc.nextInt();

       List<Car> cars = new ArrayList<>();
       for (int i = 0; i < n; i++) {
           cars.add(new Car(i, sc.nextInt(), sc.nextInt()));
       }

       Collections.sort(cars, new Comparator<Car>() {
           @Override
           public int compare(Car c1, Car c2) {
               if (c1.arrivalTime != c2.arrivalTime) {
                   return Integer.compare(c1.arrivalTime, c2.arrivalTime);
               } else {
                   return Integer.compare(c1.id, c2.id);
               }
           }
       });

       int[] pileFreeTime = new int[k + 1];

剩余60%内容，订阅专栏后可继续查看/也可单篇购买

2025 春招笔试合集文章被收录于专栏

2025打怪升级记录，大厂笔试合集 C++, Java, Python等多种语言做法集合指南