只能被本身和1整除的数，怎么写啊

1. public class Test {
   
2. public static void main(String args[]) {
   
3.   System.out.println(getSum(123));
   
4. }
   
5. 
   
6. public static int getSum(int num) {
   
7.   int a = num % 10;
   
8.   int b = (num / 10) % 10;
   
9.   int c = num / 100;
   
10.   return a + b + c;
    
11. }
    
12. }

复制代码

1. package com.ms.test;
   
2. 
   
3. public class GetSushu {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.                 for(int x=100;x<=999;x++){
    
11.                         boolean flag=true;
    
12.                         for(int y=2;y<x;y++){
    
13.                                 if(x%y==0){
    
14.                                         flag=false;
    
15.                                         break;
    
16.                                 }
    
17.                         }
    
18.                         if(flag){
    
19.                                 System.out.println(x);
    
20.                         }
    
21.                        
    
22.                 }
    
23.         }
    
24. 
    
25. }
    

复制代码

定义标记

其实做这题，你要知道什么是质数就好办了，质数就是只能被自己和1整除的数。那么你将一个数拿来从1开始除，一直到它本身，如果能被除尽，则计数器加1，最后判断计数器的值就行了。

1. class Zhishu
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int count=0;
   
6.                 for(int i=1;i<=100;i++)
   
7.                 {
   
8.                         count=0;
   
9.                         for(int j=1;j<=i;j++)
   
10.                         {
    
11.                                 if(i%j==0)
    
12.                                 {
    
13.                                         count++;
    
14.                                 }
    
15.                         }
    
16.                         if(count==2||count==1)
    
17.                         {
    
18.                                 System.out.print(i+" ");
    
19.                         }
    
20. 
    
21.                 }
    
22.         }
    
23. }

复制代码

哈达洋 发表于 2014-10-15 21:19
其实做这题，你要知道什么是质数就好办了，质数就是只能被自己和1整除的数。那么你将一个数拿来从1开始除， ...

活到老学到老！

那个什么 合数才难理解

第一个是判断某一个三位数是否是质数

1. import java.util.Scanner;
   
2. 
   
3. public class PrimeNum {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 Scanner sc = new Scanner(System.in);
   
7.                 System.out.println("请输入一个三位数");
   
8.                 int  num = sc.nextInt();
   
9.                 if(num<100 || num>999)
   
10.                         throw new RuntimeException("输入数据不合要求");
    
11.                
    
12.                 getPrime(num);
    
13.         }
    
14.         public static void getPrime(int num){
    
15.                
    
16.                 for(int x=2;x<num;x++){
    
17.                         if(num%x!=0){
    
18.                                 if(x==num-1){
    
19.                                         System.out.println(num+"是质数");
    
20.                                 }
    
21.                                 continue;
    
22.                         }
    
23.                         else{
    
24.                                 System.out.println(num+"不是质数");
    
25.                                 break;
    
26.                         }                                
    
27.                 }               
    
28.         }
    
29. }

复制代码

第二个是列出所有介于100到你输入的三位数中的质数(不包含100)

1. import java.util.Scanner;
   
2. 
   
3. public class TotalPrimeNum {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 Scanner sc = new Scanner(System.in);
   
7.                 System.out.println("请输入一个三位数");
   
8.                 int  num = sc.nextInt();
   
9.                 if(num<100 || num>999)
   
10.                         throw new RuntimeException("输入数据不合要求");
    
11.                 getPrime(num);
    
12.         }
    
13.         public static void getPrime(int num){
    
14.                 int count = 0;//计数器记录质数个数
    
15.                 W:for (int x = 101; x <= num; x++) {
    
16.                         Q:for (int y = 2; y < x; y++) {
    
17.                                 if(x%y!=0){
    
18.                                         if(y==x-1){
    
19.                                                 System.out.print(x+"\t");
    
20.                                                 count++;
    
21.                                                 continue W;
    
22.                                         }
    
23.                                         continue Q;
    
24.                                 }
    
25.                                 else{
    
26.                                         continue W;
    
27.                                 }
    
28.                         }
    
29.                 }
    
30.                 System.out.println();
    
31.                 System.out.println("101到"+num+"共有质数个数为："+count);        
    
32.         }
    
33. }
    

复制代码

长知识了。

学习了，这么多方法

用双层for循环。第一层确定100-999中的一个数，第二层再判断从1到这个数还有没有其他因数。
具体代码为：

1. public class Test {
   
2.         public static void main(String[] args){
   
3.                
   
4.                 //第一个for循环，检测100到999之间每一个三位数。
   
5.                 for(int i=100;i<1000;i++){
   
6.                        
   
7.                         //定义flag。
   
8.                         boolean flag=true;
   
9.                        
   
10.                         //第二个for循环，针对每一个i值，检测1到其本身之间有没有其它的因数，
    
11.                         //如果有，将flag标记为false。
    
12.                         for(int j=2;j<i;j++){
    
13.                                 if(i%j==0){
    
14.                                         flag=false;
    
15.                                         break;
    
16.                                 }
    
17.                         }
    
18.                        
    
19.                         //如果flag为true，表明此i值除了1和其本身没有其他的因数，为质数，将其打印。
    
20.                         if(flag)
    
21.                                 System.out.println(i);
    
22.                 }
    
23.         }
    
24. }

复制代码

嘿～～ 发表于 2014-10-15 23:10
第一个是判断某一个三位数是否是质数

前辈，怎样发像你这样的可以复制的代码？