tokenpocket钱包app官网下载最新版|写出20以内的所有质数

作者： tokenpocket钱包app官网下载最新版

2024-03-12 15:13:34

Python 输出指定范围内的素数 | 菜鸟教程

菜鸟教程 -- 学的不仅是技术，更是梦想！

首页

HTML

CSS

JavaScript

Vue

Bootstrap

NodeJS

Python3

Python2

Java

C++

SQL

Linux

jQuery

本地书签

首页

HTML

CSS

本地书签

Python3 教程

Python2 教程

Vue3 教程

vue2 教程

Bootstrap3 教程

Bootstrap4 教程

Bootstrap5 教程

Bootstrap2 教程

Python 3 教程

Python3 教程

Python3 简介

Python3 环境搭建

Python3 VScode

Python3 基础语法

Python3 基本数据类型

Python3 数据类型转换

Python3 解释器

Python3 注释

Python3 运算符

Python3 数字(Number)

Python3 字符串

Python3 列表

Python3 元组

Python3 字典

Python3 集合

Python3 条件控制

Python3 循环语句

Python3 编程第一步

Python3 推导式

Python3 迭代器与生成器

Python3 函数

Python3 lambda

Python3 数据结构

Python3 模块

Python3 输入和输出

Python3 File

Python3 OS

Python3 错误和异常

Python3 面向对象

Python3 命名空间/作用域

Python3 标准库概览

Python3 实例

Python 测验

Python3 高级教程

Python3 正则表达式

Python3 CGI编程

Python3 MySQL(mysql-connector)

Python3 MySQL(PyMySQL)

Python3 网络编程

Python3 SMTP发送邮件

Python3 多线程

Python3 XML 解析

Python3 JSON

Python3 日期和时间

Python3 内置函数

Python3 MongoDB

Python3 urllib

Python uWSGI 安装配置

Python3 pip

Python3 operator

Python math

Python requests

Python random

Python 有用的资源

Python AI 绘画

Python statistics

Python hashlib

Python 量化

Python pyecharts

Python3 time clock()方法

Python print() 函数

Python 输出指定范围内的素数

Python3 实例

素数（prime number）又称质数，有无限个。除了1和它本身以外不再被其他的除数整除。

以下实例可以输出指定范围内的素数：

实例(Python 3.0+)

#!/usr/bin/python3

# 输出指定范围内的素数

# take input from the user

lower = int(input("输入区间最小值: "))

upper = int(input("输入区间最大值: "))

for num in range(lower,upper + 1):

# 素数大于 1

if num > 1:

for i in range(2,num):

if (num % i) == 0:

break

else:

print(num)

执行以上程序，输出结果为：

$ python3 test.py

输入区间最小值: 1

输入区间最大值: 100

Python3 实例

Python3 time clock()方法

Python print() 函数

8 篇笔记

写笔记

#0 hizmz hiz***sina.com 53与前面判断是否是质数一样，作者算法中未使用到"开根号法"来节约时间复杂度，同时为加入个数等说明，因此我对其改进如下：

import math

# 输出指定范围内的素数

# 用户输入范围

lower = int(input("输入区间最小值: "))

upper = int(input("输入区间最大值: "))

print("素数结果如下：")

print("="*10)

pri_num = 0

com_num = 0

for num in range(lower, upper + 1):

# 找到其平方根（ √ ），减少算法时间

square_num = math.floor(num ** 0.5)

# 素数大于 1

if num > 1:

for i in range(2, (square_num + 1)):

if (num % i) == 0:

com_num += 1

break

else:

pri_num += 1

print(num)

print("="*10)

print(com_num,'个合数')

print(pri_num,'个素数')

hizmz hizmz hiz***sina.com7年前 (2017-09-14)

#0 Pt idi***g@qq.com 11先定义一个判断素数的函数，然后再输入范围去判断。

# -*- coding: UTF-8 -*-

# Filename : defprime.py

# author ：Pt

def isprime(x):

if x == 1:

return False

k = int(x**0.5)

for j in range(2, k + 1):

if x % j == 0:

return False

return True

lower = int(input("请输入区间最小值："))

upper = int(input("请输入区间最大值："))

for i in range(lower, upper):

if isprime(i):

print(i, end = " ")Pt Pt idi***g@qq.com7年前 (2017-10-04)

#0 风林火山 dra***a_zby@163.com 12prime_number = [x for x in range(int(input('区间最小值：')), int(input('区间最大值：'))) if[] == [y for y in range(2, int(x ** 0.5) + 1) if x % y == 0]]

print(prime_number)风林火山风林火山 dra***a_zby@163.com6年前 (2017-10-15)

#0 Transitive 276***1169@qq.com 5在已经定于的数值中求所有的素数。

#在x**y中求素数，千万别作死求太大的数，会没耐心等结果。

i = 2

x = input("请输入x的值:")

y = input("请输入y的值:")

x = int(x)

y = int(y)

s = x**y

s = int(s)

while ( i < s ):

j = 2

while (j <= (i / j )):

if not (i % j):

break

j = j + 1

if (j > i / j):

print(str(i)+",")

i = i + 1

这个是求梅森素数的:

def meisen(n):

n += 1

while True:

k = n % 2

n = n // 2

if k != 0:

return False

if n == 1:

break

return True

def sushu():

n = 1

while True:

if n == 1 or n == 2 or n == 3:

yield n

else:

m = n//2

flag = False

for i in range(2,m+1):

if n % i == 0:

flag = True

if not flag:

yield n

n += 1

import time

begin_time = time.time()

for i in sushu():

if i > 10000: #改 i >的值可以增加求取范围

break

if meisen(i):

print(i)

end_time = time.time()

print(end_time-begin_time)

begin_time = end_time

Transitive Transitive 276***1169@qq.com5年前 (2019-03-08)

#0 vinson wei***ng_vinson@163.com 13修正重复输出质数的错误:

lower = int(input("输入区间最小值: "))

upper = int(input("输入区间最大值: "))

for num in range(lower,upper + 1):

if num > 1:

for i in range(2,num):

if (num % i) == 0:

break

elif i < (num - 1):

continue

else:

print(num)vinson vinson wei***ng_vinson@163.com5年前 (2019-03-20)

#0 cc河豚 a12***4046@gmail.com 7把版大的改造了下，增加平方根和只從質數判斷是否為質數，算大數字會快很多。

import math

#創建列表儲存質數

listPM = [2]

lower = int(input("最小值: "))

upper = int(input("最大值: "))

#質數從2開始

if upper >= 2:

#平方根減少運算

for num in range(3,upper + 1):

S_num = math.sqrt(num)

#只從質數判斷是否為質數

for i in listPM:

if i > S_num:

listPM.append(num)

break

if (num % i) == 0:

break

#剔除掉小於的質數

listPM = [i for i in listPM if i >= lower]

