00后小破站员工"开盒"用户事件，后续来了

"开盒"事件

这两天，关于「2025 年 1 月 B 站员工"开盒"（公开曝光他人隐私）用户并删除用户视频」的事件有了新的进展。

可能有读者还没听说这事儿，这里简单梳理一下时间线。

事情的起因，是 B 站员工袁某某（Next0820）在某个游戏视频底下回复了一条 22 年的评论，先是通过收入对 B 站用户（黄金鼠塔）进行了嘲讽：

双方随后开始产生争执，过程中，该员工透露自己"身份不一般"，并借助内部人员优势对用户进行"开盒"恐吓：

此时该工作人员将自己账号的头像改成了受害者头像黑白照片。

但此等恐吓并未吓到这位 B 站用户，甚至还被用户回了一句"我身份证拍的很帅" 🤣🤣🤣

再之后，该工作人员开始进行了下一步行动：向用户网页端注入代码跳转到显示"你的账号已经被封禁！"的界面，且删除用户在 B 站的所有的稿件和动态。

跳转的原理十分简单暴力：通过给线上网页版的代码插入一段 JS，针对某些用户会跳转到特定界面。

这位 B 站用户平常使用的是客户端，短期并未受到影响 🤣🤣🤣

但很快，另外一位 B 站用户（罗德兰屑罗素）爆料也遇到了相同的遭遇。由于这位用户日常使用的是网页版，受到影响后，把这事儿通过工单的形式上报给官方，经过调查核实后，官方给出了对应的处理方案：

1. 确认是内部员工，行为触及底线，已进行开除处理；
2. 准备将该情况上报到监管部门；
3. 内部对这个事情再做一次通报批评，引以为戒，相关主管人员也进行处罚；
4. 对被删除的内容，进行恢复处理；

对于此事件，虽然性质恶劣，但官方处理方案还算得体。一些网友将「个人行为」上升到「平台调性」，我觉得也不甚合适。尤其涉事人员还是位 00 后，实在不好点评。

但作为"程序员"对于此事能够发生（且不止一次）还是觉得十分震惊，为什么一个"前端工程师"能够如此随意查看线上用户的隐私数据，而且还能如此随意修改线上代码，内部一点 review 都没有吗，这有点属于草台到极致了。

对此，你怎么看？你平时看 B 站多吗，和 B 站网友评论/弹幕的情况多吗？欢迎评论区交流。

...

回归主题。

来一道和「校招」相关的算法题。

题目描述

平台：LeetCode

题号：442

给你一个长度为 $n$ 的整数数组 nums，其中 nums 的所有整数都在范围 $[1, n]$ 内，且每个整数出现一次或两次。请你找出所有出现 两次 的整数，并以数组形式返回。

你必须设计并实现一个时间复杂度为 $O(n)$ 且仅使用常量额外空间的算法解决此问题。

示例 1：

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

输出：[2,3]

示例 2：

输入：nums = [1,1,2]

输出：[1]

示例 3：

输入：nums = [1]

输出：[]

提示：

• $n = nums.length$
• $1 <= n <= 10^5$
• $1 <= nums[i] <= n$
• nums 中的每个元素出现一次或两次

原地哈希

给定数组长度为 $n$，且所有数范围在 $[1, n]$，找出出现次数超过一次的所有数字。

利用值域与数字下标空间大小的等同关系，我们可以构造一种对应“关系”，使得每个数出现在它应该出现的位置：对于值为 $k$ 的数字，我们将其应该出现在的位置定为 $k - 1$。

基于此，我们从前往后遍历 $nums$，并尝试将当前处理到的 $nums[i]$ 放到目标位置 $nums[i] - 1$ 处。如果一个数在尝试移动到它应该出现的位置时，发现 $nums[nums[i] - 1] = nums[i] (nums[i] - 1 \neq i)$，则说明该数字出现了超过一次。此时我们将 $nums[i]$ 加入答案，由于此时没有发生交换，而 $nums[i]$ 占用的仍是其他数字的目标位置，为了防止 $nums[i]$ 与其他数字发生交换后，再次被检验并重复加入答案，我们将 $nums[i]$ 置为负数，并在遍历过程中跳过负数。

Java 代码：

class Solution {
    public List<Integer> findDuplicates(int[] nums) {
        List<Integer> ans = new ArrayList<>();
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            int t = nums[i];
            if (t < 0 || t - 1 == i) continue;
            if (nums[t - 1] == t) {
                ans.add(t);
                nums[i] *= -1;
            } else {
                int c = nums[t - 1];
                nums[t - 1] = t;
                nums[i--] = c;
            }
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> findDuplicates(vector<int>& nums) {
        vector<int> ans;
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            int t = nums[i];
            if (t < 0 || t - 1 == i) continue;
            if (nums[abs(t) - 1] == t) {
                ans.push_back(t);
                nums[i] *= -1;
            } else {
                int c = nums[abs(t) - 1];
                nums[abs(t) - 1] = t;
                nums[i--] = c;
            }
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def findDuplicates(self, nums: List[int]) -> List[int]:
        ans = []
        n, i = len(nums), 0
        while i < n:
            t = nums[i]
            if t >= 0 and t - 1 != i:
                if nums[abs(t) - 1] == t:
                    ans.append(t)
                    nums[i] *= -1
                else:
                    c = nums[abs(t) - 1]
                    nums[abs(t) - 1] = t
                    nums[i] = c
                    i -= 1
            i += 1
        return ans

TypeScript 代码：

function findDuplicates(nums: number[]): number[] {
    const ans = [];
    const n = nums.length;
    for (let i = 0; i < n; i++) {
        const t = nums[i];
        if (t < 0 || t - 1 === i) continue;
        if (nums[Math.abs(t) - 1] === t) {
            ans.push(t);
            nums[i] *= -1;
        } else {
            const c = nums[Math.abs(t) - 1];
            nums[Math.abs(t) - 1] = t;
            nums[i--] = c;
        }
    }
    return ans;
};

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