Question

我尝试了什么：

for num in range(2,50):
    prime = True
    for i in range(2,num):
        if (num%i==0):
            prime = False
    if prime:
       print (num)

结果很好但是禁止以任何方式使用for或while循环，所以有没有其他方法可以在不使用for或while循环的情况下执行它？

Answer 1

如果不使用for或while循环，还有其他方法吗？

是的，您可以使用递归功能：

def prime_number(n, d):
    if n//2 < d:
      return True
    if n%d == 0:
      return False
    return prime_number(n, d+1)

def find_primes(n,i, result):
  if i == n + 1:
    return result
  if prime_number(i, 2):
    result.append(i)
  return find_primes(n, i+1, result)

print(find_primes(100,2, []))

输出

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

此外，您可以使用for loops简化list comprehension。

primes = [n for n in range(2, 50) if all(n % d for d in range(2, n))]

Answer 2

这是愚蠢的，但它有效，所以也许它至少会给你一些想法：

print(list(filter(lambda x: not list(filter(lambda y:x%y == 0, range(2,x))), range(2, 50))))

输出：

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

Answer 3

这解决了打印一个列表，一次一个，每个都在新行上 - 没有View。至于素数列表，你可以作弊。

您的问题中没有任何内容表明您必须计算它们。可以从互联网上获得高达数百万的Primelists - 而不是抓取一些网站并将其送到那里，您的简单案例可以硬编码。

for loop

输出：

print( *[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47], sep = '\n')

所有素数高达50 - 不涉及循环。

Answer 4

这是Sieve of Eratosthenes的递归实现。它使用扩展切片分配来执行主筛分步骤。对于大数字，它将失败RecursionError，但使用默认设置，它可以安全地计算最多990000左右的素数。它没有这个代码更常用的迭代版本那么快，但它比进行简单的暴力因子搜索要快得多。

def rsieve(i, num, stop, seq):
    if i == stop:
        return
    if seq[i]:
        seq[i*i : num : i] = [False] * (1 + (num - 1)//i - i)
    rsieve(i + 1, num, stop, seq)

def primes(num):
    seq = [True] * num
    seq[:2] = [False] * 2
    rsieve(2, num, int(num ** 0.5) + 1, seq)
    return filter(lambda i: seq[i], range(num))

# Test
print(*primes(100))

<强>输出

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

FWIW，您可以通过直接调用lambda“magic”方法将filter函数参数替换为seq.__getitem__，使此代码的运行速度几乎快两倍。也就是说，

return filter(seq.__getitem__, range(num))

直接调用“魔法”方法通常被认为是不好的做法，所以除非你明白自己在做什么，否则请不这样做。 ;）

Answer 5

这是我对@ MihaiAlexandru-Ionut的解决方案的改造，它可以在与Python的默认堆栈大小相冲突之前计算高出3倍，通过消除偶数的素数测试并在广场上停止主要测试root而不是目标的1/2：

def find_primes(n, i=2):

    primes = []

    if i > n:
        return primes

    def is_odd_prime(n, d=3):
        if n < d * d:
            return True

        if n % d == 0:
            return False

        return is_odd_prime(n, d + 2)

    multi = i != 2

    if not multi or is_odd_prime(i):
        primes.append(i)

    return primes + find_primes(n, i + 1 + multi)

print(find_primes(1960))

仍然没有@ PM2Ring筛选解决方案的（堆叠）效率！

Answer 6

这无需使用任何外部库或for / while循环就可以为您提供直至t的所有素数。

t=1000

a=set(range(2,t))
l=map(lambda c:range(2*c,t,c),a)
result=a.difference(*l)

print(sorted(result))

它也不太慢：

>>> Calculating primes up to 1 took 2.599999999997049e-05 seconds
>>> Calculating primes up to 10 took 4.6000000000101515e-05 seconds
>>> Calculating primes up to 100 took 0.00015300000000006975 seconds
>>> Calculating primes up to 1000 took 0.001670999999999978 seconds
>>> Calculating primes up to 10000 took 0.023809999999999998 seconds
>>> Calculating primes up to 100000 took 0.24447599999999992 seconds
>>> Calculating primes up to 1000000 took 3.301934 seconds
>>> Calculating primes up to 10000000 took 42.691604 seconds

使用100000000会产生内存错误

如何在不使用for循环和while循环的情况下在python中打印素数

6 个答案: