值得去公司（完整榜单）

值得去公司

近日，脉脉出了一份《职得去公司》榜单：

前三名是 TAM（老牌巨头百度日常掉队）。

大家肯定好奇这个榜单怎么统计出来的。

这上面写的是根据「雇主指数」进行排名，广义的雇主指数包括了多个维度，包括但不限于员工满意度、员工流失率、员工留存率、薪酬竞争力、员工福利、企业文化和价值观、品牌声誉、晋升机会 等多个维度，因此广义上的雇主指数分数越高，代表这家公司越值得去，没毛病。

但脉脉这一份榜单其实并不依据广义上的雇主指数。不是脉脉不想，而是这些数据几乎不可能完全收集。

那么榜单怎么来的，在榜单说明中给出了答案：

根据「脉脉用户对该企业相关内容的浏览量、互动量、正负向情绪」等用户行为大数据，通过建模计算而得。

这就很有意思了，但我也有另外一个担心，互联网黑话，模型能分出来正负向情绪吗？另外我如果只发一个 [狗头] 表情，阁下又如何应对？

但无论如何，有榜单就图一乐好了，以下贴出最新的完整榜单：

...

回归主题。

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

题目描述

平台：LeetCode

题号：190

颠倒给定的 32 位无符号整数的二进制位。

提示：

• 请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
• 在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 2 中，输入表示有符号整数 -3，输出表示有符号整数 -1073741825。

进阶:

• 如果多次调用这个函数，你将如何优化你的算法？

示例 1：

输入: 00000010100101000001111010011100

输出: 00111001011110000010100101000000

解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596，
     因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。

示例 2：

输入：11111111111111111111111111111101

输出：10111111111111111111111111111111

解释：输入的二进制串 11111111111111111111111111111101 表示无符号整数 4294967293，
     因此返回 3221225471 其二进制表示形式为 10111111111111111111111111111111 。

提示：

• 输入是一个长度为 32 的二进制字符串

「对称位」构造

一个简单的做法是对输入的 做诸位检查。

「如果某一位是 1 的话，则将答案相应的对称位置修改为 1。」

Java 代码：

public class Solution {
    public int reverseBits(int n) {
        int ans = 0;
        for (int i = 0; i < 32; i++) {
            if (((n >> i) & 1) == 1) ans |= (1 << (31 - i));
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int reverseBits(uint32_t n) {
        int ans = 0;
        for (int i = 0; i < 32; i++) {
            if ((n >> i) & 1) ans |= (1 << (31 - i));
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def reverseBits(self, n: int) -> int:
        ans = 0
        for i in range(32):
            if (n >> i) & 1:
                ans |= (1 << (31 - i))
        return ans

• 时间复杂度： int 固定 位，循环次数不随输入样本发生改变。复杂度为
• 空间复杂度：

「逐位分离」构造

另外一种做法是，每次都使用 的最低一位，使用 的最低一位去更新答案的最低一位，使用完将 进行右移一位，将答案左移一位。

「相当于每次都用 的最低一位更新成 的最低一位。」

Java 代码：

public class Solution {
    public int reverseBits(int n) {
        int ans = 0, cnt = 32;
        while (cnt-- > 0) {
            ans <<= 1;
            ans += (n & 1);
            n >>= 1;
        }
        return ans;
    }
}

C++ 代码：

class Solution {
public:
    int reverseBits(uint32_t n) {
        int ans = 0, cnt = 32;
        while (cnt-- > 0) {
            ans <<= 1;
            ans += (n & 1);
            n >>= 1;
        }
        return ans;
    }
};

Python 代码：

class Solution:
    def reverseBits(self, n: int) -> int:
        ans = 0
        for _ in range(32):
            ans <<= 1
            ans += (n & 1)
            n >>= 1
        return ans

• 时间复杂度： int 固定 32 位，循环次数不随输入样本发生改变。复杂度为
• 空间复杂度：

分组互换

事实上，可以对于长度固定的 int 类型，我们可以使用「分组构造」的方式进行。

「两位互换 -> 四位互换 -> 八位互换 -> 十六位互换。」

代码：

public class Solution {
    public int reverseBits(int n) {
        n = ((n & 0xAAAAAAAA) >>> 1)  | ((n & 0x55555555) << 1);
        n = ((n & 0xCCCCCCCC) >>> 2)  | ((n & 0x33333333) << 2);
        n = ((n & 0xF0F0F0F0) >>> 4)  | ((n & 0x0F0F0F0F) << 4);
        n = ((n & 0xFF00FF00) >>> 8)  | ((n & 0x00FF00FF) << 8);
        n = ((n & 0xFFFF0000) >>> 16) | ((n & 0x0000FFFF) << 16);
        return n;
    }
}

C++ 代码：

class Solution {
public:
    int reverseBits(uint32_t n) {
        n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1);
        n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2);
        n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4);
        n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8);
        n = ((n & 0xFFFF0000) >> 16) | ((n & 0x0000FFFF) << 16);
        return n;
    }
};

Python 代码：

class Solution:
    def reverseBits(self, n: int) -> int:
        n = ((n & 0xAAAAAAAA) >> 1) | ((n & 0x55555555) << 1)
        n = ((n & 0xCCCCCCCC) >> 2) | ((n & 0x33333333) << 2)
        n = ((n & 0xF0F0F0F0) >> 4) | ((n & 0x0F0F0F0F) << 4)
        n = ((n & 0xFF00FF00) >> 8) | ((n & 0x00FF00FF) << 8)
        n = ((n & 0xFFFF0000) >> 16) | ((n & 0x0000FFFF) << 16)
        return n

• 时间复杂度：如何进行互换操作取决于 int 长度。复杂度为
• 空间复杂度：

「请不要认为「方法三」一定就比「方法一」等直接采用循环的方式更快。此类做法的最大作用，不是处理 int，而是处理更大位数的情况，在长度只有 32 位的 int 的情况下，该做法不一定就比循环要快（该做法会产生多个的中间结果，导致赋值发生多次，而且由于指令之间存在对 n 数值依赖，可能不会被优化为并行指令），这个道理和对于排序元素少的情况下，我们会选择「冒泡排序」而不是「归并排序」是一样的，因为「冒泡排序」常数更小。」

最后

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

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

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

欢迎关注，明天见。

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