绩效沟通有 +2 和 hr，是不是寄了？

大礼包

一般互联网打工人领大礼包（被公司辞退，赔偿 N+1），有两个比较常见的时间点，一个是「公司集体优化」，另外一个就是「绩效面谈时刻」。

最近是字节开奖绩效的时间点，也是首次新绩效方案的推行落地。

在之前的全员会议上，高管就解读了新绩效方案，其中包括一条建议是：I 绩效明确为无法履职，需加速识别，优化人效。

再结合实际情况，字节本次绩效会"整体后移"，可以知道会有一大批原来定义为 M- 绩效的同学，这次面谈会提心吊胆。

今天逛脉脉的时候，就看到一位字节算法岗的网友在发帖分享，说自己和 +1（直属领导）约了自己明天绩效沟通，结果看到把 hr 和 +2 也拉上了：

正常情况下，绩效面谈，只会有 +1 在场，这次 +2 和 hr 都在，尤其是 hr，那说明大概率没有好事。

于是网友连夜向网友发问，如何在面谈开始前，先和 +1 委婉商量，要个 N+1：

但根据字节的规则，其实 N+1 不用争取，正常如果是绩效过低，被公司劝退，都是会给 N+1，这也是字节"高效"的地方之一，根本不用来回扯皮，该给的直接给。

要到赔偿是一方面，自己被评低绩效是另外一方面。

楼主自认为自己产出还可以，而且根据自己了解到的信息，一般绩效劝退，+1 都会提前打好"预防针"，但自己这次却是被直接通知，十分意外。

同层的网友回复，给出了真相：产出是相对的，总要有人来背指标。

这也是互联网绩效淘汰机制的不合理性：机制直接假设了不可能全员及格，总要淘汰掉一些绩效尾部的员工，腾出位置给新血，难怕新血可能还不如被淘汰的老员工。那没关系，接着淘汰，接着换。

一些原本应该同为 M- 绩效的字节网友，近期也快被约谈了，迫不及待想要向楼主"取经"，不断刷评，想要知道个后续：

但也有一些比楼主更早"尘埃落定"的字节同学，已经给自己安排好了"躺平计划"：

同样在绩效面谈时，拉上了 +2 和 hr，已经沟通完了，还没打算直接领包走人，而是准备开摆几个人，同时准备一下找工作，到时再被动领大礼包。

对此，你怎么看？你司会有绩效过低直接给大礼包的规定吗？欢迎评论区交流。

...

回归主题。

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

题目描述

平台：LeetCode

题号：735

给定一个整数数组 asteroids，表示在同一行的行星。

对于数组中的每一个元素，其绝对值表示行星的大小，正负表示行星的移动方向（正表示向右移动，负表示向左移动）。

每一颗行星以相同的速度移动，找出碰撞后剩下的所有行星。

碰撞规则：

1. 两个行星相互碰撞，较小的行星会爆炸。
2. 如果两颗行星大小相同，则两颗行星都会爆炸。
3. 两颗移动方向相同的行星，永远不会发生碰撞。

示例 1：

输入：asteroids = [5,10,-5]

输出：[5,10]

解释：10 和 -5 碰撞后只剩下 10 。 5 和 10 永远不会发生碰撞。

示例 2：

输入：asteroids = [8,-8]

输出：[]

解释：8 和 -8 碰撞后，两者都发生爆炸。

示例 3：

输入：asteroids = [10,2,-5]

输出：[10]

解释：2 和 -5 发生碰撞后剩下 -5 。10 和 -5 发生碰撞后剩下 10 。

提示：

• $2 <= asteroids.length <= 10^4$
• $-1000 <= asteroids[i] <= 1000$
• $asteroids[i] != 0$

栈

由于碰撞抵消总是从相邻行星之间发生，我们可以使用「栈」来模拟该过程。

从前往后处理所有的 $ats[i]$，使用栈存储当前未被抵消的行星，当栈顶元素方向往右，当前 $ats[i]$

Java 代码：

class Solution {
    public int[] asteroidCollision(int[] asteroids) {
        Deque<Integer> d = new ArrayDeque<>();
        for (int t : asteroids) {
            boolean ok = true;
            while (ok && !d.isEmpty() && d.peekLast() > 0 && t < 0) {
                int a = d.peekLast(), b = -t;
                if (a <= b) d.pollLast();
                if (a >= b) ok = false;
            }
            if (ok) d.addLast(t);
        }
        int sz = d.size();
        int[] ans = new int[sz];
        while (!d.isEmpty()) ans[--sz] = d.pollLast();
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> asteroidCollision(vector<int>& asteroids) {
        deque<int> d;
        for (int t : asteroids) {
            bool ok = true;
            while (ok && !d.empty() && d.back() > 0 && t < 0) {
                int a = d.back(), b = -t;
                if (a <= b) d.pop_back();
                if (a >= b) ok = false;
            }
            if (ok) d.push_back(t);
        }
        vector<int> ans(d.begin(), d.end());
        return ans;
    }
};

Python 3 代码：

class Solution:
    def asteroidCollision(self, asteroids: List[int]) -> List[int]:
        stk = []
        for t in asteroids:
            ok = True
            while ok and stk and stk[-1] > 0 and t < 0:
                a, b = stk[-1], -t
                if a <= b:
                    stk.pop(-1)
                if a >= b:
                    ok = False
            if ok:
                stk.append(t)
        return stk

TypeScript 代码：

function asteroidCollision(asteroids: number[]): number[] {
    const stk = new Array<number>()
    for (const t of asteroids) {
        let ok = true
        while (ok && stk.length > 0 && stk[stk.length - 1] > 0 && t < 0) {
            const a = stk[stk.length - 1], b = -t
            if (a <= b) stk.pop()
            if (a >= b) ok = false
        }
        if (ok) stk.push(t)
    }
    return stk
};

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$