参加本次活动先看以下链接

求质数算法的N种境界 (N > 10)

So，进入本次活动的主题吧，一切都是围绕着思想的
凡是：
       敲出其中代码的，
       提出不同思路的，
       技术性越强，奖励越高
       思想也是一样，都是有奖励的

那我就回一次看看

kankan                     

额  再来一次

1. import java.util.InputMismatchException;
   
2. import java.util.Scanner;
   
3. /*
   
4. * 求质数的一种算法。
   
5. * 算法思想：所谓质数，即除了1和它自己本身外没有其他的因数的数。经分析，对于任意一个自然数，其最大的因数不会超过其自身的一半，
   
6. *                                 所以对于任意一个自然数，只需要让其对不超过自身一半大小的所有数逐一求摸，只要余数为0，则这个数就不是质数，否则它就是
   
7. *                                 一个质数。
   
8. * 程序功能：输入x值，查找出1-----x之间所有的质数并打印输出，同时在最后输出1------x之间质数的总个数，不包括x本身。这个程序完成的是需求1。
   
9. * 算法实现代码如下：
   
10. * */
    
11. public class SeekPrime {
    
12.         static int count = 0;                //记录查找到的质数的个数，初始值为0.
    
13.         public static void main(String[] args)
    
14.         {
    
15.                 Scanner sc = new Scanner(System.in);
    
16.                 System.out.println("请输入你所要求的宿舍的区间1------x中的x：");
    
17.                 while(true)
    
18.                 {
    
19.                         try
    
20.                         {
    
21.                                 int x = sc.nextInt();
    
22.                                 if(x<1)
    
23.                                 {
    
24.                                         System.out.println("你输入的数据必须是大于0的整数，请重新输入x：");
    
25.                                         x = sc.nextInt();
    
26.                                 }
    
27.                                 justPrime(x);
    
28.                                 System.out.println();
    
29.                                 System.out.println("1------"+x+"之间的质数一共有"+count+"个。");
    
30.                                 break;
    
31.                         }catch(InputMismatchException e)
    
32.                         {
    
33.                                 System.out.println("你输入的数据有误，请重新输入x：");
    
34.                                 sc = new Scanner(System.in);
    
35.                         }        
    
36.                 }
    
37.         }
    
38.         
    
39.         
    
40.         //寻找指定的1----x之间的质数。
    
41.         public static void justPrime(int x)
    
42.         {
    
43.                 for(int j =1;j<x;j++)
    
44.                 {
    
45.                         if(j==1)
    
46.                                 continue;
    
47.                         int i =1;
    
48.                         for(;i<=j/2;i++)
    
49.                         {
    
50.                                 if(j%i==0&&i!=1)
    
51.                                         break;
    
52.                                 else
    
53.                                         continue;
    
54.                         }
    
55.                         if(i>j/2)
    
56.                         {
    
57.                                 count++;
    
58.                                 if(count%15==0)                                //每15个质数换一行
    
59.                                         System.out.println(j);
    
60.                                 else
    
61.                                         System.out.print(j+"\t\t");                //输出质数
    
62.                         }
    
63.                 }
    
64.         }
    
65. }
    

复制代码

1. import java.util.InputMismatchException;
   
2. import java.util.Scanner;
   
3. /*
   
4. *  ◇需求2请实现一个函数，对于给定的整型参数 N，该函数能够从小到大，依次打印出自然数中最小的 N 个质数。
   
5.         比如，当 N = 10，则打印出
   
6.         2 3 5 7 11 13 17 19 23 29
   
7. * 求质数的一种算法。
   
8. * 算法思想：所谓质数，即除了1和它自己本身外没有其他的因数的数。经分析，对于任意一个自然数，其最大的因数不会超过其自身的一半，
   
9. *                                 所以对于任意一个自然数，只需要让其对不超过自身一半大小的所有数逐一求摸，只要余数为0，则这个数就不是质数，否则它就是
   
10. *                                 一个质数。
    
11. * 程序功能：输入x值，依次打印出自然数中最小的 x 个质数。此程序完成的是需求2。
    
12. * 算法实现代码如下：
    
13. * */
    
