[Swift]LeetCode762. 二进制表示中质数个计算置位 | Prime Number of Set Bits in Binary Representation

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10533081.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given two integers L and R, find the count of numbers in the range [L, R] (inclusive) having a prime number of set bits in their binary representation.

(Recall that the number of set bits an integer has is the number of 1s present when written in binary. For example, 21 written in binary is 10101 which has 3 set bits. Also, 1 is not a prime.) 

Example 1:

Input: L = 6, R = 10
Output: 4
Explanation:
6 -> 110 (2 set bits, 2 is prime)
7 -> 111 (3 set bits, 3 is prime)
9 -> 1001 (2 set bits , 2 is prime)
10->1010 (2 set bits , 2 is prime) 

Example 2:

Input: L = 10, R = 15
Output: 5
Explanation:
10 -> 1010 (2 set bits, 2 is prime)
11 -> 1011 (3 set bits, 3 is prime)
12 -> 1100 (2 set bits, 2 is prime)
13 -> 1101 (3 set bits, 3 is prime)
14 -> 1110 (3 set bits, 3 is prime)
15 -> 1111 (4 set bits, 4 is not prime) 

Note:

1. L, R will be integers L <= R in the range [1, 10^6].
2. R - L will be at most 10000.

---

给定两个整数 L 和 R ，找到闭区间 [L, R] 范围内，计算置位位数为质数的整数个数。

（注意，计算置位代表二进制表示中1的个数。例如 21 的二进制表示 10101 有 3 个计算置位。还有，1 不是质数。）

示例 1:

输入: L = 6, R = 10
输出: 4
解释:
6 -> 110 (2 个计算置位，2 是质数)
7 -> 111 (3 个计算置位，3 是质数)
9 -> 1001 (2 个计算置位，2 是质数)
10-> 1010 (2 个计算置位，2 是质数)

示例 2:

输入: L = 10, R = 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 不是质数)

注意:

1. L, R 是 L <= R 且在 [1, 10^6] 中的整数。
2. R - L 的最大值为 10000。

---

Runtime: 16 ms

Memory Usage: 18.6 MB

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        
        var count = 0
        for i in L...R {
            let nonzeroBitCount = i.nonzeroBitCount
            
            if isPrime(nonzeroBitCount) {
                count += 1
            }
        }
        
        return count
    }
    
    private func isPrime(_ num: Int) -> Bool {
        guard num > 1 else {
            return false
        }
        
        guard num != 2 else {
            return true
        }
        
        guard num & 1 == 1 else {
            return false
        }
        
        var i = 3
        
        while i * i <= num, num % i != 0 {
            i += 2
        }
        
        return i * i > num
    }
}

---

36ms

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        
        var count = 0
        
        for i in L...R {
            
            let bitCode = i.nonzeroBitCount
            if isSmallPrime(bitCode) {
                count += 1
            }
        }
        
        return count
    }
    
    func isSmallPrime(_ i: Int) -> Bool {
        
        switch i {
        case 2,3,5,7,11,13,17,19:
            return true
        default:
            return false
        }
    }
}

---

52ms

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        var  count = 0
        for num in L...R {
            
            let bits = getSetBits(num)
            
            if isPrime(bits) {
                count += 1
            }
            
        }
        
        return count
    }
    
    
    func getSetBits(_ num : Int) -> Int {
        var count = 0
        var v = num
        
        while v >= 1 {
            v &= v - 1 
            count += 1
        }
        return count
    }
    
    func isPrime(_ n : Int ) -> Bool {
        if n <= 1 { return false }
        if n <= 3 { return true }
        
        if n % 2 == 0 || n % 3 == 0 { return false }
        
        var i = 5
        while Int(pow(Double(i), Double(i))) <= n {
            if  n % i == 0 || n%(i+2) == 0 {
                return false
            }

            i = i + 6
        }
        
        return true
    }
}

---

96ms

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        var res = 0
        let primes = Set([2, 3, 5, 7, 11, 13, 17, 19])

        for i in L...R {
            res += primes.contains(bitCount(i)) ? 1 : 0
        }

        return res
    }

    private func bitCount(_ n: Int) -> Int {
        var count = 0
        var n = n

        while n > 0 {
            n &= n - 1
            count += 1
        }

        return count
    }
}

