用java判断101-200之间有多少个素数，并输出所有素数。

1. int sum, i;
   
2.                 for (sum = 2; sum <= 10; sum++) {
   
3.                         for (i = 2; i <= sum / 2; i++) {
   
4.                                 if (sum % i == 0) {
   
5.                                         break;
   
6.                                 }
   
7.                         }
   
8.                         if (i > sum / 2) {
   
9.                                 System.out.println(sum + "素数");
   
10.                         }
    
11.                 }

复制代码

public class nixu {
        public static void main(String[] args){
                for(int i = 101;i<=200;i++){
                        int n=0;
                        for(int j=2;j<i/2;j++){
                          if(i%j==0)
                                  n=n+1;
                        }
                        if(n==0)
                                System.out.println(i);
                }
        }

}

public class o{
        public static void main(String[] args){
      for(int i=101;i<=200;i++){
              boolean b=true;
              for(int j=2;j<=i/2;j++){
                      if(i%j==0)
                        b=false;
                          break;                    
              }
              if(b==true)
               System.out.println(i);
      }               
        }
}

上面那个用true false判断的，有一句语句冗余了，if(b==true)改为if(b)就行了，当时手抽了

这也就是一个循环判断的问题，从101遍历到200，判断是否只能整除本身和1，是的话为素数

1. class Demo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 //确定范围100~200
   
6.                 for(int x = 100;x<200;x++)
   
7.                 {        
   
8.                         //定义计数器
   
9.                         int num = 0;
   
10.                         //让x除以1到自身
    
11.                         for(int y=1;y<=x;y++)
    
12.                         {
    
13.                                 //如果能整除就+1
    
14.                                 if(x%y==0)
    
15.                                         num++;
    
16.                         }
    
17.                         //质数只能被1或自身整除，所以只要计数器为2 就可以确质数
    
18.                          if(num==2)
    
19.                                 System.out.print(x+"\t");
    
20.                 }
    
21.                
    
22.         }

复制代码

我的这种没有楼上几个同学的效率高，但是贵在好理解。

姜浩 发表于 2014-11-2 00:51
我的这种没有楼上几个同学的效率高，但是贵在好理解。

其实，好理解就是效率！楼主写的非常规范，赞一个！

Hosing 发表于 2014-11-2 10:46
其实，好理解就是效率！楼主写的非常规范，赞一个！

编写代码和人的思想是挂钩的，当时就想到了这么个粗浅的办法。但是和楼上的同学们比了一下，
确实效率没有他们高，并且还浪费资源。   大家可以研究研究楼上同学的代码。

姜浩 发表于 2014-11-2 00:51
我的这种没有楼上几个同学的效率高，但是贵在好理解。

num不是应该小于2吗？？？？？？？？？

Hosing 发表于 2014-11-2 10:50
num不是应该小于2吗？？？？？？？？？

素数是只能被1和自身整除， 被整除1次num就+1； 只有num等于2的数，才是素数。

不错喔，不错喔，不错喔，不错喔！

姜浩 发表于 2014-11-2 00:51
我的这种没有楼上几个同学的效率高，但是贵在好理解。

你的思路和楼上的几位不同，非常好的方法

使用标签也可以

1. public class PrimeNumber {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 IsPrime2();
   
5.         }
   
6. 
   
7.         private static void IsPrime2() {
   
8.                 int sum = 0;
   
9.                 outer:
   
10.                 for(int i=101;i<200;i++){
    
11.                         for(int j = 2;j<i/2;j++){
    
12.                                 if(i%j == 0)
    
13.                                         continue outer;
    
14.                         }
    
15.                         System.out.println(i+"是素数");
    
16.                         ++sum;
    
17.                 }
    
18.                 System.out.println("一共"+sum+"组素数");
    
19.         }

复制代码

姜浩 发表于 2014-11-2 11:16
素数是只能被1和自身整除， 被整除1次num就+1； 只有num等于2的数，才是素数。 ...

sodesnai!......

关键就是理解
a=i*j;(i<j)
    i^2<a<j^2;
    i<sqrt(a)<j
int sum = 0;
                outer:
                for(int i=101;i<200;i++){
                        for(int j = 2;j<sqrt(i);j++){
                                if(i%j == 0)
                                        continue outer;
                        }
                        System.out.println(i+"是素数");
                        ++sum;
                }
                System.out.println("一共"+sum+"组素数");

这是算法的思想，效率稍微高一点

1. package Test;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. public class Test003 {
   
7. 
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.                 List<Integer> list = new ArrayList<Integer>();        // 一个List，用于存放素数
    
11.                 for(int i=101;i<=200;i++){                // 遍历101-200，依次检查
    
12.                         if(isSushu(i)){
    
13.                                 list.add(i);
    
14.                         }
    
15.                 }
    
16.                 // 输出结果
    
17.                 System.out.println("101-200之间一共有"+list.size()+"个素数。分别为：");
    
18.                 for (int i : list) {
    
19.                         System.out.print(i+" ");
    
20.                 }
    
21.         }
    
22.         /**
    
23.          * 检查一个数是否为素数
    
24.          * @param num 需要检查的数字
    
25.          * @return 返回检查结果
    
26.          * */
    
27.         static boolean isSushu(int num){
    
28.                 for(int i=2;i<num/2;i++){
    
29.                         if(num%i==0){
    
30.                                 return false;
    
31.                         }
    
32.                 }
    
33.                 return true;
    
34.         }
    
35. }
    

复制代码