任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：65432，一个最小的数23456。求这两个数字的差，
得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。
如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。
请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。
其中5位数全都相同则循环圈为 [0]，这个可以不考虑。
循环圈的输出格式仿照：[82962, 75933, 63954, 61974]其中数字的先后顺序可以不考虑。

真难,没看懂什么意思

1. package my.test4;
   
2. 
   
3. import java.util.ArrayList;
   
4. 
   
5. public class Test2 {
   
6. 
   
7.         /**
   
8.          * @param args
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 // TODO Auto-generated method stub
    
12.                 for(int i=10000;i<100000;i++)
    
13.                 {
    
14.                     ArrayList list=new ArrayList();
    
15.                      int con=0;
    
16.                                      int dif=getDif(i);
    
17.                      while(dif!=i)
    
18.                     {
    
19.                             if(list.contains(dif))
    
20.                                     break;//list中存在则跳出
    
21.                             else
    
22.                                     list.add(dif);
    
23.                             dif=getDif(dif);                           
    
24.                     }                    
    
25.                     if(dif==i)
    
26.                     {
    
27.                             for(int c=0;c<list.size();c++)
    
28.                                     System.out.print(list.get(c)+"|");
    
29.                                                 System.out.print(dif);
    
30.                             System.out.println();
    
31.                     }
    
32.                        
    
33.                 }
    
34.                
    
35.                
    
36.                
    
37.         }
    
38.         static int getDif(int original)
    
39.         {//得到最大值与最小值之差
    
40.                 int dif=0;
    
41.                 dif=getMax(original)-getMin(original);
    
42.                 return dif;
    
43.         }
    
44.         static int getMax(int original){//得到最大值
    
45.                 int max=0;
    
46.                 int p=0;
    
47.                 char mod;
    
48.                 char[] trs=(original+"").toCharArray();
    
49.                 for(int i=0;i<trs.length-1;i++)
    
50.                 {
    
51.                         p=i;
    
52.                         for(int k=i+1;k<trs.length;k++)
    
53.                         {
    
54.                                 if(trs[k]>trs[p])
    
55.                                         p=k;
    
56.                         }
    
57.                         if(p!=i)
    
58.                         {
    
59.                                 mod=trs[p];
    
60.                                 trs[p]=trs[i];
    
61.                                 trs[i]=mod;
    
62.                         }
    
63.                 }
    
64.                 String str=new String(trs);
    
65.                 max=Integer.parseInt(str);
    
66.                 return max;
    
67.         }
    
68.         static int getMin(int original){//得到最小值
    
69.                 int min=0;
    
70.                 int p=0;
    
71.                 char mod;
    
72.                 char[] trs=(original+"").toCharArray();
    
73.                 for(int i=0;i<trs.length-1;i++)
    
74.                 {
    
75.                         p=i;
    
76.                         for(int k=i+1;k<trs.length;k++)
    
77.                         {
    
78.                                 if(trs[k]<trs[p])
    
79.                                         p=k;
    
80.                         }
    
81.                         if(p!=i)
    
82.                         {
    
83.                                 mod=trs[p];
    
84.                                 trs[p]=trs[i];
    
85.                                 trs[i]=mod;
    
86.                         }
    
87.                 }
    
88.                 String str=new String(trs);
    
89.                 min=Integer.parseInt(str);
    
90.                 return min;
    
91.         }
    
92. 
    
93. }
    

复制代码

返回结果为：
59994|53955
53955|59994
82962|75933|63954|61974
71973|83952|74943|62964
61974|82962|75933|63954
83952|74943|62964|71973
62964|71973|83952|74943
63954|61974|82962|75933
75933|63954|61974|82962
74943|62964|71973|83952
并且测试了最大循环次数为9次，说明 5位数中
最多循环9此便能得到它本身或者（与它本身运算得到的值相等）

public class SortText
{
        public static void main(String[] args)
        {
                for(int i=10000;i<100000;i++){
                        Integer ceshi=(Integer)i;
                demo(ceshi.toString());
                }       
                List<String> list=new ArrayList<String>();
                for(String st1:set){
                        list.add(st1);
                }
                System.out.println(list+"这些数都是能构成数字黑洞的循环数"+"+发现一个规律:10000--100000之间的5位数正反两次循环排序差"都是这个集合里面的数");                               
        }
        public static void demo(String str1)
        {
                String a=str1;               
                Integer v=sortText(a,4);               
                String str4=sb2.toString();       
                 v=sortText(a,5);
                 String v1=v.toString();               
                if(str4.contains(v1)&&sb2.length()>30){       
                        sortText(a,4);
                        String hj=sb2.substring(6, 11);
                        set.add(hj);               
                }
        }               
        static HashSet<String> set=new HashSet<String>();
        static StringBuilder sb2=new StringBuilder();
        static StringBuilder sb1=new StringBuilder();
        static int j=0;       
        public static int sortText(String str,int a){
                if(a==4|a==5){sb2.delete(0, sb2.length());sb2.append(str+",");}
                for(int i=0;i<a;i++){
                        char[] ch=str.toCharArray();
                  if(ch.length ==5){
                        Arrays.sort(ch);
                        sb1.append(ch);
                        String min=sb1.toString();
                        String max=sb1.reverse().toString();
                        sb1.delete(0, sb1.length());
                        Integer distance=(Integer)(Integer.parseInt(max)-Integer.parseInt(min));
                        j=distance;
                        String dis=distance.toString();
                        str=dis;
                        if(dis.toCharArray().length==5){
                        sb2.append(j+",")                ;}
                  }               
                }
                return j;
        }               
}