程序查错

Question

貌似我输出的结果太多了,怀疑自己写错了,请各位帮忙看下题目:
任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：65432，一个最小的数23456。求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。
比如，刚才的数字会落入：[82962, 75933, 63954, 61974] 这个循环圈。请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：
[82962, 75933, 63954, 61974]
其中数字的先后顺序可以不考虑。
我写的
import java.util.Arrays;
import java.util.ArrayList;
public class test4{
static ArrayList<Integer> al=new ArrayList<Integer>();
static int num=10000;
public static void main(String[] args){
for(;num<100000;num++){
check(num);
}
}
public static void check(int n){
String tempstr=String.valueOf(n);
int[] tempint=new int[tempstr.length()];
for(int i=0;i<tempstr.length();i++){
tempint[i]=Integer.parseInt(tempstr.substring(i,i+1));
}
Arrays.sort(tempint);
StringBuffer sb=new StringBuffer();
for(int i=0;i<tempint.length;i++){
sb.append(tempint[i]);
}
int min=Integer.parseInt(sb.toString());
int max=Integer.parseInt(sb.reverse().toString());
int result=max-min;
if(result==0){
System.out.println("~0");
}else{
while(result<10000){
result*=10;
}

if(al.indexOf(result)==-1){
al.add(result);
check(result);
}else{
al.add(result);
al.remove(0);
al.remove(1);
//System.out.print(num+"  ");
System.out.print(al);
System.out.println();
al.clear();
}
}
}
}

Answer 1

楼主,我想说两点：
1、先不说程序对错，单看你的类的命名就觉得别扭，还是改大写字母开头吧（Test4）
2、al.add(result);al.remove(0);al.remove(1);这3句还是去掉吧，既然al里面存在这样的记录，那就不应该再加进去了，至于为什么要使用两句remove()就不清楚了，感觉好怪。个人觉得应该去掉

Answer 2

程序上倒是没什么大问题，就是效率太低。其实像这样的处理挺有规律的，没必要递归，而且每个数很有可能经过处理后会出现陷入相同的黑洞，这样，一旦遇到黑洞就可以停止了。给LZ一段sampe代码import java.util.Arrays;
import java.util.ArrayList;
import java.io.PrintWriter;
import java.io.FileOutputStream;
public class Test04{
    static ArrayList<String> als=new ArrayList<String>();
    static ArrayList<ArrayList<String>> rls = new ArrayList<ArrayList<String>>();
    public static void main(String[] args){
        find(5);
        try { //把结果保存到文件
            PrintWriter pw = new PrintWriter(new FileOutputStream("check.txt"));
            for (ArrayList<String> l : rls) {
                pw.println(l);
            }
            pw.close();
        } catch (Exception e) {e.printStackTrace();}
    }    public static void find(int n) {
        int[] dig = new int[n]; //这里直接用个数组来保存5位数，省得用String转来转去
        Arrays.fill(dig, 0);
        int[] tmp;
        int num, min, max, result;
        String s;        while (true) { //其实用个while循环就可以达到递归的效果了
            dig[n-1]++;
            for (int i=n-1; i>0; i--) {
                if (dig[i] == 10) {
                    dig[i] = 0;
                    dig[i-1]++;
                } else {
                    break;
                }
            }
            if (dig[0] == 10) {break;}
            num = 0;
            for (int i : dig) {
               num = (num*10 + i);
            }
            result = num;
            als = new ArrayList<String>();
            s = String.format("%05d", result);
            while (!als.contains(s)) {
                als.add(s);
                tmp = new int[n];
                for (int i=n-1; i>=0; i--) {
                    tmp[i] = result%10;
                    result /= 10;
                }
                Arrays.sort(tmp);
                min = 0;
                for (int i : tmp) {
                    min = (min*10 + i);
                }
                max = 0;
                for (int i=n-1; i>=0; i--) {
                    max = (max*10 + tmp[i]);
                }                result = max - min;
                if (result == 0) {
                    System.out.println(num+"~0");
                    break;
                }
                while (result < (int)Math.pow(10, n-1)) {
                    result *= 10;
                }
                s = String.format("%05d", result);
            }
            if (result != 0) {
                rls.add(als);
            }
        }
    }
}

Answer 3

这是国信蓝点杯的题目吧
呵呵 之前有做过
发上代码：package GXLDBZK;import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;/**
 * 任意一个5位数，比如：34256，把它的各位数字打乱，重新排列，可以得到一个最大的数：65432，一个最小的数23456。
 * 求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个 循环圈（称为数字黑洞）。
 * 比如，刚才的数字会落入：[82962,75933, 63954, 61974] 这个循环圈。
 * 
 * 请编写程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不 考虑。循环圈的输出格式仿照：
 * [82962, 75933, 63954, 61974] 其中数字的先后顺序可以不考虑
 * 
 * @author xqh
 * 
 */
public class Test10 { public static void main(String[] args) {
Set<Set<Integer>> blackHole = new HashSet<Set<Integer>>();
for (int i = 10000; i < 100000; i++) {
if (i % 11111 != 0) {
Set<Integer> set = getBlackHole(i);
blackHole.add(set);
}
}
Iterator<Set<Integer>> it = blackHole.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
} /**
 * 数字黑洞
 * 
 * @param num
 *            五位数
 * @return blackHole 循环圈
 */
private static Set<Integer> getBlackHole(int num) {
Set<Integer> deviation = new HashSet<Integer>();//参照
Set<Integer> blackHole = new HashSet<Integer>();//存放循环圈
int div = 0;
while (true) {
div = parseSort(parseList(num));
if (deviation.contains(div)) {
if (blackHole.contains(div))
break;
else
blackHole.add(div);
} else
deviation.add(div);
num = div;
}
return blackHole;
} /**
 * 拆分五位数，将各个位上的数存放到list集合中
 * 
 * @param num
 *            五位数
 * @return list 数列
 */
private static List<Integer> parseList(int num) {
List<Integer> list = new ArrayList<Integer>();
int index = 0;
while (index < 5) {
list.add(num % 10);
num /= 10;
index++;
}
return list; // 返回数列list
} /**
 * 对list数列中的元素进行扰乱，排序，得到最大值与最小值并返回二者之差
 * 
 * @param list
 * @return c 最大值与最小值之差
 */
private static int parseSort(List<Integer> list) {
Collections.shuffle(list);// 对list数列中的元素进行扰乱
Collections.sort(list);// 按自然顺序进行排序
String min = "";
for (int i : list)
min += i;
int Min = Integer.parseInt(min);// 获取最小值
StringBuffer sb = new StringBuffer(min).reverse();
String max = sb.toString();
int Max = Integer.parseInt(max);// 获取最大值
int c = Max - Min;
return c; // 返回最大值与最小值并返回二者之差
}}