數字黑洞495,6174,...

1955年，卡普耶卡(D.R.Kaprekar)研究了對四位數的一種變換：任給出四位數k0,用它的四個數字由大到小重新排列成一個四位數m,再減去它的反序數rev(m),得出數k1=m-rev(m),然後，繼續對k1重複上述變換，得數k2.如此進行下去，卡普耶卡發現，無論k0是多大的四位數，只要四個數字不全相同，最多進行7次上述變換，就會出現四位數6174。因此這項研究在國際數學界又被稱爲“馬丁猜想—6174問題”。

有趣的數字6174

• 隨機生成四個不完全一樣的數字(0000,1111,2222,等排除);
• 四個數字組成一個最大的數 和 一個最小的數,如2,5,7,3組成的最大的數7532,最小的數2357;
• 最大的數 - 最小的數，如果不等於6174，就按照上一步將差值重新組成一個最大的數 和 一個最小的數;
• 最後一定有一次能得到差值爲6174.俗稱數字黑洞.

JAVA實現

public class Test6174 {
    public static void main(String[] args) throws InterruptedException {
        // 無線循環測試
        while (true) {
            // 隨機生成四個數字，考慮到出現四個一樣的概率非常低 沒有處理
            List<Integer> meta = new ArrayList<>();
            for (int i = 0; i < 4; i++) {
                meta.add(new Random().nextInt(10));
            }
            System.out.print("原始數字:" + meta);
            int result = 0, count = 0;
            while (result != 6174) {
                // 獲取四個數字組合的最大的數 和 最小的數
                int max = getMax(meta);
                int min = getMin(meta);
                result = Math.abs(max - min);
                count++;
                // 數字爲啥是6174？
                if (result == 6174) {
                    System.out.println(",次數:" + count);
                }
                meta = getMeta(result);
            }
            Thread.sleep(1000);
        }
    }

    public static int getMax(List<Integer> meta) {
        List<Integer> tmp = meta.stream().sorted().collect(Collectors.toList());
        return tmp.get(0) * 1000 + tmp.get(1) * 100 + tmp.get(2) * 10 + tmp.get(3);
    }

    public static int getMin(List<Integer> meta) {
        List<Integer> tmp = meta.stream().sorted().collect(Collectors.toList());
        return tmp.get(0) + tmp.get(1) * 10 + tmp.get(2) * 100 + tmp.get(3) * 1000;
    }

    public static List<Integer> getMeta(int num) {
        List<Integer> tmp = new ArrayList<>();
        tmp.add(num / 1000 % 10);
        tmp.add(num / 100 % 10);
        tmp.add(num / 10 % 10);
        tmp.add(num % 10);
        return tmp;
    }
}

同樣的黑洞數字還有很多哦

不如寫個程序來找出不同位數的黑洞數字吧

public class TestN {
    public static void main(String[] args) throws InterruptedException {
        // 輸入幾位數就是找幾位數的黑洞數字
        int digits = 5;
        List<Integer> meta = new ArrayList<>();
        for (int i = 0; i < digits; i++) {
            meta.add(new Random().nextInt(10));
        }
        if (getMax(meta) - getMin(meta) == 0){
            System.out.println("數字完全一樣,不符合要求");
            System.exit(0);
        }
        System.out.println("原始數字:" + meta);
        int result = 0;
        while (true) {
            int max = getMax(meta);
            int min = getMin(meta);
            result = Math.abs(max - min);
            meta = getMeta(result, digits);
            System.out.println(result);
        }
    }

    // 獲取數字組合的最大數
    public static int getMax(List<Integer> meta) {
        List<Integer> tmp = meta.stream().sorted().collect(Collectors.toList());
        double result = 0;
        for (int i = 0; i < tmp.size(); i++) {
            result = result + tmp.get(i) * (Math.pow(10.0, (double) (i)));
        }
        return (int) result;
    }

    // 獲取數字組合的最小數
    public static int getMin(List<Integer> meta) {
        List<Integer> tmp = meta.stream().sorted().collect(Collectors.toList());
        double result = 0;
        for (int i = 0; i < tmp.size(); i++) {
            result = result + tmp.get(i) * (Math.pow(10.0, (double) (tmp.size() - i - 1)));
        }
        return (int) result;
    }

    // 獲取數的各位數
    public static List<Integer> getMeta(int num, int c) {
        List<Integer> tmp = new ArrayList<>();
        for (int i = 0; i < c; i++) {
            tmp.add(num / ((int) Math.pow(10.0, i)) % 10);
        }
        return tmp;
    }
}

如上程序測試運行：

digits(位數)	黑洞數(個)	結果
1	-	-
2	5	9,81,63,27,45
3	1	495
4	1	6174
5	4	71973,83952,74943,62964
6	7	840852,860832,862632,642654,...
7	8	9529641,8719722,8649432,7519743,...
8	3	64308654,83208762,86526432
9	14	954197541,883098612,976494321,...