首次披露，字节跳动在职员工的平均司龄！！

字节司龄

今天，字节召开了全员会，不少高管都参会了，包括了现任字节 CEO 梁汝波和 TikTok 的首席执行官周受资。

会议内容里，大家最关心的，自然是"绩效"和"晋升条件"方面的调整解读。

简单来说：晋升门槛降低了，从前可能会要求两个 M+ 或者一个 E，才能晋升，现在一个 M+，也可以提名了。

不仅如此，活水（内部人才流动机制）要求也降低了，从前活水要求绩效必须是 M+，如今 M- 也有机会。

整体的方向，还是往"降低大家的绩效焦虑"的方向去改革，既然保留了绩效的淘汰作用（明确了 I 的含义就是无法履职，加速识别，优化人效），又降低了因为细微差别导致绩效跨级（M 尾部 & M- 头部），所引发的"冰火两重天"体验。

除此以外，会议还透露了一些有趣的数据，比如"在职员工司龄"和"离职员工司龄"。

在职员工司龄：中位数 2.9 年，平均数 3 年；离职员工司龄：中位数 2.5 年，平均 2.6 年。

这是字节成立 13 年来，首次在内部披露该数据。

从这个数据来看，字节的还算"稳定"，至少网络上盛传的《入职字节一个月，想跑路了》的案例，应该都是个例。

...

回归主题。

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

题目描述

平台：LeetCode

题号：436

给你一个区间数组 intervals，其中  ，且每个  都不同。

区间 的右侧区间可以记作区间 ，并满足 ，且 最小化。

返回一个由每个区间 的右侧区间的最小起始位置组成的数组，如果某个区间 不存在对应的右侧区间，则下标 处的值设为 。

示例 1：

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

输出：[-1]

解释：集合中只有一个区间，所以输出-1。

示例 2：

输入：intervals = [[3,4],[2,3],[1,2]]

输出：[-1,0,1]

解释：对于 [3,4] ，没有满足条件的“右侧”区间。
对于 [2,3] ，区间[3,4]具有最小的“右”起点;
对于 [1,2] ，区间[2,3]具有最小的“右”起点。

示例 3：

输入：intervals = [[1,4],[2,3],[3,4]]

输出：[-1,2,-1]

解释：对于区间 [1,4] 和 [3,4] ，没有满足条件的“右侧”区间。
对于 [2,3] ，区间 [3,4] 有最小的“右”起点。

提示：

• 每个间隔的起点都不相同

排序 + 二分

为了方便，我们称 为 。

对于每个 而言，我们需要在所有满足「 」中找到 值最小的下标 ，并将其记为 。

对于一个特定的 而言，其右端点固定，并且我们只关心目标位置的左端点。

因此我们可以构造一个记录区间左端点的数组 ，并将其进行排序，同时为了记录每个左端点来自于原序列中的那个下标，还需要额外记录原序列下标，即以 二元组的形式进行转存，并根据 排序。

然后从前往后处理每个 ，运用「二分」在 中找到第一个满足左端点 大于等于 的成员 ，将其 即是 的最右区间。

Java 代码：

