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 <iostream>

#include <vector>

using namespace std;

int main() {

int N;

cin >> N;

vector<vector<int>> flowers(N, vector<int>(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 <iostream>

#include <cmath>

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 <iostream>

#include <iomanip>

#include <cmath>

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 <iostream>

#include <string>

#include <set>

#include <vector>

void generateCombinations(const std::string& input, int start, std::string currentCombination, std::set<std::string>& combinations) {

if (!currentCombination.empty() && currentCombination.size() == std::set<char>(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<std::string> 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 <iostream>

#include <vector>

#include <string>

#include <sstream>

using namespace std;

int minWoodCount(vector<int>& woods, int length) {

vector<int> 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<int> 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<r) 确定，如果对于每个l<=i<r都有 nums[i] < numsli + 1]，那么子序列[nums[l],nums[l + 1], ..., nums[r- 1],nums[r]]就是连续递增子序列
输入描述：

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

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

示例：
输入：

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

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

测试通过用例：

#include <iostream>

#include <vector>

#include <sstream>

using namespace std;

int findLongestDecreasingSubsequence(vector<int>& 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<int> nums;

stringstream ss(input);

string num;

while (getline(ss, num, ',')) {

nums.push_back(stoi(num));

}

int length = findLongestDecreasingSubsequence(nums);

cout << "连续递减子序列的长度为: " << length << endl;

return 0;

}

大华笔试

题目描述：

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1] 输出：6 解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

示例 2：

输入：height = [4,2,0,3,2,5] 输出：9 测试通过用例：

class Solution {

public:

int trap(vector<int>& height)

{

int ans = 0;

stack<int> st;

for (int i = 0; i < height.size(); i++)

{

while (!st.empty() && height[st.top()] < height[i])

{

int cur = st.top();

st.pop();

if (st.empty()) break;

int l = st.top();

int r = i;

int h = min(height[r], height[l]) - height[cur];

ans += (r - l - 1) * h;

}

st.push(i);

}

return ans;

}

};

题目描述：

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：

对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC" 输出："BANC" 解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例 2：

输入：s = "a", t = "a" 输出："a" 解释：整个字符串 s 是最小覆盖子串。

示例 3:

输入: s = "a", t = "aa" 输出: "" 解释: t 中两个字符 'a' 均应包含在 s 的子串中， 因此没有符合条件的子字符串，返回空字符串。 测试通过用例：

class Solution {

public:

unordered_map <char, int> ori, cnt;

bool check() {

for (const auto &p: ori) {

if (cnt[p.first] < p.second) {

return false;

}

}

return true;

}

string minWindow(string s, string t) {

for (const auto &c: t) {

++ori[c];

}

int l = 0, r = -1;

int len = INT_MAX, ansL = -1, ansR = -1;

while (r < int(s.size())) {

if (ori.find(s[++r]) != ori.end()) {

++cnt[s[r]];

}

while (check() && l <= r) {

if (r - l + 1 < len) {

len = r - l + 1;

ansL = l;

}

if (ori.find(s[l]) != ori.end()) {

--cnt[s[l]];

}

++l;

}

}

return ansL == -1 ? string() : s.substr(ansL, len);

}

};

题目描述：

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：

如果字符串的长度为 1 ，算法停止如果字符串的长度 > 1 ，执行下述步骤： 在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。

给你两个 长度相等 的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回 true ；否则，返回 false 。

示例 1：

输入：s1 = "great", s2 = "rgeat" 输出：true 解释：s1 上可能发生的一种情形是： "great" --> "gr/eat" // 在一个随机下标处分割得到两个子字符串 "gr/eat" --> "gr/eat" // 随机决定：「保持这两个子字符串的顺序不变」 "gr/eat" --> "g/r / e/at" // 在子字符串上递归执行此算法。两个子字符串分别在随机下标处进行一轮分割 "g/r / e/at" --> "r/g / e/at" // 随机决定：第一组「交换两个子字符串」，第二组「保持这两个子字符串的顺序不变」 "r/g / e/at" --> "r/g / e/ a/t" // 继续递归执行此算法，将 "at" 分割得到 "a/t" "r/g / e/ a/t" --> "r/g / e/ a/t" // 随机决定：「保持这两个子字符串的顺序不变」 算法终止，结果字符串和 s2 相同，都是 "rgeat" 这是一种能够扰乱 s1 得到 s2 的情形，可以认为 s2 是 s1 的扰乱字符串，返回 true

示例 2：

输入：s1 = "abcde", s2 = "caebd" 输出：false

示例 3：

输入：s1 = "a", s2 = "a" 输出：true 测试通过用例：

class Solution {

private:

int memo[30][30][31];

string s1, s2;

public:

bool checkIfSimilar(int i1, int i2, int length) {

unordered_map<int, int> freq;

for (int i = i1; i < i1 + length; ++i) {

++freq[s1[i]];

}

for (int i = i2; i < i2 + length; ++i) {

--freq[s2[i]];

}

if (any_of(freq.begin(), freq.end(), [](const auto& entry) {return entry.second != 0;})) {

return false;

}

return true;

}

bool dfs(int i1, int i2, int length) {

if (memo[i1][i2][length]) {

return memo[i1][i2][length] == 1;

}

if (s1.substr(i1, length) == s2.substr(i2, length)) {

memo[i1][i2][length] = 1;

return true;

}

if (!checkIfSimilar(i1, i2, length)) {

memo[i1][i2][length] = -1;

return false;

}

for (int i = 1; i < length; ++i) {

if (dfs(i1, i2, i) && dfs(i1 + i, i2 + i, length - i)) {

memo[i1][i2][length] = 1;

return true;

}

if (dfs(i1, i2 + length - i, i) && dfs(i1 + i, i2, length - i)) {

memo[i1][i2][length] = 1;

return true;

}

}

memo[i1][i2][length] = -1;

return false;

}

bool isScramble(string s1, string s2) {

memset(memo, 0, sizeof(memo));

this->s1 = s1;

this->s2 = s2;

return dfs(0, 0, s1.size());

}

};

相关知识

2023年秋招软开大厂笔试在线编程记录
招聘职位详情—济南天山实验学校秋招&笔试
2020shopee秋招笔试记录
数据分析面试
秋招笔记：2018阿里中间件部门C/C++岗在线测评
重大突破 我校《工业机器人操作与编程》课程入选国家在线精品课程
大厂为什么都想做“种草”？
学校6门课程入选2023年职业教育国家在线精品课程
2023安徽马鞍山市花山区事业单位统一笔试招聘人员核减岗位公告
前端开发者常用的 10 个 AI 编程工具！

网址: 2023年秋招软开大厂笔试在线编程记录 https://www.huajiangbk.com/newsview2017903.html

上一篇: 一种基于机器视觉的木料分割方法与

下一篇: 木板切割问题——贪心