Leetcode 2523. 范围内最接近的两个质数

1.题目基本信息

1.1.题目描述

给你两个正整数 left 和 right ，请你找到两个整数 num1 和 num2 ，它们满足：

• left <= nums1 < nums2 <= right 。

• nums1 和 nums2 都是 质数 。

• nums2 - nums1 是满足上述条件的质数对中的 最小值 。

请你返回正整数数组 ans = [nums1, nums2] 。如果有多个整数对满足上述条件，请你返回 nums1 最小的质数对。如果不存在符合题意的质数对，请你返回 [-1, -1] 。

1.2.题目地址

https://leetcode.cn/problems/closest-prime-numbers-in-range/description/

2.解题方法

2.1.解题思路

线性筛+二分查找 / 埃氏筛+二分查找

2.2.解题步骤

第一步，预处理。筛选出[2,10*6+1]之间所有的质数，构建primes数组。

第二步，由于筛选出来的primes是有序的，所以可以二分找到[left,right]之间的第一个质数，记其在primes数组中的下标为index。

第三步，遍历index后面的质数，求质数间隔最小的质数对。

3.解题代码

线性筛方法代码

from bisect import bisect_left

class Solution:
    def closestPrimes(self, left: int, right: int) -> List[int]:
        # 思路1：线性筛
        # 第一步，预处理。筛选出[2,10*6+1]之间所有的质数，构建primes数组
        MAX_VAL = 10 ** 6 + 1
        isPrime = [1] * (MAX_VAL + 1)
        primes = []
        for i in range(2, MAX_VAL + 1):
            if isPrime[i]:
                primes.append(i)
            for prime in primes:
                if prime * i < MAX_VAL + 1:
                    isPrime[prime * i] = 0
                else:
                    break
                if i % prime == 0:
                    break
        # print(primes)
        # 第二步，由于筛选出来的primes是有序的，所以可以二分找到[left,right]之间的第一个质数，记其在primes数组中的下标为index
        index = bisect_left(primes, left)
        # 第三步，遍历index后面的质数，求质数间隔最小的质数对
        n = len(primes)
        p = index + 1
        minDiff, result = inf, [-1, -1]
        while p < n and primes[p] <= right:
            if primes[p] - primes[p - 1] < minDiff:
                minDiff = primes[p] - primes[p - 1]
                result = [primes[p - 1], primes[p]]
            p += 1
        return result

埃氏筛方法代码

from bisect import bisect_left

class Solution:
    def closestPrimes(self, left: int, right: int) -> List[int]:
        # 思路2：埃氏筛
        # 第一步，预处理。筛选出[2,10*6+1]之间所有的质数，构建primes数组
        MAX_VAL = 10 ** 6 + 1
        isPrime = [1] * (MAX_VAL + 1)
        primes = []
        for i in range(2, MAX_VAL + 1):
            if isPrime[i]:
                primes.append(i)
                j = i
                while i * j < MAX_VAL + 1:
                    isPrime[i * j] = 0
                    j += 1
        # print(primes)
        # 第二步，由于筛选出来的primes是有序的，所以可以二分找到[left,right]之间的第一个质数，记其在primes数组中的下标为index
        index = bisect_left(primes, left)
        # 第三步，遍历index后面的质数，求质数间隔最小的质数对
        n = len(primes)
        p = index + 1
        minDiff, result = inf, [-1, -1]
        while p < n and primes[p] <= right:
            if primes[p] - primes[p - 1] < minDiff:
                minDiff = primes[p] - primes[p - 1]
                result = [primes[p - 1], primes[p]]
            p += 1
        return result

4.执行结果