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

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


谁来解答！思路要清晰！！

小伙伴们！加油吧！

加油，纯支持:victory:

好复杂的算法

想了10分钟，果断放弃。。。暂时还得充充电

学习了！

高手哪里去了！！:sleepy:

我只想到要用到sort排序，StringBuilder容器、反转，循环。。。。

留下，以后看

连题目求的是什么都不知道？？？

难道这个题就没同学能写出来吗？

不是没人能解，估计都不想敲，太长了，亲。。。。。。。。。。。
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class 数字黑洞 {
    static Set<List<Integer>> sets = new HashSet<List<Integer>>();// 记录每个 循环圈  
    static int start = 0; // 记录循环圈的开始位置  

    // 得到最大的数  
    public static int max(String s) {
        char[] c = s.toCharArray();
        Arrays.sort(c);
        StringBuffer sb = new StringBuffer(String.valueOf(c));
        return Integer.parseInt(sb.reverse().toString());
    }

    // 得到最小的数  
    public static int min(String s) {
        char[] c = s.toCharArray();
        Arrays.sort(c);
        return Integer.parseInt(String.valueOf(c));
    }

    // 查找是否有循环圈  
    public static boolean find(int n, List<Integer> lis) {
        for (int i = 0; i < lis.size(); i++) {
            if (n == lis.get(i)) {
                start = i; // 设置循环圈的开始  
                return true;
            }
        }
        return false;
    }

    // 这个数字的五位是否都一样如:11111,22222,...  
    public static boolean same(int n) {
        char[] c = (String.valueOf(n)).toCharArray();
        char t = c[0];
        for (int i = 1; i < c.length; i++) {
            if (t != c) {
                return false;
            }
        }
        return true;
    }

    // 判断是否在sets元素里重复  
    public static boolean contain(List<Integer> tt) {
        boolean flag = false;
        // 从sets头到尾扫描是是否包含tt元素组  
        Iterator<List<Integer>> iter = sets.iterator();
        while (iter.hasNext()) {
            if (iter.next().containsAll(tt)) {
                flag = true;
                break;
            }
        }
        return flag;
    }

    // 输出循环圈  
    public static void print() {
        Iterator<List<Integer>> iter = sets.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }
    }

    // 进入黑洞测试*********  
    public static void bl(int n, List<Integer> lis) {
        String s = String.valueOf(n);
        int a = max(s); // 得到最大的数  
        int b = min(s); // 得到最小的数  
        int c = a - b; // 得到五位数 结果  
        if (find(c, lis)) { // 找到循环圈  
            List<Integer> temp = new ArrayList(); // 开辟新空间 并copy记录  
            temp.addAll(lis.subList(start, lis.size()));
            if (!contain(temp)) { // 去重  
                sets.add(temp); // 记录一个循环圈  
            }
            lis.clear(); // 清空  
            return;
        }
        lis.add(c);
        bl(c, lis); // 递归探测  
    }

    // 主函数============  
    public static void main(String[] args) {
        List<Integer> lis = new ArrayList(); // 保存记录  
        for (int i = 10000; i < 99999; i++) {
            if (!same(i)) // 去掉不符合条件的元素:如(11111,22222,...)  
                bl(i, lis); // 进入黑洞测试  
        }
        print(); // 输出循环圈  
    }
}

这个问题怎么没有正解呢！
围观中！

12楼的果然好长，看晕了。。。

我表示连题目都没有看懂，

新手，尝试了写了一下，望大神指正

1. /*
   
2. 1、获取任意五位数上各个位的数字并且放到数组中
   
3. 2、通过对数组排升序获取最小值
   
4. 3、通过对数组排降序获取最大值
   
5. 4、通过最大值和最小值获取差值
   
6. 5、通过差值循环，判断当前差值是否与这前的某个差值相等
   
7.       1）新建一个容器用来存放差值 目前只学过数组，用new in
   
8.       2）用循环判断当判断当前差值是否与这前的某个差值相等
   
9.            a、如果相等，打印这当前差值、与当前差值相等的差值以及它们之间的差值，
   
10.                  这也就是循环圈，然后跳出循环
    
11.            b、如果不等，继续循环
    
12. */
    
13. class  Quan
    
