2023年秋招软开大厂笔试在线编程记录

正在秋招，不断更新中......

目录

正在秋招，不断更新中......

小米笔试：

1、题目描述：

测试通过用例：

2、题目描述：

测试通过用例：

3、题目描述：

测试通过用例：

深信服笔试

1、题目描述：

测试通过用例：

2、题目描述

测试通过用例：

3、题目描述

测试通过用例：

---

小米笔试：

1、题目描述：

小程打牌花店买花，看到花店有N个花架，每个花架上有4盆不同颜色的花，颜色分别为红白黄粉。小程看了一下所有所有花的价格，发现即便是相同颜色的花，价格也可能不同。

小程手里有1000块钱，4个颜色的花各想买一盆；如果把钱全花光，那么有多少种买的选择呢？

输入描述：

        N<=10000，花的价格都为整数，范围1到10000

输入格式为:

        第一行为N

        接下来N行，每行4个整数，空格分开，分别表示第i(1<=i<=N)个花架上四个额色(红，白、黄、粉）的价格

输出描述：

        一个整数，表示不同买法的个数

样例输入

                3

        250 250 250 250

        156 201 205 400

        205 190 100 250

样例输出

        4

提示：

样例解释，有如下4种选择:

        1,1,1,1

        1,1,1,3

        1,1,3,2

        3,3,2,2

数字表示花架编号，如1,1,3,2表示四个颜色分别从花架1，1，3，2选取，价格分别为250，250，100，400，总和正好为1000元

测试通过用例：

#include 
#include 

using namespace std;

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

    vector> flowers(N, vector(4));

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < 4; j++) {
            cin >> flowers[i][j];
        }
    }

    int count = 0;

    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            for (int k = 0; k < N; k++) {
                for (int l = 0; l < N; l++) {
                    int sum = flowers[i][0] + flowers[j][1] + flowers[k][2] + flowers[l][3];
                    if (sum == 1000) {
                        count++;
                    }
                }
            }
        }
    }

    cout << count << endl;

    return 0;
}

存在问题：

        算法占用内存太大，部分测试无法通过。

2、题目描述：

        春天是鲜花的季节，水仙花就是其中最迷人的代表，数学上有个水仙花数，他是这样定义的: “水仙花数”是指一个三位数，它的各位数字的立方和等于其本身，比如: 153=1……3+5^3+3^3。现在要求输出所有在m和n范围内的水仙花数。

输入描述

        输入数据有多组，每组占一行，包括两个整数m和n (100<=m<=n<=999) 。

输出描述

        对于每个测试实例，要求输出所有在给定范围内的水仙花数，就是说，输出的水仙花数必须大于等于m,并且小于等于n，如果有多个，则要求从小到大排列在一行内输出，之间用一个空格隔开: 如果给定的范围内不存在水仙花数，则输出no; 每个测试实例的输出占一行。

样例输入

        100 120

        300 380

样例输出

        no

        370 371

测试通过用例：

#include 
#include 
using namespace std;

// 计算一个数的各位数字的立方和
int calculateSumOfCubes(int num) {
    int sum = 0;
    while (num > 0) {
        int digit = num % 10;
        sum += pow(digit, 3);
        num /= 10;
    }
    return sum;
}

int main() {
    int m, n;
    while (cin >> m >> n) {
        bool found = false;

        for (int i = m; i <= n; i++) {
            if (i == calculateSumOfCubes(i)) {
                if (found) {
                    cout << " ";
                }
                cout << i;
                found = true;
            }
        }

        if (!found) {
            cout << "no";
        }

        cout << endl;
    }

    return 0;
}

3、题目描述：

题目描述：

        数列的定义如下：数列的第一项为n，以后各项为前一项的平方根，求数列的m项和。

输入描述

        输入数据有多组，每组占一行，由两个整数n (n<10000) 和m(m<1000)组成，n和m的含义如前所述。

输出描述        

        对于每组输入数据，输出该数列的和，每个测试实例占一行，要求精度保留2位小数。

样例输入

        81 4

        2 2

样例输出

        94.73

        3.14

测试通过用例：

#include 
#include 
#include 
using namespace std;

int main() {
    double n, m;
    while (cin >> n >> m) {
        double sum = 0.0;
        double current = n;
        
        for (int i = 0; i < m; i++) {
            sum += current;
            current = sqrt(current);
        }

        cout << fixed << setprecision(2) << sum << endl;
    }

    return 0;
}

深信服笔试

1、题目描述：

