腾讯云智开奖，二线城市也有大笔签字费了

最新推荐文章于 2025-04-28 18:17:49 发布

宫水三叶的刷题日记

最新推荐文章于 2025-04-28 18:17:49 发布

阅读量705

点赞数 20

文章标签：后端

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

版权

腾讯云智

腾讯云智是负责"腾讯云"的相关业务，总部在西安，其余办公地点主要分布在二线城市。

前几年总是有「腾讯云智 VS 华为 OD」的 Offer 对比，当时两者的热度属于同一档位。这几年随着华为 OD 部队的不断壮大，加上起步学历背景的水涨船高，腾讯云智的讨论便少了许多。

但实际上腾讯云智的薪资待遇，还是一直在线的。

尤其是其 「有房补（二线城市，每月 1k)、最高 16薪、公积金比例为 12%」 等福利。

本次秋招，腾讯云智的开奖，虽然说不上多惊艳，但在二线城市还是有着满满的竞争力。

西安-运维：本科，12k * 16、每月 1k 房补、公积金 12%、2W~2.4W 签字费
西安-前端：本科，12k * 16、每月 1k 房补、公积金 12%、2W~2.4W 签字费
西安-后端：本科，13k * 16、每月 1k 房补、公积金 12%、2W~2.4W 签字费
武汉-后端：本科，14.5k * 16、每月 1k 房补、公积金 12%、2W~2.4W 签字费

西安和武汉两个城市的开奖情况大差不差，基本开奖范围都在 12k~15k 之间。

签字费可以简单理解为"入职奖金"，只有首年有，一般只会出现在大厂的一线城市 Offer 中。腾讯云智这次在二线城市的 Offer 中基本都给了签字费，而且都在 2W 以上，这点算是比较惊喜。

对此，你怎么看？看惯了那些动辄 20k+ 的校招薪资，是不是觉得腾讯云智的开奖特接地气？

话说大家当年有拿过签字费吗？欢迎评论区交流。

...

回归主题。

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

题目描述

平台：LeetCode

题号：719

数对由整数 a 和 b 组成，其数对距离定义为 a 和 b 的绝对差值。

给你一个整数数组 nums 和一个整数 k，数对由和组成且满足。

返回所有数对距离中第 k 小的数对距离。

示例 1：

输入：nums = [1,3,1], k = 1

输出：0

解释：数对和对应的距离如下：
(1,3) -> 2
(1,1) -> 0
(3,1) -> 2
距离第 1 小的数对是 (1,1) ，距离为 0 。

示例 2：

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

输出：0

示例 3：

输入：nums = [1,6,1], k = 3

输出：5

提示：

二分 + 双指针

根据题意，由于对距离定义使用的是绝对值，因此从原数组中找数对，等价于在排序数组中找数对。

同时由于的范围为，因此我们不能使用复杂度为的「多路归并」做法来做。

利用数据范围，我们知道距离值域范围为，假设所能形成的距离序列为，此时在以第小的距离值为分割点的数轴上，具有「二段性」，记这第小的距离值为：

处于右侧的所有位置（包含） 「必然满足」「序列中值小于等于的数不少于个」；
处于左侧的所有位置（不包含） 「不一定满足」「序列中值小于等于的数不少于个」（当且仅当在序列中不重复，或恰好是连续段距离值中的左端点时，必然不满足）。

因此这本质上是一个满足 1? 特性（而不是 10 特性）的问题，我们可以使用「二分」来找到值。

假设当前我们二分到的值是，利用我们排序好的 nums，我们并不需要真正的构建出序列，即可统计值小于等于的数量：枚举左端点，每次找第一个不满足条件的右端点（由于是第一个不满足条件的值，因此合法右端点范围为，共个），利用 nums 有序，并且所有均为正数，可知会随着增大而逐步增大，即这部分利用「双指针」可实现复杂度。

Java 代码：

class Solution {
    public int smallestDistancePair(int[] nums, int k) {
        Arrays.sort(nums);
        int l = 0, r = (int)1e6;
        while (l < r) {
            int mid = l + r >> 1;
            if (check(nums, mid) >= k) r = mid;
            else l = mid + 1;
        }
        return r;
    }
    int check(int[] nums, int x) {
        int n = nums.length, ans = 0;
        for (int i = 0, j = 1; i < n; i++) {
            while (j < n && nums[j] - nums[i] <= x) j++;
            ans += j - i - 1;
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int smallestDistancePair(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        int l = 0, r = 1e6;
        while (l < r) {
            int mid = l + r >> 1;
            if (check(nums, mid) >= k) r = mid;
            else l = mid + 1;
        }
        return l;
    }
    int check(const vector<int>& nums, int x) {
        int n = nums.size(), ans = 0;
        for (int i = 0, j = 1; i < n; i++) {
            while (j < n && nums[j] - nums[i] <= x) j++;
            ans += j - i - 1;
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def smallestDistancePair(self, nums: List[int], k: int) -> int:
        nums.sort()
        l, r = 0, 10**6
        while l < r:
            mid = l + r >> 1
            if self.check(nums, mid) >= k: 
                r = mid
            else: 
                l = mid + 1
        return r

    def check(self, nums, x):
        n, ans = len(nums), 0
        j = 1
        for i in range(n):
            while j < n and nums[j] - nums[i] <= x:
                j += 1
            ans += j - i - 1
        return ans

TypeScript 代码：

function check(nums: number[], x: number): number {
    let n = nums.length, ans = 0;
    for (let i = 0, j = 1; i < n; i++) {
        while (j < n && nums[j] - nums[i] <= x) j++;
        ans += j - i - 1;
    }
    return ans;
}
function smallestDistancePair(nums: number[], k: number): number {
    nums.sort((a, b) => a - b);
    let l = 0, r = 1000000;
    while (l < r) {
        let mid = l + r >> 1;
        if (check(nums, mid) >= k) r = mid;
        else l = mid + 1;
    }
    return r;
};