print(listPM)cc河豚 cc河豚 a12***4046@gmail.com4年前 (2020-01-02)

#0 Kindred 268***8532@qq.com 15hizmz真大佬，不过代码我研究了很久，还是给大佬加上注释如下，并对负数进行改进，如果需要，还可以自行添加对其他字符串进行限定输入。

#输出指定范围内的素数

#非数字字符串会出错，一开始就应该避免错误的发生（限定范围），而不是报错了再来改进，

#可以继续改进用列表输出质数和合数

import math

lower = int(input("输入区间(包括)最小值: "))

upper = int(input("输入区间(包括)最大值: "))

sumzs=0

sumhs=0

print("素数结果如下：")

print("="*10)

pri_num = 0

com_num = 0

for num in range(lower, upper + 1):

if num > 1: # 素数大于 1

square_num = math.floor(num ** 0.5) # 找到其平方根，减少算法时间

#++++++++++++++++++++++++++++++++++++++++++++++++++++++++

for i in range(2, (square_num + 1)): #（2,2）属于空集，不会出错，但也不会执行

if (num % i) == 0: #可以被整除说明是合数

com_num += 1

sumhs+=num

print(num,"是合数")

break #执行到这里说明是合数，跳出里层for和所有else语句，执行完其他语句（比如下面注释掉的）后继续外一层for的下一次循环

else: #不能被依次整除，说明循环完了还是质数，用pass表示占位

pass #继续执行下一句else语句

#这里的else和上面的for属于一个级的，能执行下面的语句说明上面的质数筛选已经过关了，没有执行break。

else: #上面的for模块执行完了，说明都不能被2到平方根的数整除

pri_num += 1 #所以质数计数+1

sumzs+=num

print(num,"是质数")

# print(num,"是质数") #这就是break执行后继续执行的语句，同for和else级别，也就是上面说的其他语句

#++++++++++++++++++++++++++++++++++++++++++++++++++++++++

else:

print(num,"既不是素数也不是合数")

print("="*10)

print(com_num,'个合数','和为',sumhs)

print(pri_num,'个素数','和为',sumzs)Kindred Kindred 268***8532@qq.com4年前 (2020-02-23)

#0 不是TheShy是Rookie 501***482@qq.com 2更严谨的判断，更美观的输出：

import math

def T1():

# print("0和1 既不是质数，也不是合数。")

while True:

try:

Max_num = int(input("请输入区间最大值："))

Min_num = int(input("请输入区间最小值："))

except:

print("您输入的不是整数。")

else:

if (Max_num <= 1 or Min_num <= 1) :

print("请重新输入大于“1”的整数。")

else:

if Min_num >= Max_num:

print("最大值必须大于最小值，请重新输入。")

else:

break

#前面是为了给输入的数字判断，然后传参调用T2()

T2(Min_num,Max_num)

def T2(A,B):

L = [] #质数空列表

K = [] #合数空列表

for h in range(A,(B+1)):

r = math.floor(h**0.5)

for e in range(2,(r+1)):

if (h % e) == 0:

break

else:

L.append(h) #得到的质数添加到列表L

for w in range(A,(B+1)):

if w not in L:

K.append(w) #将剩下的合数添加到列表K

print(f"{A} 到 {B} 之间的所有质数如下：\n",L) #以列表形式输出所有质数

print(f"{A} 到 {B} 之间的所有合数如下：\n",K)

print("质数共计：",len(L),"个") #如果要计算个数

print("合数共计：",len(K),"个")

if __name__ == "__main__":

T1() #范围内的所有质数（与合数）

输入 100 和 2 ，结果如下：

请输入区间最大值：100

请输入区间最小值：2

2 到 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]

2 到 100 之间的所有合数如下：

[4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30, 32, 33, 34, 35, 36, 38, 39, 40, 42, 44, 45, 46, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58, 60, 62, 63, 64, 65, 66, 68, 69, 70, 72, 74, 75, 76, 77, 78, 80, 81, 82, 84, 85, 86, 87, 88, 90, 91, 92, 93, 94, 95, 96, 98, 99, 100]

质数共计： 25 个

合数共计： 74 个不是TheShy是Rookie 不是TheShy是Rookie 501***482@qq.com6个月前 (08-30)

点我分享笔记

取消

分享笔记

昵称昵称 (必填)

邮箱邮箱 (必填)

引用地址引用地址

分类导航

HTML / CSSHTML 教程HTML5 教程CSS 教程CSS3 教程Bootstrap3 教程Bootstrap4 教程Bootstrap5 教程Font Awesome 教程Foundation 教程 JavaScriptJavaScript 教程HTML DOM 教程jQuery 教程AngularJS 教程AngularJS2 教程Vue.js 教程Vue3 教程React 教程TypeScript 教程jQuery UI 教程jQuery EasyUI 教程Node.js 教程AJAX 教程JSON 教程Echarts 教程Chart.js 教程Highcharts 教程Google 地图教程服务端Python 教程Python2.x 教程Linux 教程Docker 教程Ruby 教程Java 教程C 教程C++ 教程Perl 教程Servlet 教程JSP 教程Lua 教程Rust 教程Scala 教程Go 教程PHP 教程数据结构与算法Django 教程FastAPI 教程Zookeeper 教程设计模式正则表达式Maven 教程Verilog 教程ASP 教程AppML 教程VBScript 教程数据库SQL 教程MySQL 教程PostgreSQL 教程SQLite 教程MongoDB 教程Redis 教程Memcached 教程数据分析Python 教程NumPy 教程Pandas 教程Matplotlib 教程Scipy 教程R 教程Julia 教程移动端Android 教程Swift 教程jQuery Mobile 教程ionic 教程Kotlin 教程 XML 教程XML 教程DTD 教程XML DOM 教程XSLT 教程XPath 教程XQuery 教程XLink 教程XPointer 教程XML Schema 教程XSL-FO 教程SVG 教程 ASP.NETASP.NET 教程C# 教程Web Pages 教程Razor 教程MVC 教程Web Forms 教程 Web ServiceWeb Service 教程WSDL 教程SOAP 教程RSS 教程RDF 教程开发工具Eclipse 教程Git 教程Svn 教程Markdown 教程网站建设HTTP 教程网站建设指南浏览器信息网站主机教程TCP/IP 教程W3C 教程网站品质

反馈/建议

在线实例

·HTML 实例

·CSS 实例

·JavaScript 实例

·Ajax 实例

·jQuery 实例

·XML 实例

·Java 实例

字符集&工具

· HTML 字符集设置

· HTML ASCII 字符集

· JS 混淆/加密

· PNG/JPEG 图片压缩

· HTML 拾色器

· JSON 格式化工具

· 随机数生成器

百度知道 - 信息提示

百度首页

商城

网页

资讯

视频

图片

知道

文库

贴吧采购

地图更多

搜索答案

我要提问