安全网关可以识别和拦截病毒，假设使用[a-z]的26个字母做为病毒代号，每个字母表示一种病毒，假设病毒种类<=26。当未开启拦截模式时，安全网关在一段时间内识别到的入侵病毒详情使用字符串s来记录，当这些病毒入侵到内网各个主机时，请计算主机存在病毒组合个数(与顺序无关，例如ab与ba是一样的)。

输入描述：

        需要统计的字符串

输出描述：

        输入字符串中不重复字符组成的字符集合个数

示例1：

输入:

        aa

输出:

        1

说明：

        组合有['a']，需要去掉重复的字符

示例2：

输入:

        ab

输出:

        3

说明：

        组合有['a','b','ab']，需要去掉重复的字符

测试通过用例：

#include 
#include 
#include 
#include 

// 递归函数，用于生成字符集合的组合
void generateCombinations(const std::string& input, int start, std::string currentCombination, std::set& combinations) {
    // 将当前组合添加到集合中，但不添加空集和有重复字符的组合
    if (!currentCombination.empty() && currentCombination.size() == std::set(currentCombination.begin(), currentCombination.end()).size()) {
        combinations.insert(currentCombination);
    }

    // 从当前位置开始，递归生成更长的组合
    for (int i = start; i < input.length(); ++i) {
        generateCombinations(input, i + 1, currentCombination + input[i], combinations);
    }
}

int main() {
    std::string input;
    std::cout << "请输入需要统计的字符串: ";
    std::cin >> input;

    std::set combinations;
    generateCombinations(input, 0, "", combinations);

    // 输出不同组合个数
    std::cout << "不同组合个数: " << combinations.size() << std::endl;

    // 输出不同组合的结果
    std::cout << "不同组合结果:" << std::endl;
    for (const std::string& combination : combinations) {
        std::cout << combination << std::endl;
    }

    return 0;
}

2、题目描述

        问题描述：现有一批长度不同的木材woods，现在需要将木材进行拼接，正好达到总产幅度length，在不考虑切割木材，并且每种长度的木材不限量供应的情况下，返回满足要求额最少木材数量，如果无法通过组合达到规定长度，则返回 -1。

输入描述：

        木材长度和列表需要达到的总长度length

        木材种类：1<=len(woods)<=100

        木材长度：1<=woods[i]<=100

        总长度：1<=length<=100

        输入的2行信息均以字符串形式输入，需要自己转换为列表和证书

输出描述：

        返回满足要求的最少木材数量，如果无法通过组合达到规定长度，则返回-1

示例1：

输入：

        [1,2,3,5]

        9

输出：

        3

说明：

        9=5+3+1

测试通过用例：

#include 
#include 
#include 
#include 

using namespace std;

int minWoodCount(vector& woods, int length) {
    vector dp(length + 1, length + 1);
    dp[0] = 0;

    for (int i = 1; i <= length; ++i) {
        for (int wood : woods) {
            if (i - wood >= 0) {
                dp[i] = min(dp[i], dp[i - wood] + 1);
            }
        }
    }

    return dp[length] > length ? -1 : dp[length];
}

int main() {
    string woods_str;
    getline(cin, woods_str);
    
    string length_str;
    getline(cin, length_str);

    vector woods;
    istringstream iss(woods_str.substr(1, woods_str.size() - 2));
    string token;
    
    while (getline(iss, token, ',')) {
        woods.push_back(stoi(token));
    }

    int length = stoi(length_str);

    int result = minWoodCount(woods, length);

    cout << result << endl;

    return 0;
}

3、题目描述

        给定一个未经排序的整数数组，找到最长且 连续递减的子序列，并返回该序列的长度。连续递减的子序列 可以由两个下标I和r(l输入描述：

        未经排序的整数数组
输出描述：

        返回连续递减子序列的长度

示例：
输入：

        7，4，5，3，1
输出：

        3
最长连续递减序列是[5,3,1],长度为3

测试通过用例：

#include 
#include 
#include 
using namespace std;

int findLongestDecreasingSubsequence(vector& nums) {
    int n = nums.size();
    if (n == 0) {
        return 0;
    }

    int maxLength = 1;
    int currentLength = 1;

    for (int i = 1; i < n; ++i) {
        if (nums[i] < nums[i - 1]) {
            currentLength++;
            maxLength = max(maxLength, currentLength);
        } else {
            currentLength = 1;
        }
    }

    return maxLength;
}

int main() {
    cout << "请输入以逗号分隔的未经排序的整数数组: ";
    string input;
    getline(cin, input);

    vector nums;
    stringstream ss(input);
    string num;

    while (getline(ss, num, ',')) {
        nums.push_back(stoi(num));
    }

    int length = findLongestDecreasingSubsequence(nums);
    cout << "连续递减子序列的长度为: " << length << endl;

    return 0;
}