用筛选法求300以内素数python

可以使用以下代码来使用筛选法求300以内的素数：

# 初始化一个长度为300的列表，全部赋值为True
is_prime = [True] * 300

# 和1不是素数，将其标记为False
is_prime[] = is_prime[1] = False

# 从2开始遍历到根号300
for i in range(2, int(300 ** .5) + 1):
    # 如果当前数是素数，将其倍数标记为False
    if is_prime[i]:
        for j in range(i * i, 300, i):
            is_prime[j] = False

# 输出所有素数
for i in range(2, 300):
    if is_prime[i]:
        print(i)

运行结果为：

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
101
103
107
109
113
127
131
137
139
149
151
157
163
167
173
179
181
191
193
197
199
211
223
227
229
233
239
241
251
257
263
269
271
277
281
283
293

相关问题

用筛选法求100以内素数python

### 回答1：
可以使用以下代码来使用筛选法求100以内的素数：

# 初始化一个长度为101的列表，全部赋值为True
is_prime = [True] * 101
# 和1不是素数，将其标记为False
is_prime[] = is_prime[1] = False

# 从2开始遍历到100
for i in range(2, 101):
    # 如果当前数是素数
    if is_prime[i]:
        # 将其倍数全部标记为False
        for j in range(i * i, 101, i):
            is_prime[j] = False

# 输出所有素数
for i in range(2, 101):
    if is_prime[i]:
        print(i)

运行结果为：

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

### 回答2：
素数是指只能被1和自身整除的正整数，而1不符合这个定义，因此100以内的素数只有2到97这96个。我们可以通过使用筛选法来找出这些素数。

筛选法的基本思路是：从小到大枚举每个数，对于每个素数，将其倍数标记为合数（即非素数），排除掉所有被标记的数并标记剩余的素数。最终留下的未被标记的数字即为所求的素数。

以下是用Python语言实现筛选法求出100以内素数的代码：

def find_primes(n):
    primes = [True] * (n + 1)  # 初始假设所有数都是素数
    primes[0] = False
    primes[1] = False  # 1不是素数，标记为False
    
    for i in range(2, int(n ** 0.5) + 1):  # 从第一个素数2开始枚举，一直枚举到根号n
        if primes[i]:  # 如果当前数是素数
            for j in range(i * i, n + 1, i):  # 将其倍数标记为合数
                primes[j] = False  # 标记为False
    
    return [i for i in range(n + 1) if primes[i]]  # 返回所有未被标记的素数

我们定义了一个名为`find_primes`的函数，输入参数`n`表示要求到的最大范围，此处为100。首先创建一个长度为`n+1`的列表`primes`，将其全部初始化为True，然后将1和0对应位置标记为False，因为它们不是素数。接着从2开始枚举到根号n，对于每一个素数，将其倍数标记为False，最终返回未被标记的素数。

我们可以用以下命令调用该函数，输出100以内素数的列表：

print(find_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]

通过筛选法，我们成功地求出了100以内所有的素数。该算法时间复杂度为$O(nloglogn)$，是一种比较高效的求素数方法。

### 回答3：
素数是只能被1和自身整除的正整数，而非素数则能够被多个正整数整除。在 Python 中，我们可以用筛选法求100以内的素数。

首先，我们需要创建一个100个元素的列表，初始化为True。这个列表的下标代表着对应的数是否是素数。我们可以通过下标值来判断一个数是否为素数，如果是True，则说明该数是素数。

接下来，我们从2开始，将列表中2的倍数、3的倍数、4的倍数……直至10（因为超过10的倍数已经超过了100，不需要再筛选）都标记为False，因为它们都不是素数。接着，我们再从3开始，将3的倍数、4的倍数、5的倍数……直至33（同理，超过33的倍数已经超过了100，不需要再筛选）都标记为False。接下来，我们重复这个流程，直至在某一步操作中，我们的筛子里的最大整数的平方大于100。

最后，我们遍历这个列表，输出所有下标值对应的布尔值为True的数，即100以内的全部素数。

具体实现如下：

def sieve_of_eratosthenes(n):
    is_prime = [True] * (n + 1)
    is_prime[0], is_prime[1] = False, False

    i = 2
    while i * i <= n:
        if is_prime[i]:
             j = i * 2
             while j <= n:
                 is_prime[j] = False
                 j += i
        i += 1

    return [x for x in range(n + 1) if is_prime[x]]