百度知道>提示信息

知道宝贝找不到问题了>_

该问题可能已经失效。返回首页

15秒以后自动返回

帮助

| 意见反馈

| 投诉举报

用C语言输出1-100之间的素数（3种方法）_素数c语言程序编写-CSDN博客

用C语言输出1-100之间的素数（3种方法）

最新推荐文章于 2024-03-08 11:05:19 发布

学编程加鸡腿

最新推荐文章于 2024-03-08 11:05:19 发布

阅读量10w+

120

点赞数

文章标签：

c语言

本文链接：https://blog.csdn.net/m0_63799513/article/details/124136213

版权

首先回忆一下素数的概念：素数指除1和它本身外，不能被其他数整除的数。

接下来，我要使用三种方法实现“输出1-100之间的素数”：

1.第一种方法就是用1到100之间的每个数字，除以2到其本身前面的那一个数字，如果此过程中出现整除的现象，则该数不是素数。如果没有整除的现象，则该数为素数输出。代码如图：

2、第二种方法使用了SQRT函数，也就是平方根，这里的平方根是整数。众所周知，非素数可以写成除了1和它本身相乘的a*b方式，而a、b之间必有一个小于等于ab之积的开平方根；如果这个非素数能够被a整除，则相应的肯定会被b整除。这种方法用1到100之间的数字除以2到它的开平方根（如果该数的平方根是整数则可以除到），在此之间如果出现整除现象，则该数不是素数；如果没有出现整除现象，则该数是素数。显而易见，这种方法比第一种方法要简便，运行的次数少。

3、第三种方法是对第二种方法的优化，原理如下：1到100之间的所有偶数都不是素数，所以可以剔除，直接对奇数进行判断，这样又可以让程序的运行时间减少一半。

补充：以上程序中所有有关count的语句是为了统计所求素数个数的，可以去掉。

以下为上述代码：

1,#include int main() { int i = 0; int count = 0; for (i = 1; i <= 100; i++) { int j = 0; for (j = 2; j <= i; j++) { if (i%j == 0) { break; } } if (i == j) { count++; printf("%d ", i); } } printf("\ncount=%d\n", count); return 0; }

2.#include #include int main() { int i=0; int count=0; for(i=1;i<=100;i++) { int j=0; for(j=2;j<=sqrt(i);j++) { if(i%j==0) { break; } } if(j>sqrt(i)) { count++; printf("%d ",i); } } printf("\ncount=%d\n",count); return 0; }

#include #include int main() { int i = 0; int count = 0; for (i = 1; i <= 100; i += 2) { int j = 0; for (j = 2; j <= sqrt(i); j++) { if (i%j == 0) { break; } } if (j>sqrt(i)) { count++; printf("%d ", i); } } printf("\ncount=%d\n", count); return 0; }

毕

优惠劵

学编程加鸡腿

关注

踩

120

觉得还不错?

一键收藏

知道了

用C语言输出1-100之间的素数（3种方法）

输出1-100之间的素数（3种方法）

复制链接

扫一扫

输入整数n，输出1~n的素数

10-28

素数又叫质数，质数是指在大于1的自然数中，除了1和它本身以外，不能被其他自然数整除的数。

问题：

输入一个整数n，输出1~n中的素数，里有详细解释，有问题也欢迎留言！谢谢支持啦~

C语言300-400之间的全部素数

03-28

C语言练习程序代码,求300-400之间的全部素数

8 条评论

您还未登录，请先

后发表或查看评论

C语言之求1到n个数字之间所有的素数（三种写法）

yzb564的博客

12-26

1220

求1到n个数字之间所有的素数

C语言判断素数的三种方法判断素数（质数）

最新文章

C语言初识

2022年2篇

最新文章

C语言初识

2022年2篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值

Python多种方法求某个范围内的所有素数(质数) - 知乎

Python多种方法求某个范围内的所有素数(质数) - 知乎首发于人工智能学习工作者切换模式写文章登录/注册Python多种方法求某个范围内的所有素数(质数)zeruns贵州豪象文化传媒有限责任公司技术总监素数简介质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数。原文：https://blog.zeruns.tech/index.php/archives/286/方法1def primeNUM(min,max):

if min==1:

print('')

min += 1

for i in range(min, max+1):

for j in range(2, i + 1):

if i % j == 0: #判断i能不能被整除

break #退出for循环

if j == i: #若j等于i，说明i是素数

print(i,end=" ")

print('')

primeNUM(1,200)方法2def test(num):

list = [] #定义一个列表用于存储计算的数

i = num -1 # 去除本身

while i > 1: # 去除1

if num %i == 0 : #判断是否有余数

list.append(i) # 将所有的能整除i的数加入列表

i -= 1

if len(list) == 0 and num != 1: # 如果列表为空就是表示除了1和它本身能整除

print(num,end=' ')

def primeNUM2(min,max):

j = min

while j < max:

test(j)

j += 1

print('')

primeNUM2(1,100)输出结果：https://blog.zeruns.tech/usr/uploads/2020/01/3533089418.jpg发布于 2020-01-30 21:57素数Python算法赞同 30添加评论分享喜欢收藏申请转载文章被以下专栏收录人工智能学习工作者人工智能相关的学习和工作的人交流

手把手教你用C语言实现求质数（素数），5大方法任君挑选_素数c语言程序编写-CSDN博客

手把手教你用C语言实现求质数（素数），5大方法任君挑选

最新推荐文章于 2023-05-23 17:01:43 发布

平凡的指针

最新推荐文章于 2023-05-23 17:01:43 发布

阅读量10w+

1.4k

点赞数

540

文章标签：

c语言

算法

数据结构

本文链接：https://blog.csdn.net/m0_56311933/article/details/117911382

版权

什么是质数（素数）？第一种方法，暴力解决第二种方法，用奇数第三种方法，奇数双管齐下第四种方法，巧用数组第五种方法，巧用平方根写法1：写法2：

总结

什么是质数（素数）？

质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数（规定1既不是质数也不是合数）。———来自百度百科

第一种方法，暴力解决

我们设定一个数为x，根据质数的定义判断x是否为质数，我们看它能否被2、3、4······、x-1整除，如果它不能被其中任何一个整数整除，则这个数就是质数。比如要判断11是不是质数，我们就看能否被下面这10个数整除。 2、3、4、5、6、7、8、9、10 因为11无法被其中任何一个数整除，则判断它为质数。

如果我们要找1—1000内的质数，我们可以控制x从2自己增到1000，并且x每次自增1过后，都要从2开始找能否被x所整除的数，直到找不到结束。所以我们可以用两层for循环来控制，第一层来控制x产生2–1000数字，第二层for循环产生2到x-1的数，并且判断能否被整除。（因为1不是质数，把1排除在外）

并且我还设置了一个计数器count来统计大概运算的次数，方便和下面方法做对比。代码如下：

