leetcode--762. 二进制表示中质数个计算置位

• 题目：给你两个整数 left 和right，在闭区间[left, right]范围内，统计并返回 计算置位位数为质数 的整数个数。计算置位位数 就是二进制表示中 1 的个数。例如，21的二进制表示 10101 有 3 个计算置位。¹

• 示例：

输入：left = 6, right = 10
输出：4
解释：
6 -> 110 (2 个计算置位，2 是质数)
7 -> 111 (3 个计算置位，3 是质数)
9 -> 1001 (2 个计算置位，2 是质数)
10-> 1010 (2 个计算置位，2 是质数)
共计 4 个计算置位为质数的数字。
# 示例 2
输入：left = 10, right = 15
输出：5
解释：
10 -> 1010 (2 个计算置位, 2 是质数)
11 -> 1011 (3 个计算置位, 3 是质数)
12 -> 1100 (2 个计算置位, 2 是质数)
13 -> 1101 (3 个计算置位, 3 是质数)
14 -> 1110 (3 个计算置位, 3 是质数)
15 -> 1111 (4 个计算置位, 4 不是质数)
共计 5 个计算置位为质数的数字。

• 提示：
  1 <= left <= right <= 106
0 <= right - left <= 104

• 思路：

定义一个list列表存储每个元素的计算置位位数
定义一个new_list列表来存储为质数的计算置位位数
2和1不是质数，所以要考虑怎么处理
返回结果为new_list的长度

• 解法：

class Solution:
    def hasAlternatingBits(self, n: int) -> bool:
        list = []
        new_list = []
        for single_num in range(left, right + 1):
            count = 0
            str = bin(single_num)[2:]
            for i in str:
                if i == '1':
                    count += 1
            list.append(count)
        for i in list:
            if i == 2:
                new_list.append(i)
            elif i != 2 and i != 1:
                tag = 0
                for j in range(2, i):
                    if i % j == 0:
                        tag = 1
                        break
                if tag == 0:
                    new_list.append(i)
        return len(new_list)

• 思路：

定义一个方法判断是否为质数，在这里列出了20以内的质数，以便于更好的判断，就不用一个一个去算去判断
定义一个计数函数，循环遍历题目给出的区间，如果符合以上函数的条件则计数+1
返回count的值

• 解法二：由于数据量比较大，所以不把列表弄出来，只统计最后的值

class Solution:
    def countPrimeSetBits(self, left, right):
        count = 0
        for num in range(left, right + 1):
            if self.isPrimeNumber(bin(num).count('1')):
                count += 1
        return count

    def isPrimeNumber(self, num) -> bool:
        prime = [2, 3, 5, 7, 11, 13, 17, 19]
        if num in prime:
            return True
        else:
            return False

---

1. 来源：力扣（LeetCode）
   链接：https://leetcode-cn.com/problems/prime-number-of-set-bits-in-binary-representation ↩︎