有趣的数字 6174

在网上看到一个有趣的算法：把一个四位数的四个数字由小至大排序，组成一个新数， 又由大至小排序组成一个新数，这两个数相减， 之后重复这个步骤， 只要四位数的四个数字不完全相同（如9999），数字最终便会变成 6174。

最终显示要转换成6174迭代最多为7次

java实现代码 

/**
 * 把一个四位数的四个数字由小至大排序，组成一个新数，
 * 又由大至小排序组成一个新数，
 * 这两个数相减， 之后重复这个步骤， 
 * 只要四位数的四个数字不完全相同（如9999），
 * 数字最终便会变成 6174。
 * 
 * @author Administrator
 * 
 */
public class Demo {
	// 存放4个1位整数
	private static List<Integer> list = new ArrayList<Integer>(4);
	// 每个4位整数转换成6174所需的迭代次数
	private static int count = 0;

	public static void main(String[] args) throws Exception {
		// 把所有可用整数写进文件
		writeAll();
		// 从文件中取出整数
		Set<Integer> set = readFromFile();
		// 打印一下可用整数的个数
		System.out.println(set.size());
		// 统计迭代次数
		Set<Integer> countSet = new HashSet<Integer>();
		// 循环转换各个4位整数
		for (Integer number : set) {
			turnTo6174(number);
			countSet.add(count);
			count = 0;
		}
		// 打印统计的迭代次数
		System.out.println(countSet);
	}

	/**
	 * 把4位整数分割成4个整数，放入list中
	 * 
	 * @param number
	 * @return
	 */
	private static List<Integer> split(int number) {
		list.clear();
		String str = number + "";
		// 4位数反转相减最小为999, 为999时要补一位0以满足4位整数的要求
		if (str.length() == 3) {
			str += "0";
		}
		for (int i = 0; i < 4; i++) {
			int num = str.charAt(i) - 48;
			list.add(num);
		}
		return list;
	}

	/**
	 * 把list中的每个整数组合成一个整数
	 * 
	 * @param list
	 * @return
	 */
	private static int compose(List<Integer> list) {
		StringBuilder sb = new StringBuilder(4);
		for (Integer integer : list) {
			sb.append(integer);
		}
		return Integer.parseInt(sb.toString());
	}

	/**
	 * 升序排序
	 * 
	 * @param list
	 */
	private static void sortToASC(List<Integer> list) {
		Collections.sort(list);
	}

	/**
	 * 降序排序
	 * 
	 * @param list
	 */
	private static void sortToDESC(List<Integer> list) {
		Collections.sort(list, new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return -(o1 - o2);
			}
		});
	}

	/**
	 * 1 升序排序， 2 降序排序， 3 相减取绝对值， 4 如果不是6174则继续迭代，如果是则结束迭代
	 * 
	 * @param number
	 * @return
	 */
	private static int turnTo6174(int number) {
		count++;
		sortToASC(split(number));
		int numberASC = compose(list);
		sortToDESC(list);
		int numberDESC = compose(list);
		int exspect = Math.abs(numberASC - numberDESC);
		if (exspect == 6174) {
			return 6174;
		}
		list.clear();
		return turnTo6174(exspect);
	}

	/**
	 * 从文件中解析数字
	 * 
	 * @return
	 * @throws Exception
	 */
	private static Set<Integer> readFromFile() throws Exception {
		Set<Integer> set = new HashSet<Integer>();
		BufferedReader br = new BufferedReader(new FileReader("D:/test.txt"));
		String line = "";
		while ((line = br.readLine()) != null) {
			String[] datas = line.split(" ");
			for (String string : datas) {
				set.add(Integer.parseInt(string));
			}
		}
		return set;
	}

	/**
	 * 把所有4位整数写到文件中
	 * 
	 * @throws Exception
	 */
	private static void writeAll() throws Exception {
		BufferedWriter bw = new BufferedWriter(new FileWriter("D:/test.txt",
				true));
		for (int i = 1000; i < 10000; i++) {
			split(i);
			Set<Integer> set = new HashSet<Integer>(list);
			// 4位整数各个位置不能全部相同
			if (set.size() == 1) {
				continue;
			}
			bw.write(i + " ");
			if ((i + 1) % 10 == 0) {
				bw.write("\n");
			}
		}
		bw.flush();
		bw.close();
	}
}