//求1--1000内的质数（素数）

#include

int main()

{

int x = 0;

int i = 0;

unsigned int count = 0; //统计运算的次数

for (x = 2; x < 1000; x++) //在2到1000之间找质数

{

for (i = 2; i < x; i++) //试除法，能不能被x整除，从2开始找，直到等于x

{

count++;

if (x % i == 0) //找到能被x整除的数了

{

break;

}

if (x == i) //找到和x相等也没有被整除的，证明是质数

{

printf("%d ",x);

}

printf("\n\n\n");

printf("运算的次数：%d ",count);

return 0;

}

第一种方法运行结果：

第二种方法，用奇数

第一种方法是否有点复杂呢，这是当然的。其实我们从质数： 2、3、5、7、9、11、13、17、19······中发现什么规律了没有呢？

嘿嘿嘿，那就是除了2以外那些2的倍数（4、6、8、10、12、14、18·······）都不是质数。

所以我们的第一层for循环是不是可以不用一步步自增1，而是从3开始自增2呢，从而产生3、5、7、9、11······这样就把偶数给巧妙避免了。代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include

int main()

{

int x = 0;

int i = 0;

unsigned int count = 0;

x = 2;

printf("%d ",x); //已经知道2为质数，所以先第一个打印

for (x = 3; x < 1000; x += 2) //从3开始自增2

{

for (i = 2; i < x; i++)

{

count++;

if (x % i == 0)

{

break;

}

if (x == i)

{

printf("%d ",x);

}

printf("\n\n\n");

printf("运算的次数：%d ", count);

return 0;

}

第二种方法运行结果：第一种和第二种对比图片：大家发现了没有好像第二种并没有比第一种运算要少很多，这个是因为当判断33、66、666这些在开始阶段i=3的时候，马上就可以判定不是质数了，所以运算次数并没有怎么减少。

第三种方法，奇数双管齐下

结合第二种方法，除了2以外那些2的倍数（4、6、8、10、12、14、18·······）都不是质数。所以除了2以外质数一定是奇数。从而判断11是否为质数的时候，我们不再需要判断能否被2、3、4、5、6、7、8、9、10这9个数整除，我们只需要判断能否被3、5、7、9这几个数整除即可。所以我们可以控制第二层for循环不再自增1，而是从3开始自增2。代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include

int main()

{

int x = 0;

int i = 0;

unsigned int count = 0;

x = 2;

printf("%d ",x);

for (x = 3; x < 1000; x += 2) //只产生奇数

{

for (i = 3; i < x; i += 2) //只产生奇数

{

count++;

if (x % i == 0)

{

break;

}

if (x == i)

{

printf("%d ",x);

}

printf("\n\n\n");

printf("运算的次数：%d ", count);

return 0;

}

第三种方法运行结果：

第四种方法，巧用数组

在第三种的基础上再看，我们还发现如下规律：不能被3整除的整数也无法被大于3的那些3的倍数（6、9、12······）整除。不能被5整除的整数也无法被大于5的那些倍数（10、15、20······）整除。所以，如果整数x无法被小于x的质数整除，那么x就是质数。根据这个条件，我们求质数就有了另外一条思路：我们用数组来保存质数，控制x自增后，用x除去数组的每一个元素，如果不能整除则是质数，并且保存到数组中。

因此，我们先把2、3这两个质数保存到数组中，第一层for循环依旧是控制x自增，第二层for循环来遍历数组。遍历后如果都不能整除，则存到数组中。如果有一个能被整除，则不是质数，不保存。

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1

#include

int main()

{

int arr[500] = { 0 };

int x = 0;

int i = 0;

unsigned int count = 0;

int sum = 0; //定义数组的下标

arr[sum] = 2; //把2存到数组中

sum++;

arr[sum] = 3; //把3存到数组中

sum++;

for (x = 5; x < 1000; x += 2)

{

//从下标0开始遍历，直到数组的最后一个质数

for (i = 0; i < sum; i++ )

{

count++;

if (x % arr[i] == 0)

{

break;

}

if (sum == i) //遍历后都不能整除

{

arr[sum] = x; //把质数保存到数组中

sum++; //下标加1，为下次放做准备

}

for (i = 0; i < sum; i++)

{

printf("%d ", arr[i]);

}

printf("\n\n\n");

printf("运算的次数：%d ", count);

return 0;

}

运算结果：

第五种方法，巧用平方根

写法1：

我们设两个整数a和b，如果不是质数的话，整数x就可以写成 x=a * b 比如： 36=2 * 18 36=3 * 12 36=4 * 9 36=6 * 6 如果整数x为质数，那么就不可能写成 x = a * b的形式。所以如果整数x无法被小于等于x的平方根的质数整除，则x为质数。因此，我们可以在第四种方法上改造一下，就是在第二层for循环，从数组的第一个元素出发，每一个都写成平方，直到平方大于整数x退出循环。代码如下：

//第五种方法，巧用平方根,写法1：

#include

int main()

{

int arr[500] = { 0 };

int x = 0; //定义要找质数的变量

int i = 0;

unsigned int count = 0;

int sum = 0; //定义数组下标

arr[sum] = 2; //2是质数，储放到数组中

sum++;

arr[sum] = 3; //3也是质数，放到数组中

sum++;

for (x = 5; x < 1000; x += 2) //只查找奇数

{

for (i = 0;arr[i] * arr[i] <= x; i++) //利用数组中的元素平方去排查

{

count++;

if (x % arr[i] == 0) //不是质数

{

break;

}

if (arr[i]*arr[i]>x) //为质数

{

arr[sum] = x; //把找到的奇数放到数组中

sum++; //下标加1

}

for (i = 0; i < sum; i++)

{

printf("%d ",arr[i]);

}

printf("\n\n\n");

printf("运算的次数：%d ", count);

return 0;

}

运算结果：

写法2：

我们不要数组也可以，直接在第三种方法上改造。代码如下：

//第五种方法，巧用平方根,写法二：

#include

int main()

{

int x = 0;

int i = 0;

unsigned int count = 0;

x = 2;

printf("%d ",x);

for (x = 3; x <= 1000; x += 2)

{

for (i = 2; i*i<=x; i++) //控制第二层循环

{

count++;

if (x % i == 0)

{

break;

}

if (i*i>x)

{

printf("%d ",x);

}

printf("\n\n\n");

printf("运算的次数为：%d ",count);

return 0;

}

运算结果：

总结

我们从第一种的简单粗暴到最后的优良改造，运算次数一步步地减少，大家是否领悟到了编程的优美了呢？我特别推荐最后一种的写法二，既不用数组，也可以节省很多的运算时间。

如果有错误的地方，还有改进的方法，欢迎在评论区指出。

既然都看到这里了，点个赞呗，嘿嘿嘿。

优惠劵

平凡的指针

关注

540

踩

1438

觉得还不错?

一键收藏

知道了

手把手教你用C语言实现求质数（素数），5大方法任君挑选

目录第一种方法，暴力解决二级目录三级目录第一种方法，暴力解决//求1--1000内的质数（素数）#include <stdio.h>int main(){ int x = 0; int i = 0; unsigned int count = 0; for (x = 2; x < 1000; x++) //在2到1000之间找质数 { for (i = 2; i < x; i++) //试除法，能不能被x整除，从2开始找，直到等于x {.

复制链接

扫一扫

C语言判断素数的三种方法判断素数（质数）

JH13thpig的博客

04-27

22万+

C语言判断素数的四种方法判断素数（质数）

c语言中素数的表示方法

最新文章

【对C++中的多态分析和总结】

【单继承和多继承的虚函数表验证】

对C++中的继承分析和总结

2022年14篇

2021年34篇

分类专栏

C++

9篇

Linux

5篇

数据结构

14篇

C语言

11篇

游戏

3篇

总结

2篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值

Python – 获取 100 以内的质数 | 菜鸟教程

菜鸟教程 -- 学的不仅是技术，更是梦想！

首页

HTML

CSS

JavaScript

Vue

Bootstrap

NodeJS

Python3

Python2

Java

C++

SQL

Linux

jQuery

本地书签

首页

HTML

CSS

本地书签

Python3 教程

Python2 教程

Vue3 教程

vue2 教程

Bootstrap3 教程

Bootstrap4 教程

Bootstrap5 教程

Bootstrap2 教程

Python 基础教程

Python 简介

Python 环境搭建

Python 中文编码

Python 基础语法

Python 变量类型

Python 运算符

Python 条件语句

Python 循环语句

Python While 循环语句

Python for 循环语句

Python 循环嵌套

Python break 语句

Python continue 语句

Python pass 语句

Python Number(数字)

Python 字符串

Python 列表(List)

Python 元组

Python 字典(Dictionary)

Python 日期和时间

Python 函数

Python 模块

Python 文件I/O

Python File 方法

Python 异常处理

Python OS 文件/目录方法

Python 内置函数

Python 高级教程

Python 面向对象

Python 正则表达式

Python CGI 编程

Python MySQL

Python 网络编程

Python SMTP

Python 多线程

Python XML 解析

Python GUI 编程(Tkinter)

Python2.x 与 3.x 版本区别

Python IDE

Python JSON

Python AI 绘画

Python 100例

Python 测验

Python format 格式化函数

Python range() 函数

Python - 获取 100 以内的质数

Python 100例

题目：获取 100 以内的质数。

程序分析：质数（prime number）又称素数，有无限个。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数的数称为质数，如：2、3、5、7、11、13、17、19。

方法一：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

num=[];

i=2

for i in range(2,100):

j=2

for j in range(2,i):

if(i%j==0):

break

else:

num.append(i)

print(num)

方法二：

import math

def func_get_prime(n):

return filter(lambda x: not [x%i for i in range(2, int(math.sqrt(x))+1) if x%i ==0], range(2,n+1))

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

Python 100例

Python format 格式化函数

Python range() 函数

4 篇笔记

写笔记

#0 张小川 835***338@qq.com 1参考方法：

import math

N = 100

print [ p for p in range(2, N) if 0 not in [ p%i for i in range(2,int(math.sqrt(p))+1)]]

张小川张小川 835***338@qq.com7年前 (2017-08-20)

#0 红烧土豆块 545***924@qq.com 8参考：[n for n in range(1,100) if not [m for m in range(2,n) if n % m ==0]]

红烧土豆块红烧土豆块 545***924@qq.com6年前 (2017-11-28)

#0 阳光不锈 173***979@qq.com 3Python3 采用递归：

#递归函数求质数

def prime(n):

if n==2:

print(n)

return

else:

for i in range(2,n):

if n%i==0:

break

else:

print(n,end=',')

prime(n-1)

#获取 100 以内的质数

prime(100)阳光不锈阳光不锈 173***979@qq.com6年前 (2018-02-18)

#0 newpy bin***@163.com 4filter 方法，匿名函数，如果推导式为空，则返回值为 True。为便于代码理解，省略了求平方根。

文章示例中方法二的写法可以优化如下：推导式中将 x % i 修改为 x

Type "help", "copyright", "credits" or "license" for more information.

>>> lis = list(filter(lambda x: not[x for i in range(2, x) if x % i == 0], range(2, 100)))

>>> print(lis)

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

newpy newpy bin***@163.com6年前 (2018-08-06)

点我分享笔记

取消

分享笔记

昵称昵称 (必填)

邮箱邮箱 (必填)

引用地址引用地址

分类导航

反馈/建议

在线实例

·HTML 实例

·CSS 实例

·JavaScript 实例

·Ajax 实例

·jQuery 实例

·XML 实例

·Java 实例

字符集&工具

· HTML 字符集设置

· HTML ASCII 字符集

· JS 混淆/加密

· PNG/JPEG 图片压缩

· HTML 拾色器

· JSON 格式化工具

· 随机数生成器

C语言:如何打印输出100以内的素数？ - 知乎

C语言:如何打印输出100以内的素数？ - 知乎首页知乎知学堂发现等你来答切换模式登录/注册数论C（编程语言）素数C语言:如何打印输出100以内的素数？关注者4被浏览17,710关注问题写回答邀请回答好问题添加评论分享2 个回答默认排序无味关注这里讲解了3种不同的实现打印100-200之间素数的方法，帮助你打破思维限制！问题描述写一个C语言程序打印100-200之间的素数示例image.png方法1思路分析1.将100至200之间的数一个一个取出来，定义 i 存放取出的数 2.从2到 i-1 ，逐个尝试能否整除 i 3.如果能，则不是素数；如果否，则输出 i 4.继续判断下一个数，直到判断完100至200之间所有的数结束程序代码实现#include

int main()

{

int i = 0;

int j = 0;

for (i = 100; i <= 200; ++i)

{

//定义flag变量记录当前数是否为素数，假设是素数，变量值为1

int flag = 1;

for (j = 2; j < i; ++j)

{

if (i % j == 0)//遍历2到i-1

{

flag = 0;

break;

}

//如果flag等于1，则表明是素数，执行打印

if (flag == 1)

{

printf("%d ", i);

}

return 0;

} 这个代码实现中将两个循环嵌套使用，外层循环遍历100至200之间的数，内层循环遍历2至当前外层循环取出的数（也就是 i ），然后在内层循环中使用一个分支判断能否整除。其实素数还有个特点就是一定不为偶数，所以遍历时可以跳过偶数，只判断奇数是否满足素数的条件。不知道你有没有发现，上述方法1代码中其实也可以不借助变量flag来记录是否为素数，若想了解具体实现方法请看下面的方法2。方法2代码实现#include

int main()

{

int i = 0;

int j = 0;

for (i = 101; i < 200; i += 2)//遍历时跳过偶数

{

for (j = 2; j < i; ++j)

{

if (i % j == 0)

{

break;

}

//如果j等于i，说明上面的循环是因为不满足j

//而不是执行到了break导致循环结束的

if (j == i)

{

printf("%d ", i);

}

return 0;

} 既然偶数不可能为素数，那我们就利用这个点来实现代码。我们将外层循环的 i = 100 改为了 i = 101，判断条件也不需要等于200了，因为不需要判断偶数嘛，很自然地完成，但是只改这两处可不行，因为我们是要让101至199之间只有奇数，实现这点也很简单，直接让 i 每完成一次循环后就自增2，这样就达到了目的。这样做的好处是显而易见的，可以减少循环的次数，提高程序的执行效率。在方法2中我们还做到了不借助变量flag来记录是否为素数，方法就是用是否满足 j == i 来判断打不打印 i ，j 不等于 i 则是break语句使内层循环结束，j 等于 i 就是素数了，执行打印。这样做似乎使代码更加简洁，但是并不是所有的情况和方法都是可以直接break，不使用变量flag记录的，例如下面的方法3就必须要使用变量进行标记才可执行成功。方法3思路分析1.当2至 i -1中存在某个数 k 可以整除 i 时，令 u = i/k，则 u 也可以整除 i ，并且结果为 k 2.当2至根号下 i 不存在可以整除 i 的数时，那么根号下 i + 1至 i 也不存在可以整除 i 的数代码实现#include

#include

int main()

{

int i = 0;

int j = 0;

for (i = 101; i < 200; i += 2)

{

//定义flag变量记录当前数是否为素数，假设是素数，变量值为1

int flag = 1;

//sqrt是求平方根的函数，包含在math.h中

for (j = 2; j < sqrt(i); ++j)

{

if (i % j == 0)

{

flag = 0;//不是素数

break;

}

//如果flag等于1，则表明是素数，执行打印

if (flag == 1)

{

printf("%d ", i);

}

return 0;

} 在此方法中运用了数学相关的知识来编写代码，其中使用了sqrt库函数，此函数是一个开平方的函数，包含在头文件math.h中，需要引入对应头文件才能调用此函数。使用方法3的思路来实现相比于前两种更加高效，也就是算得更快，但相应也更难想出思路。运行结果以上3种方法都可运行成功，运行结果如下image.png总结我们在完成打印100-200之间的素数这个程序总共用了3种不同的方法来实现，但是这三种方法实现的大体思路是相同的，都是利用了两个for循环进行嵌套遍历来实现打印。通过这3种方法有助于我们更好地理解编程，学习编程，不局限于某一种方法，帮助我们打破思维界限。希望对你有所帮助！发布于 2023-11-28 04:35赞同 5添加评论分享收藏喜欢收起catzzz学生关注这是另一种思路#include "stdio.h"

#define N 100

int main(){

int i,j;

int arr[N];

for(i = 0;i

arr[i]=i+1;

}

arr[0] = 0;

//进行素数判断:从2开始用2除后面的数，如果后面的数能被2整除那么那个数一定不是素数,将那个数置为零。

//接着再用3除3后面的数。以此类推。

//要求数组是升序

for(i = 1;i < N-1;i++){

for(j = i+1;j < N;j++){

if(arr[i] != 0 && arr[j] != 0)

if(arr[j] % arr[i] == 0){

arr[j] = 0;

}

//输出

for(i = 0;i

if(arr[i] != 0)

printf("%d\n",arr[i]);

}

return 0;

}编辑于 2021-07-19 12:22赞同 43 条评论分享收藏喜欢收起写回答1 个回答被折叠（为什

C语言编程求解：1到1000之间所有的素数 - 知乎

C语言编程求解：1到1000之间所有的素数 - 知乎切换模式写文章登录/注册C语言编程求解：1到1000之间所有的素数阿汤哥先给出素数的定义：素数是只能被1和自身整出的整数。1不是素数算法思考：判断一个数是不是素数，只需要判断它是不能只能被1和自身整除。那怎么判断一个数不能被除1和自身之外的其他数整除呢？想法是写一个循环，循环里依次除以从2到这个数减1的所有的整数，如果都不能整除，说明这个数是素数；如果出现一个能整除的数，那么这个数不是素数。（其实，判断素数还可以优化，循环里依次除以从2到这个数平方根的所有的整数就可以了。因为假设一个数n，除以2~根号n的整数，都不能整除，那么除以根号n~n-1的整数也不能整数。在文章最后再贴上优化的代码。）那怎么判断能不能整除呢？我么知道C语言有求余数的运算符%，如果余数是0，那么说明能整除了。我们来写程序代码。这里，说明一下，当你写一个具有某个功能的代码的时候，把这个功能写成一个函数，而不是所有的代码都放在main函数里。在main函数里调用这个你写的函数。给函数命名，如果你知道或者查到了素数的英文单词是prime number，那么函数可以起名为 is_primer_number（如果你不知道素数的英文单词，那么随便起个名字也可以，比如叫fun）。因为要传递一个代判断的整数，所以有一个int类型参数。返回值我们用bool型（代码里要包含头文件stdbool.h），如果是素数返回true，如果不是素数返回false。代码：bool is_prime_number(int a)

{

for (int i = 2; i < a ; i++){

if (a % i == 0)

return false;

}

return true;

}判断是不是素数的函数写好了。题目是要求1到1000之间所有的函数。你可以再写一个函数，函数的功能是求1到某个整数之间的所有素数并打印。函数命名为print_prime_num。有一个int类型参数。返回值我们写为整型，返回素数的个数。循环把2到这个数之间的每个整数，作为参数，传给上面写的函数is_prime_number()，如果是素数，就打印。int print_prime_number(int a)

{

int count = 0;

for (int i = 2; i<=a; i++ ){

if（is_prime_number(a)）{

count++;

printf("%d\n", a);

}

}main函数的写法。输入一个整数，作为参数，传给函数print_prime_number()处理：int main ()

{

int a;

printf("求1到一个整数之间所有的素数.\n");

printf("请输入一个整数: \n");

scanf("%d", &a);

print_prime_number(a);

return 0;

}运行结果：优化判断素数的函数还可以优化，循环里依次除以从2到这个数平方根的所有的整数就可以了。因为假设一个数n，除以2~根号n的整数，都不能整除，那么除以根号n~n-1的整数也不能整数。所以我们只要循环2~根号n之间的数就可以了。函数is_prime_number()可以写为下面这样。这里用到了求平方根的函数sqrt()，要包含头文件math.h。另外，函数sqrt()的返回类型是double，但是这里我们要的是整数，所以加上(int)强制转换为整型。bool is_prime_number(int a)

{

for (int i = 2; i < (int)sqrt(a) +1 ; i++){

if (a % i == 0)

return false;

}

return true;

}运行结果：编辑于 2024-01-20 12:39・IP 属地上海素数C 语言入门C / C++赞同 586 条评论分享喜欢收藏申请

求质数（素数）算法，及算法优化_卡空间求素数-CSDN博客

求质数（素数）算法，及算法优化

# Never Give up &

已于 2023-01-09 10:11:20 修改

阅读量2.4w

177

点赞数

分类专栏：

算法

文章标签：

算法

质数（素数）

于 2019-08-11 10:47:29 首次发布

本文链接：https://blog.csdn.net/qq_41939020/article/details/99167166

版权

算法

专栏收录该内容

9 篇文章

2 订阅

订阅专栏

质数（素数）：只能被1和其本身整除的数字（其中1和0不属于质数）

接下来我们用多种方法求1000以内（包含1000）的质数数量，并且统计每种方法的循环次数 (如果只想知道速度快的方法可以直接看方法五)

方法一：

循环遍历所有情况

int count1 = 0;//循环次数

int count2 = 0;//质数个数

for(int i=2;i<=1000;i++) {

int flag = 0;//用作标记，如果是质数就为0，不是质数就为1

for(int j=2;j

count1++;

if(i % j == 0 ){

flag = 1;//不是质数，改为1

}

if(flag == 0){

count2++;

}

System.out.println(count1);

System.out.println(count2);

此时总循环次数为498501次质数个数有168个

方法二

改进点：当一个数第一次被比自己小的数（不包含1）整除成功后，我们就可以立刻判断出这个数不是质数，所以我们使用break跳出循环，结束对这个数接下来的判断

int count1 = 0;//循环次数

int count2 = 0;//质数个数

for(int i=2;i<=1000;i++) {

int flag = 0;//用作标记，如果是质数就为0，不是质数就为1

for(int j=2;j

count1++;

if(i % j == 0 ){

flag = 1;//不是质数，改为1

break;//既然已经知道这个数不是质数，那么就可以结束对这个数字的判断

}

if(flag == 0){

count2++;

}

System.out.println(count1);

System.out.println(count2);

此时总循环次数为78022次质数个数有168个

方法三

改进点：如果存在数字1能被数字2整除，那么一定存在这样一个小于等于数字1算术平方根的数字2（数学定理），所以一个数字在2~本身算术平方根这个数字区间内没有遇到能够被整除的数字，那么这个数就不是质数　　简单解释一下：因数都是成对出现的。比如，100的因数有：1和100，2和50，4和25，5和20，10和10。看出来没有？成对的因数，其中一个必然小于等于100的开平方，另一个大于等于100的开平方。

注释掉的部分可以进一步提高计算速度，但提高不是非常大

int count1 = 0;//质数个数

int count2 = 0;//循环次数

for(int i=2;i<=1000;i++) {

int flag = 0;//用作标记，如果是质数就为0，不是质数就为1

//if(Math.sqrt(i)!=(int)Math.sqrt(i)){

for (int j = 2; j <= Math.sqrt(i); j++) {//j改为小于i的平方根

count2++;

if (i % j == 0) {

flag = 1;//不是质数，改为1

break;//既然已经知道这个数不是质数，那么就可以结束对这个数字的判断

}

//}else {

// count2++;

//}

if (flag == 0) {

count1++;

}

System.out.println(count1);

System.out.println(count2);

此时总循环次数为5288次质数个数有168个

方法四

改进点：如果数字1取余数字2不等于0，那么数字一取余数字2的倍数一定也不为0。例如：7%2！=0那么我们没必要再去算7%4和7%6，因为4=22,6=32 所以，我们只需要判断一个数是否能被小于他的质数除尽即可在这里我们将已经算出来为的质数存到一个数组中，后续的%只需对该数组中小于这个数本身平方根的数字进行

int count1 = 0;//质数个数

int count2 = 0;//循环次数

int re[] =new int[500];//定义一个数组，用于储存质数

re[0] = 2;

int k = 0;

for(int i=2;i<=1000;i++) {

int flag = 0;//用作标记，如果是质数就为0，不是质数就为1

for(int j=0;j<=k;j++){

count2++;

if(re[j]>Math.sqrt(i)){//只去小于等于该数字本身平方根的数字

break;

}

if(i % re[j] == 0 ){//只对质数取余

flag = 1;//不是质数，改为1

break;//既然已经知道这个数不是质数，那么就可以结束对这个数字的判断

}

if (flag == 0) {

re[++k] = i;

count1++;

}

System.out.println(count1);

System.out.println(count2);

此时总循环次数为3467次质数个数有168个

方法五

boolean prime[] = new boolean[1001];

int count1 = 0;//质数个数

int count2 = 0;//循环次数

for(int i=2;i<1000;i++){

prime[i] = true;

}

for(int i=2;i<=1000;i++){

if(prime[i]){

for(int j=i+i;j<1000;j+=i){

count2++;

prime[j] = false;

}

for(int i=0;i<=1000;i++){

if(prime[i] == true){

count1++;

}

System.out.println(count1);

System.out.println(count2);

此时总循环次数为1956次质数个数有168个

讲解: 利用了筛法，首先，2是公认最小的质数，所以，先把所有2的倍数去掉；然后剩下的那些大于2的数里面，最小的是3，所以3也是质数；然后把所有3的倍数都去掉，剩下的那些大于3的数里面，最小的是5，所以5也是质数…… 　　上述过程不断重复，就可以把某个范围内的合数全都除去（就像被筛子筛掉一样），剩下的就是质数了。维基百科上有一张很形象的动画，能直观地体现出筛法的工作过程。

问题延伸

现在是让你求1000以内的素数，我们可以写死让i<=1000，但如果题目改为让你按从小到大的顺序，输出1000个质数该怎么办呢？第1000个质数的范围在哪里呢？如果我们使用上面的方法四可以这样写

int count1 = 0;//质数个数

int count2 = 0;//循环次数

int re[] =new int[1001];//定义一个数组，用于储存质数

re[0] = 2;

int k = 0;

for(int i=2;;i++) {

if(count1==1000){

break;

}

int flag = 0;//用作标记，如果是质数就为0，不是质数就为1

for(int j=0;j<=k;j++){

count2++;

if(re[j]>Math.sqrt(i)){//只去小于等于该数字本身平方根的数字

break;

}

if(i % re[j] == 0 ){//只对质数取余

flag = 1;//不是质数，改为1

break;//既然已经知道这个数不是质数，那么就可以结束对这个数字的判断

}

if (flag == 0) {

re[++k] = i;

count1++;

}

System.out.println(count1);

System.out.println(count2);

但是我们知道方法四比方法五要慢很多，但方法五中我们是提前定好了boolean prime[] = new boolean[1001];，第一千个质数我们应该将prime[]的大小定位多少呢？

这就涉及到了我们的数学知识，数学家找到了一些公式，用来估计某个范围内的素数，大概有几个。在这些公式中，最简洁的就是 x/ln(x)，公式中的 ln 表示自然对数（估计很多同学已经忘了啥叫自然对数）。假设要估计1,000,000以内有多少质数，用该公式算出是72,382个，而实际有78,498个，误差约8个百分点。该公式的特点是：估算的范围越大，偏差率越小。　　有了素数定理，就可以根据要打印的质数个数，反推出这些质数分布在多大的范围内。因为这个质数分布公式有一定的误差（通常小于15%）。为了保险起见，把反推出的素数分布范围再稍微扩大15%，应该就足够了。

空间优化

看到这你因为这已经是最优的解法了吗？不，现在我们只优化了时间，还没有优化空间。有些程序猿会想出按位（bit）存储的思路。　　以Java为例。一个boolean占用4字节内存（boolean类型占了单独使用是4个字节，在数组中又是1个字节）。而1个字节有8个比特，每个比特可以表示0或1。所以，当你使用按位存储的方式，一个字节可以拿来当8个布尔型使用。所以，构造一个定长的byte数组，数组的每个byte存储8个布尔值。空间性能相比直接定义boolean，提高8倍（对于Java而言）。

最后总结

关于代码优化这件事，我认为没有最优，只有更优，科技永远不会停下前进的脚步

努力吧，少年！

优惠劵

# Never Give up &

关注

踩

177

觉得还不错?

一键收藏

知道了

求质数（素数）算法，及算法优化

质数（素数）：只能被1和其本身整除的数字（其中1和0不属于质数）接下来我们用多种方法求1000以内（包含1000）的质数数量，并且统计每种方法的循环次数(如果只想知道速度快的方法可以直接看方法五)方法一：循环遍历所有情况int count1 = 0;//质数个数int count2 = 0;//循环次数for(int i=2;i<=1000;i++) { int fla...

复制链接

扫一扫

专栏目录

厄拉多塞法求素数.c

11-21

用厄拉多塞法求素数的C源代码

经典的素数筛算法学习笔记

04-02

包含了素数筛和线性筛算法的实现和理解，是很实用的一种筛选算法, 筛选算法的本质是一种标记算法

17 条评论

您还未登录，请先

后发表或查看评论

【经典专题】寻找质数——巧妙的埃氏筛和线性筛

丧心病狂Loli控的博客

12-12

230

很经典的题目：统计 [2,n)[2,n)[2,n) 中质数的数量

Demo1：input 10，output 4

Demo1：input 100，output 25

暴力枚举

首先，复习一遍质数的定义：在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。

最朴素的思想，对于一个数 nnn，把它除以 [2,n)[2, n)[2,n)的每一个数，如果出现了整除的情况（n % i == 0），则 nnn 即为质数。

这种纯暴力的方法（考虑最坏的情况），判断每个数的时间.

素数筛法求素数

04-23

之前在考研机试的时候看到了这个素数筛法，觉得还挺有趣的。解释下其中的一点，j为什么从i*i开始，按照一般思路应该从i*2开始的，但是仔细分析会发现i*i已经覆盖了i*2这个条件了，因此从i*i开始了。

c++ 求素数优化算法

09-12

新手我热爱算法，第一次由个人琢磨出来的优化求任意两个数之间的素数算法，谢谢。我个人觉得，他似乎可以减少时间复杂度

【数论】求素数的三种方法

最新文章

MySQL update中使用select

linux将新加磁盘绑挂载到指定目录

docker启动jar包（简易版）

2022年2篇

2021年12篇

2020年12篇

2019年135篇

分类专栏

SQL

6篇

Linux

6篇

面试

Git

4篇

工作

10篇

日常错误

13篇

Java高级

9篇

Redis

3篇

Spring系列

22篇

MyBatis

5篇

工作总结

第三方服务

1篇

Mycat

3篇

elasticsearch

2篇

分布式微服务

1篇

IDEA

1篇

Vue.js

2篇

ES6

Nginx

2篇

swagger

1篇

Maven

1篇

JavaWeb

8篇

HTML5

1篇

java

13篇

二维码

1篇

https

1篇

tomcat

1篇

算法

9篇

数据结构

java基础

43篇

被折叠的条评论

为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

祝福语

请填写红包祝福语或标题

红包数量

个

红包个数最小为10个

红包总金额

元

红包金额最低5元

余额支付

当前余额3.43元

前往充值 >

需支付：10.00元

取消

确定

下一步

知道了

成就一亿技术人!

领取后你会自动成为博主和红包主的粉丝

规则

hope_wisdom 发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值

python 列出1到100的质数 - 知乎

python 列出1到100的质数 - 知乎首发于python切换模式写文章登录/注册python 列出1到100的质数雁卿雁卿呀python 列出1到100的质数# 找到1 到100 的质数

#如果一个数只能被 1 和它本身整除，这个数就是质数

num = []

for i in range(2, 101):

flag = 0

for j in range(1, i+1):

if i % j == 0:

flag += 1

if flag == 2:

num.append(i)

print(num)

# !/usr/bin/python

# -*- coding: UTF-8 -*-

num = [];

i = 2

for i in range(2, 100):

j = 2

for j in range(2, i):

if (i % j == 0):

break

else:

num.append(i)

print(num)运行结果：以上如果对你有所帮助，就给 @雁卿雁卿呀点赞，留个关注吧。这样雁卿也会更有动力更新下去top外企⭐️亚马逊公司⭐️内推可以在工重号：雁卿雁卿呀找到我编辑于 2022-10-14 18:39Python赞同 111 条评论分享喜欢收藏申请转载文章被以下专栏收录pythonpython 基础学

Follow

tokenpocket钱包app官网下载最新版|写出20以内的所有质数

tokenpocket钱包app官网下载最新版|写出20以内的所有质数

Python 输出指定范围内的素数 | 菜鸟教程

百度知道 - 信息提示

用C语言输出1-100之间的素数（3种方法）_素数c语言程序编写-CSDN博客

Python多种方法求某个范围内的所有素数(质数) - 知乎

手把手教你用C语言实现求质数（素数），5大方法任君挑选_素数c语言程序编写-CSDN博客

Python – 获取 100 以内的质数 | 菜鸟教程

C语言:如何打印输出100以内的素数？ - 知乎

C语言编程求解：1到1000之间所有的素数 - 知乎

求质数（素数）算法，及算法优化_卡空间求素数-CSDN博客

python 列出1到100的质数 - 知乎

最近的新闻

您可能喜欢的文章

tokenpocketcom官网下载|什么是互为质数

imtoken下载网址|cspr怎么提到钱包

比特派怎么样使用才能更安全

澄海比特派对怎么样好玩吗

随州丘比特派对怎么样啊

比特派钱包是怎么样的软件

比特派钱包是怎么样的平台