2016蓝桥杯假期任务之《黑洞数》



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

请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。

循环圈的输出格式仿照：
[82962, 75933, 63954, 61974]

其中数字的先后顺序可以不考虑。

代码：

import java.util.ArrayList;  
import java.util.Arrays;   
import java.util.Iterator;  
import java.util.LinkedHashSet;  
import java.util.List;  
import java.util.Set;  
  
public class Main {  
    static Set<List<Integer>> sets = new LinkedHashSet<List<Integer>>();
    static int start = 0;   
    public static int max(String s){  
        char[] c = s.toCharArray();  
        Arrays.sort(c);  
        StringBuffer sb = new StringBuffer(new String(c));  
        return Integer.parseInt(sb.reverse().toString());  
    }   
    public static int min(String s){  
        char[] c = s.toCharArray();  
        Arrays.sort(c);  
        return Integer.parseInt(new String(c));  
    }   
    public static String fillZero(String s){  
        if(s.length()<5) return s;   
        StringBuffer sb = new StringBuffer(s);  
        int len = 5 - sb.length(); 
        for(int i=0;i<len;i++){  
            sb.insert(0, "0");  
        }  
        return sb.toString();  
    }   
    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;  
    }  
    public static boolean same(int n){  
        char[] c = (""+n).toCharArray();  
        char t = c[0];  
        for(int i=1;i<c.length;i++){  
            if(t!=c[i]){  
                return false;  
            }  
        }  
        return true;  
    }   
    public static boolean contain(List<Integer> tt){  
        boolean flag = false;   
        Iterator<List<Integer>> iter = sets.iterator();  
        while(iter.hasNext()){  
            if(iter.next().containsAll(tt)){  
                flag = true;  
            }  
        }  
        return flag;  
    }  
 
    public static void bl(int n,List<Integer> lis){  
        String tt = fillZero(String.valueOf(n));  
        int a = max(tt);    
        int b = min(tt);   
        int c = a - b;        
        if(find(c,lis)){    
            lis.add(c);      
            List<Integer> temp = new ArrayList();  
            temp.addAll(lis.subList(start, lis.size()-1));  
            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)) 
                bl(i,lis);  
        }  
        Iterator<List<Integer>> iter = sets.iterator();  
        while(iter.hasNext()){  
            System.out.println(iter.next());  
        }   
    }  
}  

运行结果：

[0]
[74943, 62964, 71973, 83952]
[63954, 61974, 82962, 75933]
[53955, 59994]

代码不是自己写的，，，，只是理解了解题思路，但是对于迭代器什么的知识点还是不太了解。