需要帮助！使用python计算素数

计算小于非负数n的素数。我已经创建了以下代码，但复杂度太高。如果有人能给我一个更好的解决方案，我将不胜感激

import math
class Solution(object):
    def countPrimes(self, n):
        PrimeCount=0
        primelist=[]
        for i in range(2,n):
            if self.primeCheck1(i,primelist)==True:
                primelist.append(i)       #try2 with new logic
                PrimeCount=PrimeCount+1

        return PrimeCount



    def primeCheck1(self,n,primelist):
        flag=False
        if n==2:
            return True
        elif n==3:
            return True
        sqroot=int(math.sqrt(n))

        for j in range(0,sqroot):
            if n%primelist[j]==0:
                flag=True
                break

        if flag!=True:
            return True
        else:
            return False

---

首先使用

pip安装symphy

安装symphy软件包。然后试试这个：

import sympy
PrimeCount=0
n=int(input("Number?"))
for elem in range(n):
   if sympy.isPrime(elem):
      PrimeCount+=1
print(PrimeCount)

---

您可以使用按位筛选算法

SIZE = 1000000
LIMIT=int(math.sqrt(SIZE)+1)

prime = []

def sieve():
    for i in range(SIZE/32):
        prime[i]=0xffff
        prime[0]&=~(1<<(1%32))

    for i in range(LIMIT+1):
        if(prime[i/32]&(1<<(i%32))):
            for j in range(2*i, SIZE, j=j+i):
                prime[j/32]&=~(1<<(j%32))

def isPrime(n):
        return prime[n/32]&(1<<(n%32))

SIZE=1000000
极限=整数（数学sqrt（大小）+1）
素数=[]
def sieve（）：
对于范围内的i（尺寸/32）：
素数[i]=0xffff
prime[0]&=~（1我喜欢创建一个prime列表并使用该列表检测较大的prime的方式。您的代码比需要的复杂，这是对的，特别是不需要您的
标志
变量

您在
primeCheck1（）
方法中也错过了一些可以加快速度的技巧。因为我的Python不存在，所以这是类似Python的伪代码。我假设您能够转换它

def primeCheck1(self, n, primelist):

  # Handle even numbers.
  if n % 2 == 0:
        # The only even prime is 2.
        return (n == 2)

  # Handle multiples of 3.
  if n % 3 == 0:
        return (n == 3)

  # Handle remaining numbers.
  sqroot = int(math.sqrt(n))

  for j in range(0, sqroot):
    if n % primelist[j] == 0:
      return False  # Not a prime number.

  # If we get this far then the number is prime.
  return True

end primeCheck1

在一个次要的问题上，你有一个不把代码隔开的习惯：
a==b
而不是
a==b
。使用空格作为分隔符可以使代码更容易阅读。
对代码进行重新编写，使其速度提高3倍，计算少于一百万的素数：

class Solution(object):
    def countPrimes(self, n):
        primelist = []

        for i in range(2, n):
            if self.primeCheck(i, primelist):
                primelist.append(i)

        return len(primelist)

    def primeCheck(self, n, primes):

        if n < 2:
            return False

        if n % 2 == 0:  # 2 is the only even prime
            return n == 2

        for prime in primes:

            if prime * prime > n:  # easier to square many than sqroot one
                return True

            if n % prime == 0:  # divisible by a prime, not a prime
                return False

        return True

solution = Solution()

print(solution.countPrimes(1000000))

class Solution(object):

    def __init__(self):
        self.sieve = None

    def countPrimes(self, n):

        self.sieve = [True] * n

        if n > 0:
            self.sieve[0] = False
            if n > 1:
                self.sieve[1] = False

        def mark_sieve(prime):
            for index in range(prime + prime, n, prime):
                self.sieve[index] = False

        for number in range(2, int(n ** 0.5) + 1):
            if self.sieve[number]:
                mark_sieve(number)

        return sum(self.sieve)

solution = Solution()

print(solution.countPrimes(1000000))

这里的胜利是消除所有那些昂贵的分区。
def count\u prime（prime）：
def count_primes(prime):

    check=2
    main_res=0

    while check <= prime:
        result=0
        control=1
        while control <= check: 
            if check%control==0:
                result+=1
                control+=1
            else:
                control+=1
        if result==2:
            main_res+=1


        check+=1

    return main_res


# Test for COUNT PRIME
#print(count_primes(100))

检查=2
main_res=0
检查时，我非常确定OP必须为学校做这件事。因此使用
sympy
会破坏整个作业的目的。此外，Python中没有
++
运算符。您需要使用
+=1
。oops使用java有一段时间了。这里修复了它：这可能更好地发布在Did的可能副本上您或投票支持它的人实际上尝试运行它？首先，它似乎不计算素数，只生成素数。其次，它似乎不是可运行的Python，例如
def isPrime（int n）：
，
范围（2*i，SIZE，j=j+i）
，等等。我只是给他看了一个降低时间复杂度的代码示例。问题是如何找到更复杂的素数。你发布的代码虽然有效，但复杂度并没有更好。