跳转至

1009. 十进制整数的反码

题目描述

每个非负整数 N 都有其二进制表示。例如， 5 可以被表示为二进制 "101"，11 可以用二进制 "1011" 表示，依此类推。注意，除 N = 0 外，任何二进制表示中都不含前导零。

二进制的反码表示是将每个 1 改为 0 且每个 0 变为 1。例如，二进制数 "101" 的二进制反码为 "010"。

给你一个十进制数 N，请你返回其二进制表示的反码所对应的十进制整数。

 

示例 1：

输入：5
输出：2
解释：5 的二进制表示为 "101"，其二进制反码为 "010"，也就是十进制中的 2 。

示例 2：

输入：7
输出：0
解释：7 的二进制表示为 "111"，其二进制反码为 "000"，也就是十进制中的 0 。

示例 3：

输入：10
输出：5
解释：10 的二进制表示为 "1010"，其二进制反码为 "0101"，也就是十进制中的 5 。

 

提示：

  1. 0 <= N < 10^9
  2. 本题与 476：https://leetcode.cn/problems/number-complement/ 相同

解法

方法一：位运算

思考

写成二进制再按位取反可以得到补数，但 \(n\) 可达 \(10^9\)，且补数不含前导零对应的高位翻转，\(n=0\) 还需单独得到 \(1\)。

从低到高逐位处理时，只需对 \(n\) 中实际出现过的位取反并写入答案，处理完后 \(n\) 右移为空即停，自然不会碰到更高的零位。

用 \(i\) 记录当前位数，将 \((n\bmod 2)\) 取反后或入 \(\textit{ans}\) 的第 \(i\) 位，直到 \(n\) 变为 \(0\)。

我们首先判断 \(n\) 是否为 \(0\)，如果是，则返回 \(1\)。

接着我们定义两个变量 \(\textit{ans}\) 和 \(i\)，初始化为 \(0\)。然后我们遍历 \(n\)，在每次遍历中，我们将 \(\textit{ans}\) 的第 \(i\) 位设置为 \(n\) 的第 \(i\) 位取反，然后将 \(i\) 加 \(1\)，并且\(n\) 右移 \(1\) 位。

最后返回 \(\textit{ans}\) 即可。

时间复杂度 \(O(\log n)\)，其中 \(n\) 为给定的十进制数。空间复杂度 \(O(1)\)。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Solution:
    def bitwiseComplement(self, n: int) -> int:
        if n == 0:
            return 1
        ans = i = 0
        while n:
            ans |= ((n & 1 ^ 1) << i)
            i += 1
            n >>= 1
        return ans

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class Solution {
    public int bitwiseComplement(int n) {
        if (n == 0) {
            return 1;
        }
        int ans = 0, i = 0;
        while (n != 0) {
            ans |= (n & 1 ^ 1) << (i++);
            n >>= 1;
        }
        return ans;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
class Solution {
public:
    int bitwiseComplement(int n) {
        if (n == 0) {
            return 1;
        }
        int ans = 0, i = 0;
        while (n != 0) {
            ans |= (n & 1 ^ 1) << (i++);
            n >>= 1;
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
func bitwiseComplement(n int) (ans int) {
    if n == 0 {
        return 1
    }
    for i := 0; n != 0; n >>= 1 {
        ans |= (n&1 ^ 1) << i
        i++
    }
    return
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
function bitwiseComplement(n: number): number {
    if (n === 0) {
        return 1;
    }
    let ans = 0;
    for (let i = 0; n; n >>= 1) {
        ans |= ((n & 1) ^ 1) << i++;
    }
    return ans;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
impl Solution {
    pub fn bitwise_complement(mut n: i32) -> i32 {
        if n == 0 {
            return 1;
        }
        let mut ans = 0;
        let mut i = 0;
        while n != 0 {
            ans |= ((n & 1) ^ 1) << i;
            n >>= 1;
            i += 1;
        }
        ans
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class Solution {
    public int BitwiseComplement(int n) {
        if (n == 0) {
            return 1;
        }
        int ans = 0, i = 0;
        while (n != 0) {
            ans |= ((n & 1) ^ 1) << (i++);
            n >>= 1;
        }
        return ans;
    }
}

评论