14. public class SeekPrime1 {
    
15.         static int count = 0;                //记录查找到的质数的个数，初始值为0.
    
16.         public static void main(String[] args)
    
17.         {
    
18.                 Scanner sc = new Scanner(System.in);
    
19.                 System.out.println("请输入你所要求的质数的个数x：");
    
20.                 while(true)
    
21.                 {
    
22.                         try
    
23.                         {
    
24.                                 int x = sc.nextInt();
    
25.                                 if(x<1)
    
26.                                 {
    
27.                                         System.out.println("你输入的数据必须是大于0的整数，请重新输入x：");
    
28.                                         x = sc.nextInt();
    
29.                                 }
    
30.                                 countPrime(x);
    
31.                                 System.out.println();
    
32.                                 break;
    
33.                         }catch(InputMismatchException e)
    
34.                         {
    
35.                                 System.out.println("你输入的数据有误，请重新输入x：");
    
36.                                 sc = new Scanner(System.in);
    
37.                         }       
    
38.                 }
    
39.         }
    
40.        
    
41.        
    
42.         //寻找指定的1----x之间的质数。
    
43.         public static void countPrime(int x)
    
44.         {
    
45.                 for(int j =1;j<10000000;j++)
    
46.                 {
    
47.                         if(j==1)
    
48.                                 continue;
    
49.                         int i =1;
    
50.                         for(;i<=j/2;i++)
    
51.                         {
    
52.                                 if(j%i==0&&i!=1)
    
53.                                         break;
    
54.                                 else
    
55.                                         continue;
    
56.                         }
    
57.                         if(i>j/2)
    
58.                         {
    
59.                                 count++;
    
60.                                 if(count<=x)
    
61.                                 {
    
62.                                         if(count%15==0)                                //每15个质数换一行
    
63.                                                 System.out.println(j);
    
64.                                         else
    
65.                                                 System.out.print(j+"\t\t");                //输出质数
    
66.                                 }
    
67.                                 else
    
68.                                         break;
    
69.                         }               
    
70.                 }
    
71.         }
    
72. }
    

复制代码

在1~sqrt(n)之间找就行了。在判断玩2、3、5...等数之后，顺便可以排除他们的倍数。

什么时候再有技术分的活动

我也回复一个算法吧。

import java.util.Scanner;

public class PrimeTest {
        public static void main(String []args)
        {
                System.out.println("请输入你要求素数区间的最大值：");
                Scanner in=new Scanner(System.in);
               
                int x=in.nextInt();
                getPrime(x);
        }

       
        public static void getPrime(int x)
        {/*想法，在（2,x]这个区间中所有的偶数都不是素数
                这样范围就减少一半了，这个小区间中能被3整除的数也都不是素数，
                */
                System.out.print("1~"+x+"之间的素数有：2,3");
                        for(int i=3;i<=x;i+=2){               
                                if(i%3==0)
                                        continue;               
                                        for(int j=2;j<=Math.sqrt(i);j++){
                                        if(i%j==0)
                                                break;
                                        }
                                        System.out.print(","+i);
                        }
               
        }
}

publicclassPrime{ /**
         * 一般求素数方法
         *
         * @param args
         */publicstaticvoidmain(String[]args){for(inti=2; i<100; i++){intj;
for(j=2; j<(int)(Math.sqrt(i)+1); j++) {if(i%j==0){break;}}
if(j>(int)Math.sqrt(i)){System.out.print(i+" ");}} } }

