任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：65432，一个最小的数23456。求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。

请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：
[82962, 75933, 63954, 61974]
其中数字的先后顺序可以不考虑。

1. package itheima.blog;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Arrays;
   
5. import java.util.List;
   
6. 
   
7. public class NumberBlackhole {
   
8. 
   
9.         public static void main(String[] args) {
   
10.                 // TODO Auto-generated method stub
    
11.                 List<Integer> allNumber = new ArrayList<Integer>();
    
12.                 List<Integer> repeatedNumber = new ArrayList<Integer>();
    
13.                 int value = 99887;//指定一个数
    
14.                 while(true){
    
15.                        
    
16.                         if(allNumber.contains(value)){
    
17.                                 if(repeatedNumber.contains(value))
    
18.                                         break;
    
19.                                 else
    
20.                                         repeatedNumber.add(value);
    
21.                         }
    
22.                         else{
    
23.                                         allNumber.add(value);
    
24.                         }
    
25.                                
    
26.                         value = nextNumber(toArray(value));
    
27.                 }
    
28.                 System.out.println(allNumber);
    
29.                 /*打印循环圈*/
    
30.                 System.out.println(repeatedNumber);
    
31.         }
    
32. 
    
33. 
    
34.              
    
35.         public static int[] toArray(int n){
    
36.                 int arr[]=new int[5];
    
37.                 for(int i=0; i<5; i++){
    
38.                         arr[4-i] = n%10;
    
39.                         n = n/10;
    
40.                 }
    
41.             return arr;
    
42.         }
    
43.        
    
44.         public static int nextNumber(int a[]){
    
45.             Arrays.sort(a);
    
46.             String min="";
    
47.             for(int i=0;i<5;i++){
    
48.                     min=min+String.valueOf(a[i]);
    
49.             }
    
50.             int Min=Integer.parseInt(min);
    
51.             StringBuffer sb = new StringBuffer(min).reverse();
    
52.             String max = sb.toString();
    
53.             int Max = Integer.parseInt(max);
    
54.             return Max-Min;
    
55.         }
    
56. 
    
57. }
    

复制代码

你这是蓝桥杯（C本科组）的试题，之前参赛前做的练习题有它，直接你代码吧：

1. #include <stdio.h>
   
2. struct
   
3. {
   
4.   int num;
   
5.   int next;
   
6.   int node;
   
7. }N[100000];
   
8. 
   
9. void init()
   
10. {
    
11.   int i;
    
12.   for(i=0; i<100000;i++)
    
13.         {  
    
14.           N[i].num=i;
    
15.           N[i].next=-1;
    
16.           N[i].node=-1;
    
17.         }
    
18. }
    
19. 
    
20. int maxof(int m)
    
21. {
    
22.   int i, t = 0;
    
23.   int d[10] = {0,0,0,0,0,0,0,0,0,0};
    
24.   while (m > 0)
    
25.   {
    
26.     d[m%10]++;
    
27.     m/=10;
    
28.   }
    
29.   for (i = 9; i >= 0; i --)
    
30.     while (d[i] > 0)
    
31.     {
    
32.           t*= 10;
    
33.           t += i;
    
34.           d[i] --;
    
35.          }  
    
36.   return t;
    
37. }
    
38. 
    
39. int minof(int m)
    
40. {
    
41.   int i, t = 0;
    
42.   int d[10] = {0,0,0,0,0,0,0,0,0,0};
    
43.   while (m > 0)
    
44.   {
    
45.     d[m%10]++;
    
46.     m/=10;
    
47.   }
    
48.   for (i = 0; i <= 9; i ++)
    
49.     while (d[i] > 0)
    
50.     {
    
51.           t*= 10;
    
52.           t += i;
    
53.           d[i]--;
    
54.         }  
    
55.   return t;
    
56. }
    
57. 
    
58. int trans(int m)
    
59. {
    
60.   return (maxof(m)-minof(m));
    
61. }
    
62. 
    
63. int main()
    
64. {
    
65.    int i,t,k,j,count=0;
    
66.    init();
    
67.    for(i = 0;i<100000; i ++)
    
68.      if(N[i].next== -1)  
    
69.      {
    
70.         k = i;
    
71.         do        
    
72.         {                              
    
73.             N[k].next = trans(k); //下一个位置
    
74.             N[k].node = i; //首先由i开始的链
    
75.             k = trans(k);   
    
76.          }while (N[k].next == -1);  //遇到已经处理的节点则结束
    
77.         
    
78.         
    
79.          if (N[k].node== i)  //是首先由i起始的链才是首次发现的圈
    
80.          {
    
81.            t = k;
    
82.            printf("%d: [%d", count++, t);
    
83. 
    
84.            while (trans(k) != t)
    
85.            {
    
86.              k = trans(k);
    
87.                          printf(", %d", k);
    
88.              N[k].node = 1;      
    
89.            }
    
90.            printf("]\n");
    
91.          }
    
92.      }
    
93. }

复制代码