今天在牛客网刷到一篇很有意思的帖子。
这位同学说道:985学历真好用。一面答得再差都挂不了,都给你二面了再挂,二面挂也不秒挂,基本至少泡一周泡发了才挂,相当给面子!就是不给offer 🤣🤣🤣
哈哈哈哈哈,这位同学把我乐坏了。
然后我看了一眼评论区。
一位复旦大学计算机专业,正在找暑假实习的大三学生分享了自己的经历:腾讯字节都是一面挂。
这还不算什么,甚至还有"双九简历挂"的盖楼集合:
要我说,行情不好,同学们还是挺会苦中作乐的。
通常在应聘市场中,学历只是门槛之一,也就是一般只会作为"简历初筛"的条件之一,如果一家公司 985 学历等价于一面通行证,那么大概率一面才是他们的"初筛"。
至于"双九(本科和硕士均为 985)简历挂"就有点离谱了,这种估计大概率还在流程中。
无论是校招还是社招,候选人能力才是决定性的因素。
只不过针对是否有工作经验,考察的侧重点会不同。
国内互联网大厂或外企,校招中「算法」是考察的重点,下面一道「可灵活切换数据范围」的小小思维题,如果在一面中,基本解法都没做出来,我估计是什么学历都不好使。
平台:LeetCode
题号:2335
现有一台饮水机,可以制备冷水、温水和热水。每秒钟,可以装满 2
杯 不同 类型的水或者 1
杯任意类型的水。
给你一个下标从 0
开始、长度为 3
的整数数组 amount
,其中 amount[0]
、amount[1]
和 amount[2]
分别表示需要装满冷水、温水和热水的杯子数量。
返回装满所有杯子所需的 「最少」 秒数。
示例 1:
输入:amount = [1,4,2]
输出:4
解释:下面给出一种方案:
第 1 秒:装满一杯冷水和一杯温水。
第 2 秒:装满一杯温水和一杯热水。
第 3 秒:装满一杯温水和一杯热水。
第 4 秒:装满一杯温水。
可以证明最少需要 4 秒才能装满所有杯子。
示例 2:
输入:amount = [5,4,4]
输出:7
解释:下面给出一种方案:
第 1 秒:装满一杯冷水和一杯热水。
第 2 秒:装满一杯冷水和一杯温水。
第 3 秒:装满一杯冷水和一杯温水。
第 4 秒:装满一杯温水和一杯热水。
第 5 秒:装满一杯冷水和一杯热水。
第 6 秒:装满一杯冷水和一杯温水。
第 7 秒:装满一杯热水。
示例 3:
输入:amount = [5,0,0]
输出:5
解释:每秒装满一杯冷水。
提示:
水的种类固定为 3
,且每种水的数据范围只有
,可直接使用递归进行求解。
为了尽可能的凑成多的对数,我们可以每次取剩余数量最多且不为 0
的两类水进行成组(因此每次处理前需要先对当前 amount
进行排序),直到没有水剩余,或只有一类水的剩余数据量不为 0
(剩下的水只能独自生成)。
Java 代码:
class Solution {
public int fillCups(int[] amount) {
Arrays.sort(amount);
if (amount[1] == 0) return amount[2];
amount[1]--; amount[2]--;
return 1 + fillCups(amount);
}
}
C++ 代码:
class Solution {
public:
int fillCups(vector<int>& amount) {
sort(amount.begin(), amount.end());
if (amount[1] == 0) return amount[2];
amount[1]--; amount[2]--;
return 1 + fillCups(amount);
}
};
Python 代码:
class Solution:
def fillCups(self, amount: List[int]) -> int:
amount.sort()
if amount[1] == 0:
return amount[2]
amount[1] -= 1
amount[2] -= 1
return 1 + self.fillCups(amount)
TypeScript 代码:
function fillCups(amount: number[]): number {
amount.sort((a, b) => a - b);
if (amount[1] === 0) return amount[2];
amount[1] -= 1;
amount[2] -= 1;
return 1 + fillCups(amount);
};
amount
的长度固定为 3
,因此排序消耗可视为常量;每次至少会消耗两杯水,直到递归结束或只剩下一种水。复杂度为我们已经知道可以通过「每次取剩余数量最多且不为 0
的水成对」来实现最少生成次数。
那么是否存在直接计算最少生成次数的方法,而不是采用逐回合模拟。
考虑对 amount
进行排序,分别使用 a
、b
和 c
代表剩余次数递增的三种种类。
根据
和
的大小关系进行分情况讨论:
,此时每消耗一个
都可以顺带消除一个
或
,因此最少生成次数为
;
,此时考虑其之间的差值
,若能顺利通过
次对
和
的合并,可以将局面转成情况一,最少生成次数为
; 考虑起始是否能先对
和
进行
个回合,由于我们有
,我们只需考虑是否必然有
即可,可通过反证法证明
必然不成立,若有
,则有
=>
,由于
,则有
,与原条件冲突。 最后,为了处理
的奇偶性问题,先用
和
进行
抵消操作,再与
进行抵消
Java 代码:
class Solution {
public int fillCups(int[] amount) {
Arrays.sort(amount);
int a = amount[0], b = amount[1], c = amount[2];
if (a + b <= c) return c;
else return (a + b - c + 1) / 2 + c;
}
}
C++ 代码:
class Solution {
public:
int fillCups(vector<int>& amount) {
sort(amount.begin(), amount.end());
int a = amount[0], b = amount[1], c = amount[2];
if (a + b <= c) return c;
else return (a + b - c + 1) / 2 + c;
}
};
Python 代码:
class Solution:
def fillCups(self, amount: List[int]) -> int:
amount.sort()
a, b, c = amount
if a + b <= c:
return c
else:
return (a + b - c + 1) // 2 + c
TypeScript 代码:
function fillCups(amount: number[]): number {
amount.sort((a, b) => a - b);
const [a, b, c] = amount;
if (a + b <= c) return c;
else return Math.floor((a + b - c + 1) / 2) + c;
};
amount
的长度固定为 3
,因此排序消耗可视为常量,整体复杂度为