精华内容
下载资源
问答
  • 输出一百以内的素数
    千次阅读
    2021-03-26 14:08:27

    php输出1000以内质数(素数)示例

    复制代码 代码如下:

    for($i = 2; $i < 1001; $i++) {

    $primes = 0;

    for($k = 1; $k <= $i; $k++)

    if($i%$k === 0) $primes++;

    if($primes <= 2) // 能除以1和自身的整数(不包括0)

    echo "{$i}
    ";

    }

    时间: 2014-02-15

    复制代码 代码如下: # 判断是否是素数def is_sushu(num): res=True for x in range(2,num-1):  if num%x==0:   res=False   return res return res # 打印出素数列表print ([x for x in range(1000) if is_sushu(x)])

    素数就是质数,就是只能被1整除,不能被其他数整除的数 java程序为: 复制代码 代码如下: public static void main(String[] args) {        //程序打印出从100到200的所有素数并求和:         int Sum = 0; for (int i = 100; i <= 200; i++) {            boolean flag = true;            /*内嵌了一个for循环,作用是用100到200之间的每一个数

    题目:求100之内的素数 方法一: package airthmatic; public class demo8 { /** * 素数是指因数只有1和本身的数字 * @param arg */ public static void main(String arg[]) { for(int i=1;i<=100;i++) { if(find(i)) System.out.print(i+" "); } } /** * 1-n个自然数中的素数 * @param n * @return

    本文实例讲述了GO语言筛选法求100以内的素数.分享给大家供大家参考.具体实现方法如下: 思路:找出一个非素数就把它挖掉,最后剩下就是素数. 下面就来欣赏一下go简洁的代码吧 目前不支持GO的代码插入,使用xml的代替一下. 复制代码 代码如下: package main import (     "fmt"     "math" ) func main() {     var i, j, n int     var a [101]int     for i = 1

    质数又称素数.一个大于1的自然数,如果除了1和它自身外,不能被其他自然数整除的数:否则称为合数.根据算术基本定理,每一个比1大的整数,要么本身是一个质数,要么可以写成一系列质数的乘积:而且如果不考虑这些质数在乘积中的顺序,那么写出来的形式是唯一的.下面是一个java求100之内的素数简单示例 复制代码 代码如下: public class test { public static void main(String[] args) {  int i,n,k=0;     for (n = 3; n

    方法一,用for循环来实现 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 ==

    复制代码 代码如下: /** * @author jxqlovedn * 埃拉托斯特尼素数筛选法,请参考:http://zh.wikipedia.org/zh-cn/埃拉托斯特尼筛法 */public class AratosternyAlgorithm { public static void getPrimes(int n) {  if(n < 2 || n > 1000000)   // 之所以限制最大值为100万,是因为JVM内存限制,当然有其他灵活方案可以绕过(比如位图法)   th

    复制代码 代码如下: /** * 判断数组中的最大数 * @param args * @return */public static int getMaxNum(int args[]){int max=0;for(int i=0;iargs[max])max=i;}return args[max];} /** * 判断数组中的最小数 * @param args * @return */public static int getMinNu

    ruby求50之内的素数的方法,感觉对比PHP和SHELL方法是最简单的,但SHELL中可以利用factor命令,而PHP中没有求素数的对应函数的,需要自己设计算法,三种方式大家对比学习下,应该还有更优更简单的方法的. 复制代码 代码如下: #encoding:utf-8 #求50以内的素数(注意数字中..与...的区别)   for i in 2..50 #1默认不为素数,所以从1-50范围内被排除     f=true #起始假定每个数都是素数     for p in 2...i #比自身

    一,描写叙述 ​在多线程下编程的时候.大家可能会遇到一种需求,就是我想在我开启的线程都结束时,同一时候获取每一个线程中返回的数据然后再做统一处理,在这种需求下,Future与Callable的组合就派上了非常大的用场. 也有人会说,我能够使用同步来完毕这个需求啊,普通情况下确实能够.可是在一种特殊情况下就不行了: ​想象,你开启了多个线程同步计算一些数据,可是大家都知道,线程是会争用资源的,也就是说.你开启多个线程来同步计算数据时.事实上线程之间的计算顺序是不可空的,当然除非你非非常大周折去处理

    用Java Swing做的一个QQ登录界面 复制代码 代码如下: import java.awt.Container;import java.awt.Image;import java.awt.event.ActionEvent;import java.awt.event.ActionListener; import javax.swing.ImageIcon;import javax.swing.JButton;import javax.swing.JCheckBox;import javax

    更多相关内容
  • 输出100以内的所有质数(有难度,作为面试题出现过)** 方案: /* 100以内所有质数输出 注:质数又叫素数,指在大于1的自然数中,只能被1和它本身整除的自然数,最小的质数是2。 方法:个数n,从2开始到(n-1)为止...

    输出100以内的所有质数

    (有一定难度,曾作为面试题出现过)

    方案:

    /*
    100以内所有质数的输出
    注:质数又叫素数,指在大于1的自然数中,只能被1和它本身整除的自然数,最小的质数是2。
    
    算法思想:一个数n,从2开始到(n-1)为止,n都不能被这段数中的某个自然数整除,n即为质数。
    */
    
    class PrimeNumberTest
    {
    	public static void main(String[] args) 
    	{
    		boolean isFlag=true;  //标识i是否被j除尽,一旦除尽,修改其值
    		for(int i=2;i<=100;i++){  //遍历100以内的自然数
    			for(int j=2;j<i;j++){ //j:被i除
    				if(i%j==0){  //i被j除尽
    					isFlag=false;
    				}	
    			}
    			//必须所有的j考虑完以后,看i是否都没有除尽过才能判i是否为质数
    			//内层for循环结束
    			if(isFlag==true){ 
    				System.out.println(i);
    			}  //13-22行整体作为外层循环的循环体
    			isFlag=true; //重置一下标识,若不重置,只会输出2,3
    		}
    		
    	}
    }
    
    

    在这里插入图片描述
    方案第一步优化(添加break):
    为了运行效率对比更直观,选择一个较大的数100000

    测试原方案一(未优化)的运行时间:

    /*
    100000以内所有质数的输出
    */
    
    class PrimeNumberTest
    {
    	public static void main(String[] args) 
    	{
    		boolean isFlag=true; 
    		//获取当前时间距离1970-01-01 00:00:00的毫秒数
    		long start=System.currentTimeMillis();
    		for(int i=2;i<=100000;i++){ 
    			for(int j=2;j<i;j++){ 
    				if(i%j==0){  
    					isFlag=false;
    				}	
    			}
    			
    			if(isFlag==true){ 
    				System.out.println(i);
    			}  
    			isFlag=true; 
    		}
    		//获取当前时间距离1970-01-01 00:00:00的毫秒数
    		long end=System.currentTimeMillis();
    		System.out.println("不加break所花费时间为:"+(end-start));
    	}
    }
    
    

    在这里插入图片描述
    测试方案一(添加break优化后)的运行时间:

    /*
    100000以内所有质数的输出
    */
    
    class PrimeNumberTest
    {
    	public static void main(String[] args) 
    	{
    		boolean isFlag=true; 
    		//获取当前时间距离1970-01-01 00:00:00的毫秒数
    		long start=System.currentTimeMillis();
    		for(int i=2;i<=100000;i++){ 
    			for(int j=2;j<i;j++){ 
    				if(i%j==0){  
    					isFlag=false;
    					/*优化一(只对本身非质数有效):
    					添加break后,遇见除尽立即跳出循环。
    					如对于100只算到除2可除尽,立即跳出(类似短路)*/
    					break; 
    				}	
    			}
    			
    			if(isFlag==true){ 
    				System.out.println(i);
    			}  
    			isFlag=true; 
    		}
    		//获取当前时间距离1970-01-01 00:00:00的毫秒数
    		long end=System.currentTimeMillis();
    		System.out.println("加break进行第一次优化后所花费时间为:"+(end-start));
    	}
    }
    
    

    在这里插入图片描述
    由以上两个程序可以看出算法得到明显优化。

    方案第二步优化:

    /*
    100000以内所有质数的输出
    */
    
    class PrimeNumberTest
    {
    	public static void main(String[] args) 
    	{
    		boolean isFlag=true; 
    		//获取当前时间距离1970-01-01 00:00:00的毫秒数
    		long start=System.currentTimeMillis();
    		for(int i=2;i<=100000;i++){  //遍历1-100000内的自然数
    			//优化二:对本身是质数的自然数有效
    			for(int j=2;j<=Math.sqrt(i);j++){ 
    				if(i%j==0){  
    					isFlag=false;
    					/*优化一(只对本身非质数的自然数有效):
    					添加break后,遇见除尽立即跳出循环。
    					如对于100只算到除2可除尽,立即跳出(类似短路)*/
    					break; 
    				}	
    			}
    			
    			if(isFlag==true){ 
    				System.out.println(i);
    			}  
    			isFlag=true; 
    		}
    		//获取当前时间距离1970-01-01 00:00:00的毫秒数
    		long end=System.currentTimeMillis();
    		System.out.println("进行第二次优化后所花费时间为:"+(end-start));
    	}
    }
    
    

    在这里插入图片描述算法再次得到明显优化。
    注意:第二次优化将内层for循环的循环条件由j<i变为了j<=根号i:
    内层for循环
    由for(int j=2;j<i;j++)变为for(int j=2;j<=Math.sqrt(i);j++)

    相关解释如下图例子:

    在这里插入图片描述
    另一种实现方法:(更快)

    /*
    100000以内所有质数的输出
    */
    
    class PrimeNumberTest
    {
    	public static void main(String[] args) 
    	{
    		int count=0;
    		
    		//获取当前时间距离1970-01-01 00:00:00的毫秒数
    		long start=System.currentTimeMillis();
    		label:for(int i=2;i<=100000;i++){  
    			for(int j=2;j<=Math.sqrt(i);j++){ 
    				if(i%j==0){  //i被j除尽
    					continue label;  //此处表示当前i已经不靠谱,直接进行下一个
    				}	
    			}
    			//能执行的此步骤的都是质数
    			count++;
    		}
    		//获取当前时间距离1970-01-01 00:00:00的毫秒数
    		long end=System.currentTimeMillis();
    		System.out.println("100000内质数个数为:"+count);
    		System.out.println("运行后所花费时间为:"+(end-start));
    	}
    }
    
    

    在这里插入图片描述

    展开全文
  • public class 一百以内质数输出 { // 100以内的所有的质数输出 // 只能被1和本省整除的自然数 // 从2开始,到这个数结束为止,都不能被这个数整除的 public static void main(String[] args) { // TODO Auto...

    方法1:

    
    public class 一百以内质数的输出 {
    	// 100以内的所有的质数输出
    	// 只能被1和本省整除的自然数
    	// 从2开始,到这个数结束为止,都不能被这个数整除的
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		boolean isFlag = true;// 表示i是否被j除尽,一旦除尽,就修改这个值
    		for (int i = 2; i <= 100; i++) {// 遍历100以内的自然数
    
    			for (int j = 2; j < i; j++) {// j:被i去除
    				if (i % j == 0) {// i被j去除
    					isFlag = false;
    				}
    			}
    			if (isFlag == true) {
    				System.out.println(i);
    			}
    			// 重置isFlag
    			isFlag = true;
    		}
    	}
    
    }
    
    

    方法2:

    
    
    public class 一百以内质数的输出 {
    	// 100以内的所有的质数输出
    	// 只能被1和本省整除的自然数
    	// 从2开始,到这个数结束为止,都不能被这个数整除的
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		for (int i = 2; i <= 100; i++) {// 遍历100以内的自然数
    			boolean isFlag = true;// 表示i是否被j除尽,一旦除尽,就修改这个值
    			for (int j = 2; j < i; j++) {// j:被i去除
    				if (i % j == 0) {// i被j去除
    					isFlag = false;
    				}
    			}
    			if (isFlag == true) {
    				System.out.println(i);
    			}
    
    		}
    	}
    
    }
    
    
    

    结果:
    在这里插入图片描述

    展开全文
  • 本篇文章是对输出1000以内素数的算法进行了详细的分析介绍,需要的朋友参考下
  • (c语言)输出一百以内所有质数

    千次阅读 2021-05-17 08:44:13
    质数又称素数个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数; #include<stdio.h> void main() { int i,j; int flag=1; for(i=2;i<=100;i++) { for(j=2;j<=i/2;j++) ...

    质数又称素数。一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数;

    注:1不是素数

    #include<stdio.h>
    void main()
    {
    	int i,j;
    	int flag=1;     //定义flag,当flag=1时为素数,为0时则不为素数
    	for(i=2;i<=100;i++) //控制范围在一百以内,以2开始
    	{
    		for(j=2;j<=i/2;j++)  
    		{
    			if(i%j==0) //判断是否能被2整除
    			{
    			flag=0; //如果flag=0,则退出循环
    			break;
    			}
    		}
    		if(flag==1) //判断flag是否等于1
    		{
    			printf("%d\n",i);  //输出i
    		}
    		flag=1; //重新给flag赋值1,继续执行循环
    	}
    }
    

    运行结果如下:
    一百以内所有素数

    展开全文
  • 质数的定义:只能被1和其本身整除的数称为质数。最小的质数是2。 思路: ①定义个监测标识 ②循环遍历i(2~100)。 ... ⑤输出未被记录监测标识i,即为质数。 ⑥监测标识重置。 class...
  • JAVA输出100以内素数

    千次阅读 2021-04-07 08:46:42
    //输出100以内素数 public static void main(String[] args){ final int MAX=100; int j,k,n; System.out.println(“2~”+MAX+“之间的所有素数为:”); System.out.print(“2\t”); n=1; k=3; do{ j=3; while(j&...
  • Python输出一百以内质数素数

    万次阅读 2017-11-12 23:03:31
    >>> p=[2,] >>> for i in range(2,101): for temp in range(2,i): if i%temp==0: break if temp==i-1: p.append(i) ...[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
  • 汇编语言编程输出一百以内质数,十分易懂!!!!!!!!
  • #include<stdio.h> int main() { int x,i; for(x=2;x<100;x++) { int isprime=1; for(i=2;i<x;i++) { if(x%i==0) { isprime=0; break; } } if(isprime==1) ...}
  • C#取1000以内质数并按三角形输出 //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 //.................................................
  • 使用JavaScript判断100以内素数,素数的概念就是只有1和它本身两个因数的数。
  • java输出100以内质数素数)合

    千次阅读 2022-05-20 18:57:21
    public class New { public static void main(String[] args) { // TODO Auto-generated method stub int sum = 0;//定义总和 for (int i = 2;...//立个布尔型的标记来控制是否加质数进总和 for (int j...
  • php输出100以内素数质数

    万次阅读 多人点赞 2019-04-13 11:23:11
    方法 for($i=2;$i;$i++){ if($i){ //当i时走这条 if($i%4<>0&&$i%6<>0&&$i%9<>0){ //如果i不能被4.6.9整除 echo $i.' '; //就输出 } }else{ //当i不小于10时走这条 if($i%2<>0&...
  • 输出100以内素数质数) /** * 输出100以内素数 */ public class prime { public static void main(String[] args) { System.out.println(); boolean flag; for (int i = 2; i < 100; i++) { ...
  • //求一百以内素数 public class java_2022_9_11_prime_sum { public static void main(String agrs[]) { /*是java程序的入口地址,java虚拟机运行程序的时候首先找的就是main方法。参数String[] args是一个字符...
  • 输出100以内素数

    万次阅读 多人点赞 2017-12-06 11:58:32
    ···输出100以内素数的关键是明白素数的概念:只能被自身或1整除的数叫素数。0和1都不是素数。 ···应该想到用for循环,既然0,1不是素数,那循环就应从2开始,到100。 ···要判断能不能整除其他数,就应该...
  • js输出100以内质数

    千次阅读 2021-02-07 17:29:52
    1、质数的定义     若一个整数,只能被1和自身整除,则这个数就是质数...若没有个整除的,则n是质数。 3、js语言实现质数判断 //5.1) 判断质数 function getPrimes(arr) { return arr.filter(function (ele) {
  • Python实现输出100以内质数

    万次阅读 多人点赞 2020-12-29 19:32:59
    python实现输出100以内质数 (两种方法) First: zhishu = [] for num in range(2,100): if(num == 2): zhishu.append(2) for n in range(2,num): if num % n == 0: break else: if(n==num-1): zhishu....
  • //根据算术基本定理,每个比1大的整数,要么本身是质数,要么可以写成系列质数的乘积;而且如果不考虑这些质数在乘积中的顺序,那么写出来的形式是唯一的。最小的质数是2 for (int i = 2; i ; i++) { int j...
  • 主要介绍了JavaScript 斐波那契数列 倒序输出 输出100以内质数代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • C语言:输出100以内素数

    千次阅读 2021-10-13 22:29:26
    我们知到,查找素数有很多种思路,以下是个用接地气的算法,输出100以内素数 #include <stdio.h> int main() { int flag = 1;//标记:是素数 flag=1,不是素数 flag=0 // i:从 2 到 99 中找素数 for ...
  • 用Python输出100以内质数

    千次阅读 2022-03-23 20:34:49
    # 遍历2到100的数,因为[1]可以是其他数的质数 for i in range(2,100): # 一样遍历2到2到100的数 for j in range(2, i): # 判断如果模等于0,说明不是质数,结束... # 否则输出质数 else: print(i,end=' ') ...
  • 输出100以内质数

    2020-12-12 11:30:02
    质数素数):个大于1的自然数,除了1和它本身外,不能被其他自然数整除的数就叫做质数。 最小的质数是 2。 规律:从 2 开始,到这个数 减 1 结束为止 1.方式:最普通的做法 /* 实现方式 */ class ...
  • 个大于1的自然数,除了1和它本身外,不能被其他自然数(质数)整除,换句话说就是该数除了1和它本身以外不再有其他的因数;否则称为合数。 public class demo7{ public static void main(String[] args) { ...
  • 输出1000以内素数 汇编课程设计,可以用的,直接用编译器打开,或者用记事本打开就够了

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,742
精华内容 7,496
关键字:

输出一百以内的素数