print(sieve_of_eratosthenes(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]

以上就是用筛选法求100以内素数的实现方法，这种方法的时间复杂度是 O(nloglogn)，效率比较高。

python用筛选法求100以内素数

### 回答1：
筛选法是一种常见的求解素数的方法，可以用Python语言实现。具体步骤如下：

1. 创建一个长度为101的列表，用来存储100以内的数字，列表中的每个元素都初始化为True，表示该数字是素数。

2. 从2开始，依次遍历列表中的每个数字，如果该数字是素数，则将它的倍数标记为False，表示它们不是素数。

3. 遍历完列表后，所有未被标记为False的数字都是素数，将它们输出即可。

下面是Python代码实现：

# 创建一个长度为101的列表，用来存储100以内的数字
is_prime = [True] * 101

# 从2开始，依次遍历列表中的每个数字
for i in range(2, 101):
    # 如果该数字是素数，则将它的倍数标记为False
    if is_prime[i]:
        for j in range(i * 2, 101, i):
            is_prime[j] = False

# 输出所有未被标记为False的数字，即素数
for i in range(2, 101):
    if is_prime[i]:
        print(i, end=' ')

输出结果为：

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

以上就是用Python实现筛选法求100以内素数的方法。

### 回答2：
素数是指只能被 1 和本身整除的数，比如2、3、5、7、11等都是素数。求解素数是算法领域的一个经典问题，本文将介绍如何利用 Python 语言通过筛选法求解 100 以内的素数。

筛选法又称埃氏筛法，因为其思想来源于古希腊数学家埃拉托斯特尼（Eratosthenes）的思想。该算法的基本思想是从小到大枚举所有自然数，对于每个质数，如果其小于等于它的平方根，则遍历该质数的所有倍数，并将它们标记为合数。这样，当遍历完所有小于等于 100 的数后，未被标记的数字即为素数。

下面是用 Python 3.0 实现该算法的代码：

#定义一个列表来储存2到100的所有自然数
num_list = list(range(2,101))
#存放素数的空列表
prime = []

while len(num_list) > 0:
    #弹出列表中第一个数（即最小值）
    p = num_list.pop(0)
    #将弹出的数加入素数列表
    prime.append(p)
    #筛去列表中p的倍数
    for i in num_list:
        if i % p == 0:
            num_list.remove(i)

print(prime)

代码逐行解释：

1. 定义一个列表，该列表包含了 2 到 100 之间的所有自然数

# 定义一个列表来储存2到100的所有自然数
num_list = list(range(2,101))

2. 定义一个空列表，用于储存素数

# 存放素数的空列表
prime = []

3. 使用 while 循环，只要 num_list 列表中还有数，就一直循环

while len(num_list) > 0:

4. 弹出列表中第一个数，即最小值

p = num_list.pop(0)

5. 将弹出的数加入素数列表

prime.append(p)

6. 使用 for 循环，遍历 num_list 中所有数，将 p 的倍数都从 num_list 中删除

for i in num_list:
    if i % p == 0:
        num_list.remove(i)

7. 循环结束后，未被删除的数就是 100 以内的所有素数

print(prime)

总结：Python 语言通过筛选法求解 100 以内的素数非常简单，只需要按照上述步骤编写代码即可。此外，人们常常使用的是厄拉多塞筛法和欧拉筛法，在实际使用中还需要特别注意算法的性能问题，以获取更快的执行速度。

### 回答3：
要用python求出100以内的所有素数，可以使用筛选法，也称为埃氏筛或爱拉托逊斯筛法。

首先，我们可以建立一个长度为101的数组，表示从0到100的数字。数组的每个元素都默认为1，代表这个数字是素数。然后我们从2开始，依次将2的倍数、3的倍数、4的倍数……筛选掉。

具体实现就是，对于每个数字i（i从2到100），如果它是素数（数组中对应元素为1），则把它的所有倍数（除它本身外）都标记为非素数（对应数组元素设为0）。这一步可以用两个循环实现，外层循环遍历2到100，内层循环依次将当前数字i的2倍、3倍、4倍……标记为非素数。

最后，再遍历一遍数组，将所有元素值为1的下标输出即为100以内的素数。

下面是具体实现的python代码：

nums = [1]*101  # 初始化数组，全都默认为素数（1）
for i in range(2, 11):  # 从2到10依次遍历
    if nums[i]:  # 如果当前数字i是素数
        for j in range(2*i, 101, i):  # 将当前数字i的2倍、3倍、4倍……都标记为非素数
            nums[j] = 0

primes = []  # 用列表记录所有素数
for i in range(2, 101):  # 再次遍历数组
    if nums[i]:  # 如果当前数字是素数，将它的下标加入列表
        primes.append(i)

print(primes)  # 输出素数列表

这段代码的输出结果为：

[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]

可以看到，输出结果包含了所有100以内的素数。