打印出1~1000范围中所有的“水仙花数”，所谓的“水仙花”是指一个三位数，其个位数的立方和等于该数本身。例如：153是一个水仙花数，因为153=（1的立方+5的立方+3的立方）。
代码看不懂，谁能解释一下~

1. public class NarcissisticNumber //水仙花数{
   
2. public static void main(String[] args)
   
3. {
   
4. for (int n = 100 ;n <1000 ;n++ )
   
5. {
   
6. int x,y,z;
   
7. x = n/100;
   
8. y = (n-x*100)/10;
   
9. z = n-x*100-y*10;
   
10. if (n == x*x*x+y*y*y+z*z*z )
    
11. {
    
12. System.out.println ("1--10000之间的水仙花数为"+ n); }
    
13. }
    
14. }
    
15. }
    
16. 
    

复制代码

代码看不懂，谁能解释一下

拿153来讲153=1的立方+5的立方+3的立方
因为水仙花数是一个三位数，所以只要求到百位、十位、个位就可以了。
百位=这个数/100,像153/100=1
十位=(这个数-百位数字*100)/10，像(153-1*100)/10=5
个位=这个数-百位*100-十位*10，像153-1*100-5*10=3
分别得到1,5,3 只要在让这个数与1的立方+5的立方+3的立方
的值进行比较，如果相等就是水仙花数

public class Demo {

        /**个位:x%10
         * 十位:x/10%10
         百位:x/10/10%10
         */
        public static void main(String[] args) {
               
                for (int i = 100; i < 1000; i++) {
                        int ge =i%10;
                        int shi=i/10%10;
                        int bai=i/10/10%10;
                        if (ge*ge*ge+shi*shi*shi+bai*bai*bai==i) {
                                System.out.println(i);
                        }
                }
        }

}

1. package com.mth.test;
   
2. 
   
3. public class NarcissisticNumber
   
4. // 水仙花数
   
5. {
   
6.         public static void main(String[] args) {
   
7.                 for (int n = 100; n < 1000; n++) {
   
8.                         // x代表百位 y代表十位 z代表个位
   
9.                         // 比如 拿数字 153 举例子
   
10.                         // 当 n循环到153
    
11.                         int x, y, z;
    
12.                         x = n / 100; // x=153/100 此时x=1
    
13.                         y = (n - x * 100) / 10;// y=(153-1*100)/10=53/10 此时 y=5
    
14.                         z = n - x * 100 - y * 10;// z=153-1(百位)*100-5(十位)*10 此时剩下的就是个位 z =3
    
15. 
    
16.                         if (n == x * x * x + y * y * y + z * z * z) { // 拿到了 百位，个位，十位
    
17.                                                                                                                         // 那么判断水仙花成立的条件
    
18.                                                                                                                         // 满足条件的话 就打印
    
19.                                 System.out.println("1--10000之间的水仙花数为" + n);
    
20.                         }
    
21.                 }
    
22.         }
    
23. }

复制代码

/*水仙花数就是个位+十位+百位=这个数
个位:x%10
十位:x/10%10
百位:x/10/10%10
*/
public class Test {

        
        public static void main(String[] args) {
               
                for (int x = 100; x <=999; x++) {
                        int ge =x%10;//个位上的数
                        int shi=x/10%10;//十位上的数
                        int bai=x/10/10%10;//百位上的数
                        if (ge*ge*ge+shi*shi*shi+bai*bai*bai==x) {//个位十位百位加起来等于这个数
                                System.out.println(x);
                        }
                }
        }

}

/*
判断100到1000内的水仙花数；
首先一个数判断是否是水仙花；
一个数的每个位的立方和等于这个数，那么他就是水仙花；
然后循环判断每一个数；
*/
public class NarcissisticNumber //水仙花数{
public static void main(String[] args)
{
           for (int n = 100 ;n <1000 ;n++ )
          {
                   int x,y,z;
                   x = n/100;//求得百位上的数
                   y = (n-x*100)/10;//求得十位上的数
                   z = n-x*100-y*10;//求得个位上的数
                   if (n == x*x*x+y*y*y+z*z*z )//判断循环中每个数是否为水仙花，如果是则打印水仙花
                  {
                         System.out.println ("1--10000之间的水仙花数为"+ n);
                  }
          }
}
}

我觉得要打印一个水仙花数,就要定义一个方法用来打印你传入的数内的所有水仙花数!而不是你确定了0到1000内的所有水仙花数,然后
/**个位:x%10
         * 十位:x/10%10
         百位:x/10/10%10
         */
这样只能解决你一时的要求,如果是打印 一亿以内的所有水仙花数,  是否每个位都要整除10呢?

下面我定义了一个自己的用于专门打印水仙花数的方法 ,能帮你更好的理解!

思想:得到一个数,只要将其每位上的数都拿出来,将每位数的立方加起来看是否是水仙花数
将一个数转换为字符串,截取字符串的每位数,转换成整数,算立方和


package wsc.itheima.com;
import java.util.ArrayList;
import java.util.Iterator;
public class MyTest3 {
  
             public static void main(String[] args) {
                             PrintNarcissus(1000);
              }
              private static void PrintNarcissus(int num){        //打印水仙花数的方法
                 for(int x=0;x<=num;x++){                                  //遍历传入的数
                 ArrayList<Object> al=new ArrayList<Object>();      //定义集合 ,用于存如,截取的每位数的立方
                 int len=0;
                 String s = String.valueOf(x);//将整形转化为字符串          //装换为字符串
                  for(int y=0;y<s.length();y++){                                     //遍历字符串的位数
                int n=Integer.parseInt(s.substring( y, y+1));                 //转换为 整数
              al.add(n*n*n);                                                                  //算立方
   
   }
                    Iterator<Object> it=al.iterator();                                // 迭代
                      while(it.hasNext()){                                               
                       len+=(Integer)it.next();                                            //将每位数的立方叠加赋给len
     }
                 if(len==x){
                System.out.println(x);                                                      //判读是否符合条件,符合则打印出来
                 }
     }
  }
}