---

372ms

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        
        var count = 0
        for i in L...R {
            let nonzeroBitCount = i.nonzeroBitCount
            
            var isPrime = true
            if nonzeroBitCount == 1 {
                isPrime = false
            } else {
                for factor in stride(from: 2, to: nonzeroBitCount, by: 1) {
                    if nonzeroBitCount % factor == 0 {
                        isPrime = false
                        break
                    }
                }
            }
            
            count += isPrime ? 1 : 0
        }
        
        return count
    }
}

---

460ms

class Solution {
  func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
    let primeMap = [0,0,1,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,1,0]
    
    var count = 0
    
    for num in L...R {
      var n = num
      var oneCount = 0
      while n > 0 {
        if n & 1 == 1 {
          oneCount += 1
        }
        n >>= 1
      }
      count += primeMap[oneCount]
    }
    
    return count
  }
}

---

620ms

class Solution {
    // 输入区间为 1...10^6, 既最大为20位, 直接取20以内质数
    let c = [2, 3, 5, 7, 11, 13, 17, 19]
    
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        return (L...R).reduce(0) {
            $0 + (c.contains($1.nonzeroBitCount) ? 1 : 0)
        }
    }
}

---

944ms

class Solution {
    
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        var numPrime = 0
        let primes = [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
        for i in L...R {
            var numOnes = 0
            for j in 0..<32 {
                if (i >> j) & 1 != 0 {
                    numOnes += 1
                }
            }
            if primes.contains(numOnes) {
                numPrime += 1
            }
        }
        return numPrime
    }
    
}

---

1460ms

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
    var result: Int = 0
    for i in L...R {
        let binaryString = String(i, radix: 2)
        if isPrime(numberOfSetBits(binaryString)) { result += 1 }
    }

    return result
}

func isPrime(_ num: Int) -> Bool {
    guard num >= 2 else { return false }

    for i in 2..<num {
        if num % i == 0 { return false }
    }
    
    return true
}

func numberOfSetBits(_ text: String) -> Int {
    guard text != "" else { return 0 }
    var result: Int = 0
    
    text.characters.forEach { (char) in
        if char == "1" { result += 1 }
    }
    
    return result
  }
}

---

1840ms

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        var statistics: [Int] = Array(repeating: 0, count: R-L+1)
        for (i, v) in (L...R).enumerated() {
            // 二进制操作数
            var vt = v
            // 二进制置位累加值
            var va = 0
            while vt > 0 {
                if (vt >> 1) * 2 != vt {
                    va += 1
                }
                vt = vt >> 1
            }
            statistics[i] = va
        }
        return filterPrimeNumber(for: statistics)
    }
    // 输入区间为 1...10^6, 既最大为20位, 直接取20以内质数
    func filterPrimeNumber(for array: [Int]) -> Int {
        let c = [2, 3, 5, 7, 11, 13, 17, 19]
        var accumulator = 0
        array.forEach({
            if c.contains($0) { accumulator += 1 }
        })
        return accumulator
    }
}

---

1948ms

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        var count = 0 
        var out: [Int] = []
        for i in L...R {
            let bin = String(i, radix: 2)
            var numberOfOnes = 0 
            for char in bin {
                if char == "1" {
                    numberOfOnes += 1
                }
            }
            if isPrime(number: numberOfOnes) {
                out.append(i)
            }
        }
        return out.count 
    }
    
    func isPrime(number: Int) -> Bool {
     return number > 1 && !(2..<number).contains { number % $0 == 0 }
    }
}

---

2648ms

class Solution {
    func countPrimeSetBits(_ L: Int, _ R: Int) -> Int {
        var result = 0
        for v in L...R {
            if isPrime(Array(String(v, radix: 2)).filter {$0 == "1"}.count) {
                result += 1
            }
        }
        
        return result
    }
    
    func isPrime(_ number: Int) -> Bool {
        return number > 1 && !(2..<Int(sqrt(Double(number)))+1).contains { number % $0 == 0 }
    }
}