阿里员工自曝：某多多的4轮面试都通过了，但到了谈薪资的环节，

发表于

HR 的为难

又是一期「排雷+心理按摩」，正在密谋年底跳槽的同学需要额外注意。

起源是我看到了这么一篇帖子分享：

一位目前应该还是在职的阿里巴巴的员工，前后花了一个多月的时间，顺利通过了某多多的 4 轮面试。

按道理，4 轮面试都过了，流程也差不多进入尾声了。

这时候如果再因为一些非硬性指标，未能谈成，会尤其可惜。

沉没成本嘛，很好理解。

然而，就在候选人觉得一切顺利的时候，却遭遇了 HR 的“特殊”对待。

其实就是谈薪的时候，HR 需要候选人的上一份工作的薪资证明。

候选人显示开具了税前收入证明，被 HR 拒绝，要求开具银行流水。

候选人再提供了带公章的银行流水，再次被 HR 拒绝，要求开具工资单加交税证明。

此时候选人有点不耐烦了，说「要不算了吧」，结果对方直接挂电话了 🤣

从这件事上，看得出这位 HR 很不专业。

需要的材料没有一次说明清楚，在候选人表达不满的时候，不是选择进行安抚说明，而是直接挂掉电话，似乎就是在等候选人主动放弃岗位一样。

再细看评论区，发现有同样经历的不止楼主一人：

这位网友也是面完 4 轮，到谈薪阶段，该网友给出报价后，遭遇 HR 的冷漠拒绝：只说给不到，也不明说该岗位的薪资范围。

另外一位，则是上份工作是在华为的网友爆料：

给 HR 提供的个税截图被质疑真实性，还提出个税中的收入金额是否包含报销费用等问题，引发候选人的不满，直接放弃入职。

…

确实，有时候我们很难判断 HR 是真的缺乏专业性，还是因为不想招人了而进行的故意拖延。

但我们又无法要求将 HR 沟通的这一步进行前置，这不现实。

目前所能做的最合理的做法只能是：求职过程中，有些公司的流程快，有些公司流程慢，无论快慢，都以发 offer 为准，不要将流程的繁琐视为沉没成本，如果在已经离职的情况下，尽量多家面试并行投递推进，既可以帮助自己快速进入面试状态，也不会落入流程走了一个多月，到之后没谈拢的局面。

…

回归主线。

现在的大厂面试，不管校招还是社招，去哪都得做算法面试题。

来一道「华为」面试真题。

题目描述

平台：LeetCode

题号：524

给你一个字符串 s 和一个字符串数组 dictionary 作为字典。

找出并返回字典中最长的字符串，该字符串可以通过删除 s 中的某些字符得到。

如果答案不止一个，返回长度最长且字典序最小的字符串。

如果答案不存在，则返回空字符串。

示例 1：

1
2
3
ini复制代码输入：s = "abpcplea", dictionary = ["ale","apple","monkey","plea"]

输出："apple"

示例 2：

1
2
3
ini复制代码输入：s = "abpcplea", dictionary = ["a","b","c"]

输出："a"

提示：

  • 1<=s.length<=10001 <= s.length <= 10001<=s.length<=1000
  • 1<=dictionary.length<=10001 <= dictionary.length <= 10001<=dictionary.length<=1000
  • 1<=dictionary[i].length<=10001 <= dictionary[i].length <= 10001<=dictionary[i].length<=1000
  • s 和 dictionary[i] 仅由小写英文字母组成

排序 + 双指针 + 贪心

根据题意，我们需要找到 dictionary 中为 s 的子序列，且「长度最长（优先级 111）」及「字典序最小（优先级 222）」的字符串。

数据范围全是 100010001000。

我们可以先对 dictionary 根据题意进行自定义排序：

  1. 长度不同的字符串，按照字符串长度排倒序；
  2. 长度相同的，则按照字典序排升序。

然后我们只需要对 dictionary 进行顺序查找，找到的第一个符合条件的字符串即是答案。

具体的，我们可以使用「贪心」思想的「双指针」实现来进行检查：

  1. 使用两个指针 i 和 j 分别代表检查到 s 和 dictionary[x] 中的哪位字符；
  2. 当 s[i] != dictionary[x][j]，我们使 i 指针右移，直到找到 s 中第一位与 dictionary[x][j] 对得上的位置，然后当 i 和 j 同时右移，匹配下一个字符；
  3. 重复步骤 222，直到整个 dictionary[x] 被匹配完。

证明：对于某个字符 dictionary[x][j] 而言，选择 s 中 当前 所能选择的下标最小的位置进行匹配，对于后续所能进行选择方案，会严格覆盖不是选择下标最小的位置，因此结果不会变差。

Java 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Java复制代码class Solution {
    public String findLongestWord(String s, List<String> dictionary) {
        Collections.sort(dictionary, (a,b)->{
            if (a.length() != b.length()) return b.length() - a.length();
            return a.compareTo(b);
        });
        int n = s.length();
        for (String ss : dictionary) {
            int m = ss.length();
            int i = 0, j = 0;
            while (i < n && j < m) {
                if (s.charAt(i) == ss.charAt(j)) j++;
                i++;
            }
            if (j == m) return ss;
        }
        return "";
    }
}

C++ 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
C++复制代码class Solution {
public:
    string findLongestWord(string s, vector<string>& dictionary) {
        sort(dictionary.begin(), dictionary.end(), [](const string& a, const string& b) {
            if (a.length() != b.length()) return b.length() < a.length();
            return a < b;
        });
        int n = s.length();
        for (const string& word : dictionary) {
            int m = word.length();
            int i = 0, j = 0;
            while (i < n && j < m) {
                if (s[i] == word[j]) j++;
                i++;
            }
            if (j == m) return word;
        }
        return "";
    }
};

Python 代码：

1
2
3
4
5
6
7
8
9
10
11
12
Python复制代码class Solution:
    def findLongestWord(self, s: str, dictionary: List[str]) -> str:
        dictionary.sort(key=lambda x: (-len(x), x))
        n = len(s)
        for word in dictionary:
            m = len(word)
            i, j = 0, 0
            while i < n and j < m:
                if s[i] == word[j]: j += 1
                i += 1
            if j == m: return word
        return ""

TypeScript 代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
TypeScript复制代码function findLongestWord(s: string, dictionary: string[]): string {
    dictionary.sort((a, b) => {
        if (a.length !== b.length) return b.length - a.length;
        return a.localeCompare(b);
    });
    const n = s.length;
    for (const word of dictionary) {
        const m = word.length;
        let i = 0, j = 0;
        while (i < n && j < m) {
            if (s[i] === word[j]) j++;
            i++;
        }
        if (j === m) return word;
    }
    return "";  
};
  • 时间复杂度：令 n 为 s 的长度，m 为 dictionary 的长度。排序复杂度为 O(mlog⁡m)O(m\log{m})O(mlogm)；对 dictionary 中的每个字符串进行检查，单个字符串的检查复杂度为 O(min⁡(n,dictionary[i]))≈O(n)O(\min(n, dictionary[i]))\approx O(n)O(min(n,dictionary[i]))≈O(n)。整体复杂度为 O(mlog⁡m+m×n)O(m\log{m} + m \times n)O(mlogm+m×n)
  • 空间复杂度：O(log⁡m)O(\log{m})O(logm)

我是宫水三叶，每天都会分享算法题解，并和大家聊聊近期的所见所闻。

欢迎关注，明天见。

更多更全更热门的「笔试/面试」相关资料可访问排版精美的 合集新基地 🎉🎉

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%