class Solution {
    public int[] findRightInterval(int[][] its) {
        int n = its.length;
        int[][] clone = new int[n][2];
        for (int i = 0; i < n; i++) clone[i] = new int[]{its[i][0], i};
        Arrays.sort(clone, (a,b)->a[0]-b[0]);
        int[] ans = new int[n];
        for (int i = 0; i < n; i++) {
            int l = 0, r = n - 1;
            while (l < r) {
                int mid = l + r >> 1;
                if (clone[mid][0] >= its[i][1]) r = mid;
                else l = mid + 1;
            }
            ans[i] = clone[r][0] >= its[i][1] ? clone[r][1] : -1;
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> findRightInterval(vector<vector<int>>& its) {
        int n = its.size();
        vector<pair<int, int>> clone;
        clone.reserve(n);
        for (int i = 0; i < n; i++) clone.push_back({its[i][0], i});
        sort(clone.begin(), clone.end());
        vector<int> ans(n);
        for (int i = 0; i < n; i++) {
            int l = 0, r = n - 1;
            while (l < r) {
                int mid = l + r >> 1;
                if (clone[mid].first >= its[i][1]) r = mid;
                else l = mid + 1;
            }
            ans[i] = (clone[r].first >= its[i][1]) ? clone[r].second : -1;
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def findRightInterval(self, its: List[List[int]]) -> List[int]:
        n = len(its)
        clone = [(its[i][0], i) for i in range(n)]
        clone.sort()
        ans = []
        for i in range(n):
            l, r = 0, n - 1
            while l < r:
                mid = l + r >> 1
                if clone[mid][0] >= its[i][1]:
                    r = mid
                else:
                    l = mid + 1
            ans.append(clone[r][1] if clone[r][0] >= its[i][1] else -1)
        return ans

TypeScript 代码：

function findRightInterval(its: number[][]): number[] {
    const n = its.length;
    const clone: [number, number][] = its.map(([start, _], i) => [start, i]);
    clone.sort((a, b) => a[0] - b[0]);
    const ans: number[] = new Array(n).fill(-1);
    for (let i = 0; i < n; i++) {
        let l = 0, r = n - 1;
        while (l < r) {
            const mid = l + r >> 1;
            if (clone[mid][0] >= its[i][1]) r = mid;
            else l = mid + 1;
        }
        ans[i] = clone[r][0] >= its[i][1] ? clone[r][1] : -1;
    }
    return ans;
};

• 时间复杂度：排序复杂度为 ；对于每个 找到最右区间需要进行二分，复杂度为 。整体复杂度为
• 空间复杂度：

双指针（莫队思想）

更进一步，在解法一中我们并没有对求解询问的顺序进行调整，这导致了我们不得不每次都在整个左端点序列中进行二分。

朴素处理询问的方式，需要每次对整个序列进行扫描，复杂度为 。

实际上，如果我们按照「右端点从小到大」的顺序处理询问，其每个询问对应的「最右区间的左端点」也具有单调特性。

因此，我们可以运用莫队思想：「通过调整询问的处理顺序，来减少扫描目标位置的指针移动次数。将其从「必然进行 次移动」优化为「最多不超过 次移动」，从而将 构造答案 的复杂度从 优化为 。」

最后，由于每个 只关心目标位置的「左端点」，因此我们无须对某一段进行分块，而直接使用双指针实现即可。

Java 代码：

class Solution {
    public int[] findRightInterval(int[][] its) {
        int n = its.length;
        int[][] ss = new int[n][2], es = new int[n][2];
        for (int i = 0; i < n; i++) {
            ss[i] = new int[]{its[i][0], i};
            es[i] = new int[]{its[i][1], i};
        }
        Arrays.sort(ss, (a,b)->a[0]-b[0]);
        Arrays.sort(es, (a,b)->a[0]-b[0]);
        int[] ans = new int[n];
        for (int i = 0, j = 0; i < n; i++) {
            int[] cur = es[i];
            int loc = cur[0], idx = cur[1];
            while (j < n && ss[j][0] < loc) j++;
            ans[idx] = j == n ? -1 : ss[j][1];
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> findRightInterval(vector<vector<int>>& its) {
        int n = its.size();
        vector<pair<int, int>> ss, es;
        for (int i = 0; i < n; i++) {
            ss.push_back({its[i][0], i});
            es.push_back({its[i][1], i});
        }
        sort(ss.begin(), ss.end());
        sort(es.begin(), es.end());
        vector<int> ans(n, -1);
        for (int i = 0, j = 0; i < n; i++) {
            auto cur = es[i];
            int loc = cur.first, idx = cur.second;
            while (j < n && ss[j].first < loc) j++;
            ans[idx] = (j == n) ? -1 : ss[j].second;
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def findRightInterval(self, its: List[List[int]]) -> List[int]:
        n = len(its)
        ss = [(its[i][0], i) for i in range(n)]
        es = [(its[i][1], i) for i in range(n)]
        ss.sort()
        es.sort()
        ans = [-1] * n
        j = 0
        for i in range(n):
            cur = es[i]
            loc, idx = cur[0], cur[1]
            while j < n and ss[j][0] < loc:
                j += 1
            ans[idx] = -1 if j == n else ss[j][1]
        return ans

TypeScript 代码：

function findRightInterval(its: number[][]): number[] {
    const n = its.length;
    const ss = its.map(([start, _], i) => [start, i]);
    const es = its.map(([_, end], i) => [end, i]);
    ss.sort((a, b) => a[0] - b[0]);
    es.sort((a, b) => a[0] - b[0]);
    const ans = new Array(n).fill(-1);
    for (let i = 0, j = 0; i < n; i++) {
        const [loc, idx] = es[i];
        while (j < n && ss[j][0] < loc) j++;
        ans[idx] = j == n ? -1 : ss[j][1];
    }
    return ans;
};

• 时间复杂度：排序复杂度为 ；双指针构造答案的复杂度为 。整体复杂度为
• 空间复杂度：

最后

巨划算的 LeetCode 会员优惠通道目前仍可用 ~

使用福利优惠通道 leetcode.cn/premium/?promoChannel=acoier，年度会员 有效期额外增加两个月，季度会员 有效期额外增加两周，更有超大额专属 🧧 和实物 🎁 福利每月发放。

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

欢迎关注，明天见。

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

本文由 mdnice 多平台发布