字节面试怼了面试官，会被封杀吗？

最新推荐文章于 2025-05-12 17:49:31 发布

宫水三叶的刷题日记

最新推荐文章于 2025-05-12 17:49:31 发布

阅读量970

点赞数 18

文章标签：后端

本文链接：https://blog.csdn.net/weixin_33243821/article/details/142520570

版权

字节

日常逛社区，发现一篇很"另类"的求助帖：

贴主在字节二面的时候，觉得面试官全程不耐烦，中途实在没忍住，直言道"要是不愿意面可以不面"，但转头就后悔了，跑来社区求助，担心自己的会在"字节"被封杀。

这真的很难评 🤣🤣🤣

首先，这种行为不该发生，能在面试过程中直接说出这样的话，一定程度候选人自己也是属于"不耐烦"的那一类。

其次，这种行为发生了也没必要后悔，因为一般的公司面试，一面都是入职后的平级同事，二面都是入职后的 +1 领导，楼主在二面遇到的那个"不合眼缘"的面试官，绝大概率是将来的 +1 领导。

众所周知，打工人的职场体验，几乎取决于直属领导的为人，在面试阶段都合不来，将来合作只会摩擦不断，现在被刷其实可以看作是一种止损。

本次面试肯定是没救了，至于说会不会被字节拉黑，将来面其他部门也都被刷？

我认为是不会，前面说到了，二面面试官其实只是入职后的 +1 领导，除非候选人面的岗位职级很高（从帖子描述中的言语，候选人更像是毕业不久的童鞋），否则其实面试官也就是一个小 leader（网友俗称的大头兵），很现实的说，是没有多少实权的。

根本不存在帖子担心的情况，就算招聘系统有这个功能，应该也会在是"系统"或"HR 总监"级别的人才有权限。也就是说除非笔试作弊（会被系统标记拉黑）或者某个 HR 总监进行手动标记（正常要先有 HR 面试记录，以及填写拉黑原因），正常面试根本不会出现拉黑的情况。

...

回归主题。

来一道和「字节跳动」相关的算法题。

题目描述

平台：LeetCode

题号：1764

给你一个长度为 n 的二维整数数组 groups ，同时给你一个整数数组 nums 。

你是否可以从 nums 中选出 n 个不相交的子数组，使得第 i 个子数组与 groups[i]（下标从 0 开始）完全相同，且如果 i > 0 ，那么第 (i-1) 个子数组在 nums 中出现的位置在第 i 个子数组前面。（也就是说，这些子数组在 nums 中出现的顺序需要与 groups 顺序相同）

如果你可以找出这样的 n 个子数组，请你返回 true ，否则返回 false。

如果不存在下标为 k 的元素 nums[k] 属于不止一个子数组，就称这些子数组是不相交的。子数组指的是原数组中连续元素组成的一个序列。

示例 1：

输入：groups = [[1,-1,-1],[3,-2,0]], nums = [1,-1,0,1,-1,-1,3,-2,0]

输出：true

解释：你可以分别在 nums 中选出第 0 个子数组 [1,-1,0,1,-1,-1,3,-2,0] 和第 1 个子数组 [1,-1,0,1,-1,-1,3,-2,0] 。
这两个子数组是不相交的，因为它们没有任何共同的元素。

示例 2：

输入：groups = [[10,-2],[1,2,3,4]], nums = [1,2,3,4,10,-2]

输出：false

解释：选择子数组 [1,2,3,4,10,-2] 和 [1,2,3,4,10,-2] 是不正确的，因为它们出现的顺序与 groups 中顺序不同。
[10,-2] 必须出现在 [1,2,3,4] 之前。

示例 3：

输入：groups = [[1,2,3],[3,4]], nums = [7,7,1,2,3,4,7,7]

输出：false

解释：选择子数组 [7,7,1,2,3,4,7,7] 和 [7,7,1,2,3,4,7,7] 是不正确的，因为它们不是不相交子数组。
它们有一个共同的元素 nums[4] （下标从 0 开始）。

提示：

双指针

为了方便，将 groups 记为 gs。

从前往后处理每个，使用 idx 记录当前使用到 nums 中的哪一位（即的已经用于匹配。

每次尝试从 idx 出发匹配 gs[i]，若能匹配成功，则整段更新；否则将 idx 后移一位，继续尝试匹配 gs[i]。

Java 代码：

class Solution {
    public boolean canChoose(int[][] gs, int[] nums) {
        int m = nums.length, idx = 0;
        out:for (int[] info : gs) {
            for (int j = idx; j + info.length <= m; j++) {
                boolean ok = true;
                for (int k = 0; k < info.length && ok; k++) {
                    if (nums[j + k] != info[k]) ok = false;
                }
                if (ok) {
                    idx = j + info.length;
                    continue out;
                }
            }
            return false;
        }
        return true;
    }
}

C++ 代码（用 ct 模拟 continue tag 效果）：

class Solution {
public:
    bool canChoose(vector<vector<int>>& gs, vector<int>& nums) {
        int m = nums.size(), idx = 0;
        out:for (auto& info : gs) {
            bool ct = false;
            for (int j = idx; j + info.size() <= m; j++) {
                bool ok = true;
                for (int k = 0; k < info.size() && ok; k++) {
                    if (nums[j + k] != info[k]) ok = false;
                }
                if (ok) {
                    idx = j + info.size();
                    ct = true;
                    break;
                }
            }
            if (!ct) return false;
        }
        return true;
    }
};

Python 代码：

class Solution:
    def canChoose(self, gs: List[List[int]], nums: List[int]) -> bool:
        m, idx = len(nums), 0
        for info in gs:
            for j in range(idx, len(nums) - len(info) + 1):
                if all(nums[j + k] == info[k] for k in range(len(info))):
                    idx = j + len(info)
                    break
            else:
                return False
        return True

TypeScript 代码：

function canChoose(gs: number[][], nums: number[]): boolean {
    let m = nums.length, idx = 0;
    for (const info of gs) {
        let ct = false;
        for (let j = idx; j + info.length <= m; j++) {
            let ok = true;
            for (let k = 0; k < info.length && ok; k++) {
                if (nums[j + k] !== info[k]) ok = false;
            }
            if (ok) {
                idx = j + info.length;
                ct = true;
                break;
            }
        }
        if (!ct) return false;
    }
    return true;
};