14. {
    
15.         public static void main(String[] args)
    
16.         {
    
17.                 int x=34556;
    
18.                 getCirculation(x);
    
19.         }
    
20.         public static void getCirculation(int x)
    
21.         {
    
22.                 int[] res=new int[100];   //  目前只学过数组，用这个可能不太好，不知道有没有更恰当的
    
23.                 boolean check=true;
    
24.                 int difference=getDifference(x);
    
25.                 for(int j=0;j<res.length-1&&check==true;difference=getDifference(difference),j++)
    
26.                 {
    
27.                         res[j]=difference;
    
28.                         for(int k=j-1;k>=0&&check==true;k--)
    
29.                         {
    
30.                                 if(res[k]==difference)
    
31.                                 {
    
32.                                         System.out.print("[");
    
33.                                         for(int a=k;a<j-1;a++)
    
34.                                         {
    
35.                                                 System.out.print(res[a]+",");
    
36.                                         }
    
37.                                         System.out.print(res[j-1]+"]");
    
38.                                         check=false;
    
39.                                 }
    
40.                         }
    
41.                 }
    
42.         }
    
43.         public static int getDifference(int x)    //获取差值
    
44.         {
    
45.                 int[] arr=getArr(x);
    
46.                 maxSort(arr);
    
47.                 int max=getNumber(arr);
    
48.                 minSort(arr);
    
49.                 int min=getNumber(arr);
    
50.                 return (max-min);        
    
51.         }
    
52.         public static int[] getArr(int x)   //获取五位数的数组
    
53.         {
    
54.                 int[] arr=new int[5];
    
55.                 for (int i=10000,j=0;i>=1;i=i/10,j++)
    
56.                 {
    
57.                         arr[j]=x/i;
    
58.                         x=x%i;
    
59.                 }
    
60.                 return arr;
    
61.         }
    
62.         public static void maxSort(int[] arr)   //升序排列数组
    
63.         {
    
64.                 for(int i=0;i<arr.length-1;i++)
    
65.                 {
    
66.                         for(int j=i+1;j<arr.length;j++)
    
67.                         {
    
68.                                 if(arr[i]<arr[j])
    
69.                                 {
    
70.                                         int temp=arr[i];
    
71.                                         arr[i]=arr[j];
    
72.                                         arr[j]=temp;
    
73.                                 }
    
74.                         }
    
75.                 }
    
76.         }
    
77.         public static void minSort(int[] arr)   //降序排列数组
    
78.         {
    
79.                 for(int i=0;i<arr.length-1;i++)
    
80.                 {
    
81.                         for(int j=i+1;j<arr.length;j++)
    
82.                         {
    
83.                                 if(arr[i]>arr[j])
    
84.                                 {
    
85.                                         int temp=arr[i];
    
86.                                         arr[i]=arr[j];
    
87.                                         arr[j]=temp;
    
88.                                 }
    
89.                         }
    
90.                 }
    
91.         }
    
92.         public static int getNumber(int[] arr)    //数组转成数字
    
93.         {
    
94.                 int num=0;
    
95.                 for(int i=0,temp=10000; i<arr.length;i++,temp=temp/10)
    
96.                 {
    
97.                         num=num+arr[i]*temp;
    
98.                 }
    
99.                 return num;
    
100.         }
     
101. }
     

复制代码

1. 
   
2. import java.io.PrintStream;
   
3. import java.lang.reflect.Array;
   
4. import java.util.*;
   
5. 
   
6. /**
   
7. *
   
8. 有任意一个5位数，如：34256，
   
9. 把它的各位数字打乱，重新排列，就可得到一个最大的数：65432，还有一个最小的数23456。
   
10. 求这两个数字的差，得：41976，
    
11. 然后把这个数字再次重复上述过程（如果不足5位，则前边补0）。
    
12. 如此往复，数字会落入某个循环圈（称为数字黑洞）。
    
13. 比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。
    
14. * @author JunZhu
    
15. */
    
16. public class NumberBlackHole {
    
17.         public static void main(String[] args) throws Exception{
    
18.                 //定义一个set用于存放所有可能的循环组合
    
19.                 HashSet<HashSet> al=new HashSet<HashSet>();
    
20.                 //把结果存入一个文件中
    
21.                 PrintStream ps=new PrintStream("BlackHole.txt");
    
22.                 //定义一个set用于存放某一个循环圈
    
23.                 HashSet<Integer> al2=new HashSet<Integer>();
    
24.                 //定义一个标志位用于判断循环的结束
    
25.                 boolean flag=false;
    
26.                 for (int i = 10000;i<100000; i++) {
    
27.                         for (int j = i; ; ) {
    
28.                                 al2.add(j);
    
29.                                 j =getMaxNum(j)-getMinNum(j);
    
30.                                 if (al2.contains(j)&& flag==false) {
    
31.                                         flag=true;
    
32.                                         al2.clear();
    
33.                                 }
    
34.                                 if (al2.contains(j)) {
    
35.                                         flag=false;
    
36.                                         break;
    
37.                                 }
    
38.                         }
    
39.                         al.add((HashSet) al2.clone());
    
40.                         //System.out.println(al2);
    
41.                         //ps.println(al2);
    
42.                         al2.clear();
    
43.                 }
    
44.                 Iterator it=al.iterator();
    
45.                 while (it.hasNext()) {
    
46.                         ps.println(it.next());
    
47.                 }
    
48.                 ps.close();
    
49.         }
    
50.         public static int getMaxNum(int a) {
    
51.                 int[] num=getNum(a);
    
52.                 int k=0;
    
53.                 Arrays.sort(num);
    
54.                 for (int i = num.length-1; i >= 0; i--) {
    
55.                         k=k*10+num[i];
    
56.                 }               
    
57.                 return k;
    
58.         }
    
59.         public static int getMinNum(int a) {
    
60.                 int[] num=getNum(a);
    
61.                 int k=0;
    
62.                 Arrays.sort(num);
    
63.                 for (int i = 0; i < num.length; i++) {
    
64.                         k=k*10+num[i];
    
65.                 }
    
66.                 return k;
    
67.         }
    
68.         public static int[] getNum(int a) {
    
69.                 String ss=Integer.toString(a);
    
70.                 //判断，不足5位的话补零
    
71.                 int[] s=new int[5];
    
72.                 for (int i = 0; i < ss.length(); i++) {
    
73.                         s[i]=a%10;
    
74.                         a=a/10;
    
75.                 }
    
76.                 if (ss.length()<5) {
    
77.                         for (int i = ss.length(); i < 5; i++) {
    
78.                                 s[i]=0;                                                               
    
79.                         }
    
80.                 }
    
81.                 return s;
    
82.         }
    
83. }
    

复制代码

最后结果是输出到了BlackHole.txt文件中，有一个零，是例外的。一共三组。
[0]
[71973, 83952, 74943, 62964]
[53955, 59994]
[63954, 61974, 82962, 75933]

其实我就不懂为什么61974之后不继续求循环圈了

数字黑洞，面试不会出这样的题吧{:3_55:}

进来看看，