leetcode位运算的题

最新推荐文章于 2024-10-14 18:52:56 发布

分子美食家

最新推荐文章于 2024-10-14 18:52:56 发布

阅读量73

点赞数

文章标签： leetcode bit

本文链接：https://blog.csdn.net/weixin_40083227/article/details/103145590

版权

leetcode 371
不用加减计算两个数的和


class Solution(object):
    def getSum(self, a, b):
        """
        circuit full-adder
        since Python don't restrict to 32bit, we need
         1. Masking
         2. Overflow handling
        :type a: int
        :type b: int
        :rtype: int
        """
        MAX = 0x7FFFFFFF
        MSK = 0xFFFFFFFF

        carry = (a & b) << 1
        out = a ^ b

        # convert to 32 bit
        carry &= MSK
        out &= MSK

        if carry != 0:
            return self.getSum(out, carry)
        else:
            # handle overflow
            if out < MAX:
                return out
            else:  # negative
                return ~(out ^ MSK)

leetcode89 graycode
格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。

给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。格雷编码序列必须以 0 开头。

示例 1:

输入: 2
输出: [0,1,3,2]
解释:
00 - 0
01 - 1
11 - 3
10 - 2

对于给定的 n，其格雷编码序列并不唯一。
例如，[0,2,3,1] 也是一个有效的格雷编码序列。

00 - 0
10 - 2
11 - 3
01 - 1
示例 2:

输入: 0
输出: [0]
格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异.给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。格雷编码序列必须以 0 开头。示例 1:输入: 2
输出: [0,1,3,2]
解释:
00 - 0
01 - 1
11 - 3
10 - 2
对于给定的 n，其格雷编码序列并不唯一。
例如，[0,2,3,1] 也是一个有效的格雷编码序列。

00 - 0
10 - 2
11 - 3
01 - 1
示例 2:

输入: 0
输出: [0]
解释: 我们定义格雷编码序列必须以 0 开头。
给定编码总位数为 n 的格雷编码序列，其长度为 2n。当 n = 0 时，长度为 20 = 1。
因此，当 n = 0 时，其格雷编码序列为 [0]。

class Solution:
    def grayCode(self, n):
        """
        Graycode: The reflected binary code solves this problem by changing only one switch at a time, so there is never
        any ambiguity of position,
        Dec  Gray   Binary
         0   000    000
         1   001    001
         2   011    010
         3   010    011
         4   110    100
         5   111    101
         6   101    110
         7   100    111


        Algorithm:
        Dec  Gray   Binary
         0     0    000
         1     1    001

         2    11    010
         3    10    011

         4   110    100
         5   111    101
         6   101    110
         7   100    111

        k-bit graycodes is the reversed sequence of (k-1)-bit graycodes appending 1 at the most significant bit
        :param n:
        :return: list of integers (dec_repr)
        """
        if n==0:
            return [0]
        result = [0, 1]

        for num_of_bit in range(2, n+1):
            msb = 1<<num_of_bit-1
            for element in reversed(result):
                result.append(msb+element)

        return result


    def grayCode_math(self, n):
        """
        a-th gray code is a>>1 XOR a
        :param n:
        :return: list of integers (dec_repr)
        """
        return [(x>>1)^x for x in range(1<<n)]

leetcode 190 颠倒二进制位

class Solution:
    def reverseBits(self, n):
        """
        %2 /2
        """
        ret = 0
        BITS = 32
        for i in range(BITS):
            ret += n&1
            if i == BITS-1:
                break
            ret <<= 1
            n >>= 1

        return ret

leetcode191 汉明距离,二进制数中位1的个数

编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。示例 1：
输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1’。
示例 2：
输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1’。
示例 3：
输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1’。

class Solution:
    def hammingWeight(self, n):
        """
        /2 and %2
        """
        cnt = 0
        while n:
            cnt += n&1
            n >>= 1

        return cnt

leetcode201 数字范围内的按位与

给定范围 [m, n]，其中 0 <= m <= n <= 2147483647，返回此范围内所有数字的按位与（包含 m, n 两端点）。
示例 1:
输入: [5,7]
输出: 4
示例 2:
输入: [0,1]
输出: 0


class Solution:
    def rangeBitwiseAnd(self, m, n):
        """
        Brute force O(N), which is suitable for all bit operations not just AND.

        Observation:
        After enumerating some example, we have the following observation:
        * The numbers \in [m, n] will enumerate all possible 0, 1 in bits starting from LSB except for left header of 1
        * Left header of 1's is will be result

        left header
        :type m: int
        :type n: int
        :rtype: int
        """
        pos = 0
        while m != n:
            pos += 1
            m >>= 1
            n >>= 1

        return n << pos  # or m << pos

leetcode 231 如何判断一个数是不是二的幂

给定一个整数，编写一个函数来判断它是否是 2 的幂次方。

class Solution:
    def isPowerOfTwo(self, n):
        """
        Bit manipulation
        :type n: int
        :rtype: bool
        """
        if n <= 0:
            return False

        return n & (n - 1) == 0

leetcode 260 只出现一次的数

给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。找出只出现一次的那两个元素。
示例 :
输入: [1,2,1,3,2,5]
输出: [3,5]

class Solution:
    def singleNumber(self, nums):
        """
        Constant space
        :type nums: list[int]
        :rtype: list[int]
        """
        bits = 0
        for elt in nums:
            bits ^= elt

        rightmost_bit_set = bits & -bits
        a = 0
        b = 0
        for elt in nums:
            if elt & rightmost_bit_set:
                a ^= elt
            else:
                b ^= elt

        return a, b