当前位置：首页 > news >正文

华为不同职级，薪资待遇一览表

news 2024/10/22 18:11:56

华为

之前发过华为 OD 薪资一览表，不少同学表示十分意外，这 OD 待遇都比不少中小厂要好了，而且还和正编一样有加班费、年终奖和基本福利（带薪年假、夜宵、班车、加班打车报销）。

怎么说呢，大家要是先看华为正编待遇，再来看华为 OD 待遇，可能感觉又会有所不同 🤣🤣🤣

在了解华为正编员工薪资之前，先来了解一下华为职级（与薪资待遇强相关）。

华为的大级（职级）分为 13级~22级，23级及以上属于高层管理层，在华为内网上不显示，每个大级（职级）又分为 A/B/C 三个小级。

对于新入职的本科应届毕业生，通常从最低的 13C 级开始起步，然后每年晋升两个小级。

从级别分布来看，工作年限不足三年的基本都是 13 级，工作年限不足五年的基本都是 14 级，五年以上工作年限的，基本都在 15级~18级这个区间，普通人很难越过 18 级，在华为职级定义里面，19级~22级都是属于专家级别。

好了，对华为职级有基本概念后，我们再看看不同职级对应的薪资区间：

13级：Base 20W~26W，年终奖 3W~6W，无股权，总包 23W~32W
14级：Base 26W~30W，年终奖 5W~8W，股权 1W~4W，总包 32W~42W
15级：Base 30W~38W，年终奖 7W~12W，股权 5W~8W，总包 42W~58W
16级：Base 38W~46W，年终奖 8W~16W，股权 10W~16W，总包 56W~78W
17级：Base 46W~68W，年终奖 18W~26W，股权 20W~30W，总包 84W~124W
18级：Base 70W~85W，年终奖 35W~50W，股权为 30W~50W，总包 125W~185W

看完这个薪资，或许你就理解一个现象：网上这么多从华为离职的网友，他们对华为有着诸多的不满，但唯独从来不说华为小气。

如果这时候把华为 OD 的薪资待遇拉出来比较，你就会发现，同一职级，华为 OD 用最高的 base 来算，年终奖也按最高的 4 个月来算（中位数 2~4 个月），也要比同级华为正编的区间下限要低上一大截（对具体数据感兴趣的，可以点击文章开头的链接去看）。

对此，你有什么想说的？看完华为正编待遇，再看看自己的，能代入到什么级别当中？

...

回归主题。

来一道和「华为」无关的算法题。

题目描述

平台：LeetCode

题号：338

给定一个非负整数 num。

对于 0 ≤ i ≤ num 范围中的每个数字 i，计算其二进制数中的的数目并将它们作为数组返回。

示例 1:

输入: 2

输出: [0,1,1]

示例 2:

输入: 5

输出: [0,1,1,2,1,2]

进阶:

给出时间复杂度为的解答非常容易。但你可以在线性时间内用一趟扫描做到吗？
要求算法的空间复杂度为。
你能进一步完善解法吗？要求在 C++ 或任何其他语言中不使用任何内置函数（如 C++ 中的 __builtin_popcount）来执行此操作。

模拟

这道题要对每个数进行统计，因此不会有比更低的做法。

而很容易想到的朴素做法是对每个数进行「位运算」计数，每个数都是位的，因此是一个的做法。

Java 代码：

class Solution {
    public int[] countBits(int n) {
        int[] ans = new int[n + 1];
        for (int i = 0; i <= n; i++) ans[i] = getCnt(i);
        return ans;
    }
    int getCnt(int u) {
        int ans = 0;
        for (int i = 0; i < 32; i++) ans += (u >> i) & 1;
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    vector<int> countBits(int n) {
        vector<int> ans(n + 1);
        for (int i = 0; i <= n; i++) ans[i] = getCnt(i);
        return ans;
    }
    int getCnt(int u) {
        int ans = 0;
        for (int i = 0; i < 32; i++) ans += (u >> i) & 1;
        return ans;
    }
};

Python 代码：

class Solution:
    def countBits(self, n: int) -> List[int]:
        ans = [0] * (n + 1)
        for i in range(n + 1):
            ans[i] = self.getCnt(i)
        return ans