publicclassPrime2{ /**
         * 筛法求素数
         *
         * @param args
         */publicstaticvoidmain(String[]args){// TODO Auto-generated method stubintn=100;
int[]array=newint[n];for(inti=2; i<n; i++)array[i]=i;
for(inti=2; i<n; i++){if(array[i]!=0){intj, temp;

回帖看看   

public class Test {
    public static void main(String[] args) {
          //循环100以内的数
          for (int n=1;n<=100;n++){
           //给b初始值true
           boolean b = true;
           //如果循环拿到的数n不等于1，就进入下面循环
           if (n != 1 ){
            //i从大于1的第一个数也就是2开始，一次循环到比这个数n本身小的最大的数
            //何为质数，除了1和他本身不能再被其他数整除。所以...这样循环
            for (int i = 2; i < n; i++){
             if (n % i == 0){//如果取余为0，也就是除了1和其本身有其他数可以乘除他，所以置为false
              b = false;
              //跳出当前循环，判断是否打印，并且到外面循环继续
              break;
             }

            }
           }
           //如果b为true打印下面的质数
           if (b){
            System.out.println(n + "是质数");
           }
          }
         }
}

1. <div class="blockcode"><blockquote>
   
2. /*
   
3. * 经过对质数的分析，发现质数属于奇数的一部分（除了2），质数只能被1和其自身整除，当然奇数是不能被任何偶数整除的，
   
4. * 所以质数也不能被任何偶数整除的（不包含2）；还发现任何奇数的除数都不会超过其本身的一半，且还有一些规律
   
5. * 结论:只要判断是否能够被一些奇数整除，便可知道此数书否为质数。
   
6. * */
   
7. public class ClassFor {
   
8.         public static void main(String[] args){
   
9.                 show(7); //在这里输入大于7的任何数
   
10.         }
    
11.         public static void show(int i){
    
12.                 StringBuilder sb = new StringBuilder();
    
13.                 sb.append("2,3,5,7,");
    
14.                 int num =0;
    
15.                 for(int x= 9;x<=i;x+=2) //定义x的取值范围小于等于用户指定的数i
    
16.                 {
    
17.                         for(int y =1;y<=(x-1)/2;y+=2) //产生一定范围内的奇数
    
18.                         {
    
19.                                 if(x%y!=0) //判断书否能够被产生的奇数整除
    
20.                                         num=x;         //不能整除将产生的奇数存储
    
21.                         }
    
22.                         if(num!=0)
    
23.                                 sb.append(num+",");
    
24.                 }
    
25.                
    
26.                 sb.deleteCharAt(sb.length()-1);
    
27.                 System.out.println(sb);
    
28.         }
    
29. 
    
30. }
    

复制代码

public class test3 {
/**
  * @param args
  */
public static void zs(int n){
  boolean flag = false;
  for(int i = 2 ; i<=n/2 ;i++){
   if(n % i == 0){
    flag = true;
    break;
   }
  }
  if(!flag){
   System.out.println(n+" 是质数!");
  }
  n--;
  if(n==2){
   System.out.println("2 是质数!");
  }else{
   zs(n);
  }
  
}
public static void main(String[] args) {
  zs(100);
}
}

写一个判断质数的函数，参数是n,从2到sqrt(n)不停的除这个数，如果能整除，就不是质数，如果不能整除，就是质数

public class test3 {
/**
  * @param args
  */
public static void zs(int n){
  boolean flag = false;
  for(int i = 2 ; i<=n/2 ;i++){
   if(n % i == 0){
    flag = true;
    break;
   }
  }
  if(!flag){
   System.out.println(n+" 是质数!");
  }
  n--;
  if(n==2){
   System.out.println("2 是质数!");
  }else{
   zs(n);
  }
  
}
public static void main(String[] args) {
  zs(100);
}
}

有活动真好啊

import java.util.Scanner;

public class PrimeNumber {
        public static void main(String[] args) {
                System.out.println("input numbers:");
                Scanner scan = new Scanner(System.in);
                int num = scan.nextInt();
                int flag = 1;
                for (int i = 2; i < (num / 2); i++) {

                        if (num % i != 0) {
                                flag = 1;
                        } else {
                                flag = 0;
                        }

                }
                if (flag == 1) {
                        System.out.println(num + "是质素！！");

                } else {
                        System.out.println(num + "不是质素！！");
                }

        }
}

import java.util.Scanner;

/*
* 素数：只能被1和本身整除的数。(不包括1)
* 需求：输出1~n之间的所有素数，每行打印5个
* 2  3  5  7  11
* 13 17 19 23 29...
* 思想：所谓素数，是和in呢个被1和本身整除的自然数，判断一个自然数是不是素数，
* 只要将逐一求模运算(从1开始，到这个自然数的一半)，只能被1和本身整除的数，都可以称之为素数，，反之则不是素数。
* 程序实现：输出1~n之间的所有素数，每行打印5个。
* 代码：
* */
public class PrimeNumberDemo {

        /**
         * @author Doevents
         *
         */
        public static void main(String[] args) {
                prime();
        }
       
        public static void prime(){
                int t=0;  //定义打印个数
                boolean flag;
                Scanner sc=new Scanner(System.in);
                System.out.println("请输入素数的个数：");
                int k=sc.nextInt();
                System.out.println("1~"+k+"之间的素数有：");
                for(int i=2;i<=k;i++){
                        flag=true;
                        for(int j=2;j<=i/2;j++){
                                if(i%j==0){
                                        flag=false;        //非素数
                                        break;
                                }
                        }
                        if(flag){
                                System.out.print(i+"\t");
                                t++;        //累加器
                               
                                if(t%5==0){        //每行输入5个
                                        System.out.println();
                                }
                        }
                }               
        }
}