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

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

这题怎么做？

来和你增加人气！

1. 
   
2. import java.util.ArrayList;
   
3. import java.util.Arrays;
   
4. import java.util.List;
   
5. 
   
6. /*
   
7. 关注微信有你想不到的惊喜任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：
   
8. 65432，一个最小的数23456。求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。
   
9. 如此往复，数字会落入某个循环圈（称为数字黑洞）。
   
10. 比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。
    
11. 
    
12. 请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：
    
13. [82962, 75933, 63954, 61974]
    
14. 其中数字的先后顺序可以不考虑。
    
15. *
    
16. * 思路：       
    
17. *                 1.把5个数字转换为长度为5的数组。
    
18. *                 2.每个索引中的值都为0-9。
    
19. *                 3.升序和降序排列。
    
20. *                 4.将数组转换为字符串输出，然后将字符串转换为数字进行运算
    
21. *                 5.对得到的数字进行递归运算，如果5位数全部相同，则停止循环。
    
22. *                 6.将得到的数字装到list中。
    
23. * */
    
24. 
    
25. public class DigitDarkHoleDemo {
    
26.         public static void main(String[] args) {
    
27.                 int x = 34256;
    
28.                 digitHole(x);
    
29.         }
    
30.         /*利用递归调用，每次获取到的数字，都跟集合中已经存在的数字相比较，若想等则说明找到该循环*/
    
31.         public static void digitHole(int x){
    
32.                 int temp = getNum(x);
    
33.                 List<Integer> list = new ArrayList<>(10);
    
34.                 boolean flag = true;
    
35.                 while(flag){
    
36.                         list.add(temp);
    
37.                         temp=getNum(temp);
    
38.                         for(int i=0;i<list.size();i++){
    
39.                                 if(temp == list.get(i)){
    
40.                                         int index = list.indexOf(temp);
    
41.                                         while(index>0){
    
42.                                                 try {
    
43.                                                         list.remove(0);
    
44.                                                         index--;
    
45.                                                 }catch (Exception e) {
    
46.                                                         e.printStackTrace();
    
47.                                                 }
    
48.                                         }
    
49.                                         flag=false;
    
50.                                         break;
    
51.                                 }
    
52.                         }
    
53.                 }
    
54.                 System.out.println(list);
    
55.         }
    
56.         @Override       
    
57.         public String toString() {//用集合来装数字黑洞中的循环圈
    
58.                 String str="[";
    
59.                 List<Integer> list = new ArrayList<>();
    
60.                 for(int i=0;i<list.size();i++){
    
61.                         if(i==list.size()-1){
    
62.                                 str+=list.indexOf(i);
    
63.                         }else{
    
64.                                 str+=list.indexOf(i)+",";
    
65.                         }
    
66.                 }
    
67.                 return str+"]";
    
68.         }
    
69.        
    
70.         public static int getNum(int num){//获得一个5位数的数字黑洞
    
71.                 int[] arr = new int[5];
    
72.                 int[] temparr = getArr(num);
    
73.                 if(temparr.length<5){
    
74.                         for(int i=0;i<5-temparr.length;i++){
    
75.                                 arr[i] = 0;
    
76.                         }
    
77.                 }
    
78.                 System.arraycopy(temparr, 0, arr, arr.length-temparr.length, temparr.length);
    
79.                 Arrays.sort(arr);
    
80.                 int min = arr2Num(arr);//得到这个数字升序排列后的数字
    
81.                 invert(arr);
    
82.                 int max = arr2Num(arr);
    
83.                 int temp = max-min;//得到最大值减去最小值的差，得到新的数据
    
84.                 return temp;
    
85.                
    
86.         }
    
87.        
    
88.         public static int[] getArr(int x){//将得到的数变成一个数组，好进行升序与降序排列
    
89.                 String str = x+"";
    
90.                 char[] carr = str.toCharArray();
    
91.                 int[] arr = new int[carr.length];
    
92.                 for(int i=0;i<carr.length;i++){
    
93.                         arr[i] = Character.getNumericValue(carr[i]);
    
94.                 }
    
95.                 return arr;
    
96.         }
    
97.        
    
98.         public static int arr2Num(int[] arr){//将数组变成数字
    
99.                 String str = "";
    
100.                 for(int i=0;i<arr.length;i++){
     
101.                         str+=arr[i];
     
102.                 }
     
103.                 return Integer.parseInt(str);
     
104.         }
     
105.        
     
106.         public static void invert(int[] arr){//反转数组，用于将数组逆序排列
     
107.                 int temp = 0;
     
108.                 for(int i=0;i<arr.length/2;i++){
     
109.                         temp = arr[arr.length-1-i];
     
110.                         arr[arr.length-1-i] = arr[i];
     
111.                         arr[i] = temp;
     
112.                 }
     
113.         }       
     
114.        
     
115. }
     