    def getCnt(self, u):
        ans = 0
        for i in range(32):
            ans += (u >> i) & 1
        return ans

TypeScript 代码：

function countBits(n: number): number[] {
    const ans: number[] = new Array(n + 1).fill(0);
    for (let i = 0; i <= n; i++) ans[i] = getCnt(i);
    return ans;
}
function getCnt(u: number): number {
    let ans = 0;
    for (let i = 0; i < 32; i++) ans += (u >> i) & 1;
    return ans;
}

时间复杂度：
空间复杂度：使用与输入同等规模的空间存储答案。复杂度为

动态规划

事实上，这道题是有严格的解法的，要求复杂度又是输出方案的题，通常就是递推的 DP 题。

用已算出的值去凑出要算的值。

那么对于这类问题我们该如何考虑呢？一般是靠经验，如果实在没见过这类题型的话，我们就需要在纸上画一下，分析一下我们「朴素做法的最后一步」是怎么进行的。

不失一般性的，假设当前我要统计的数的 i，i 对应的二进制表示是 00000...0010100101（共 32 位）

如果我们是使用「朴素解法」求解的话，无论是从高位进行统计，还是从低位进行统计，最后一位扫描的都是边缘的数（如果是 1 就计数，不是 1 就不计数）。

「从低位到高位」，最后一步在扫描 「最高位」之前，「统计出 1 的个数应该等同于将 i 左移一位，并在最低位补 0，也就是等于 ans[i << 1]，这时候就要求我们在计算 i 的时候 i << 1 已经被算出来（从大到小遍历）」
「从高位到低位」，最后一步在扫描 「最低位」之前，「统计出 1 的个数应该等同于将 i 右移一位，并在最高位补 0，也就是等于 ans[i >> 1]，这时候就要求我们在计算 i 的时候 i >> 1 已经被算出来（从小到大遍历）」

通过「对「朴素做法」的最后一步分析」，转移方程就出来了：

当 「从大到小遍历」 ：
当 「从小到大遍历」 ：

Java 代码（P1）：

class Solution {
    // 从大到小遍历
    public int[] countBits(int n) {
        int[] ans = new int[n + 1];
        for (int i = n; i >= 0; i--) {
            // 如果计算 i 所需要的 i << 1 超过 n，则不存储在 ans 内，需要额外计算
            int u = i << 1 <= n ? ans[i << 1] : getCnt(i << 1);
            // ans[i] =「i << 1 所包含的 1 的个数」 + 「i 的最高位是否为 1」
            ans[i] = u + ((i >> 31) & 1);
        } 
        return ans;
    }
    int getCnt(int u) {
        int ans = 0;
        for (int i = 0; i < 32; i++) ans += (u >> i) & 1;
        return ans;
    }
}

Java 代码（P2）：

class Solution {
    // 从小到大遍历
    public int[] countBits(int n) {
        int[] ans = new int[n + 1];
        // ans[i] = 「i >> 1 所包含的 1 的个数」+「i 的最低位是否为 1」
        for (int i = 1; i <= n; i++) ans[i] = ans[i >> 1] + (i & 1);
        return ans;
    }
}

C++ 代码（P2）：

class Solution {
public:
    vector<int> countBits(int n) {
        vector<int> ans(n + 1);
        for (int i = 1; i <= n; i++) {
            ans[i] = ans[i >> 1] + (i & 1);
        }
        return ans;
    }
};

Python 代码（P2）：

class Solution:
    def countBits(self, n: int) -> List[int]:
        ans = [0] * (n + 1)
        for i in range(1, n + 1):
            ans[i] = ans[i >> 1] + (i & 1)
        return ans

TypeScript 代码（P2）：

function countBits(n: number): number[] {
    const ans: number[] = new Array(n + 1).fill(0);
    for (let i = 1; i <= n; i++) {
        ans[i] = ans[Math.floor(i >> 1)] + (i & 1);
    }
    return ans;
}