复制代码

1. package day4;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. /**
   
6. * 任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：65432，一个最小的数23456。
   
7. * 求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。
   
8. * 比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。
   
9. * 请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。
   
10. * 循环圈的输出格式仿照：[82962, 75933, 63954, 61974]
    
11. * 其中数字的先后顺序可以不考虑。
    
12. * @author Administrator
    
13. */
    
14. public class DigitalBlackHole {
    
15. 
    
16.         public static void main(String[] args) {
    
17.                
    
18.                 int num = 34258;
    
19.                 print(num);
    
20.         }
    
21.        
    
22.         //把循环圈内的数字提取出来，并规范成具有一定格式的字符串
    
23.         private static void print(int num){
    
24.                
    
25.                 //直到第一次出现重复元素才终止循环，并装入集合中(包含第一次出现的重复元素)
    
26.                 ArrayList<Integer> list = new ArrayList<Integer>();
    
27.                 int ret = getSub(num);
    
28.                 while(ret != 0){
    
29.                         ret = getSub(ret);
    
30.                         if(list.contains(ret)){
    
31.                                 list.add(ret);
    
32.                                 break;
    
33.                         }else{
    
34.                                 list.add(ret);
    
35.                         }
    
36.                 }
    
37.                
    
38.                 //用来装循环圈内的数字
    
39.                 List<Integer> subList = new ArrayList<Integer>();
    
40.                 for(int i = 0; i < list.size(); i++){
    
41.                         if(list.get(i).equals(list.get(list.size() - 1))){
    
42.                                 subList = list.subList(i, list.size() - 1);
    
43.                                 break;
    
44.                         }
    
45.                 }
    
46.                
    
47.                 //把集合内数字转换成字符串
    
48.                 String str = "[";
    
49.                 for(int i = 0; i < subList.size(); i++){
    
50.                         str += subList.get(i);
    
51.                         if(i != subList.size() - 1){
    
52.                                 str += ",";
    
53.                         }
    
54.                 }
    
55.                 str += "]";
    
56.                 System.out.println(str);
    
57.         }
    
58.        
    
59.         //求最大数与最小数之差
    
60.         private static int getSub(int num){
    
61.                
    
62.                 StringBuilder sb = new StringBuilder("");
    
63.                 sb.append(num);
    
64.                
    
65.                 char[] ch = sb.toString().toCharArray();
    
66.                 if(ch.length != 5){
    
67.                         for(int i = 0; i < 5 - ch.length; i++){
    
68.                                 sb.append(0);
    
69.                         }
    
70.                 }
    
71.                 ch = sb.toString().toCharArray();
    
72.                
    
73.                 int subtract = descending(ch) - ascending(ch);
    
74.                
    
75.                 return subtract;
    
76.         }
    
77.        
    
78.         //数组元素升序排序(冒泡),并转换成int整数
    
79.         private static int ascending(char[] arr){
    
80.                 int min = 0;
    
81.                 String str = "";
    
82.                 for(int i = 0; i < arr.length - 1; i++){
    
83.                         for(int j = 0; j < arr.length - 1 - i; j++){
    
84.                                 if(arr[j] > arr[j + 1]){
    
85.                                         char temp = arr[j];
    
86.                                         arr[j] = arr[j + 1];
    
87.                                         arr[j + 1] = temp;
    
88.                                 }
    
89.                         }
    
90.                 }
    
91.                 for (char c : arr) {
    
92.                         str += c;
    
93.                 }
    
94.                 min = new Integer(str);
    
95.                 return min;
    
96.         }
    
97.        
    
98.         //数组元素降序排序(选择),并转换成int整数
    
99.         private static int descending(char[] arr){
    
100.                 int max = 0;
     
101.                 String str = "";
     
102.                 for(int i = 0; i < arr.length - 1; i++){
     
103.                         for(int j = i; j < arr.length - 1; j++){
     
104.                                 if(arr[i] < arr[j + 1]){
     
105.                                         char temp = arr[i];
     
106.                                         arr[i] = arr[j + 1];
     
107.                                         arr[j + 1] = temp;
     
108.                                 }
     
109.                         }
     
110.                 }
     
111.                 for (char c : arr) {
     
112.                         str += c;
     
113.                 }
     
114.                 max = new Integer(str);
     
115.                 return max;
     
116.         }
     
117. }
     

复制代码

排序方法好久没写了，就自己写了下升序和降序的方法。