PAT乙级 1019 数字黑洞 (20分)

给定任一个各位数字不完全相同的 4 位正整数，如果我们先把 4 个数字按非递增排序，再按非递减排序，然后用第 1 个数字减第 2 个数字，将得到一个新的数字。一直重复这样做，我们很快会停在有“数字黑洞”之称的 6174，这个神奇的数字也叫 Kaprekar 常数。

例如，我们从6767开始，将得到

7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174
7641 - 1467 = 6174
... ...

 

现给定任意 4 位正整数，请编写程序演示到达黑洞的过程。

输入格式：

输入给出一个 ( 区间内的正整数 N。

输出格式：

如果 N 的 4 位数字全相等，则在一行内输出 N - N = 0000；否则将计算的每一步在一行内输出，直到 6174 作为差出现，输出格式见样例。注意每个数字按 4 位数格式输出。

输入样例 1：

6767

 

输出样例 1：

7766 - 6677 = 1089
9810 - 0189 = 9621
9621 - 1269 = 8352
8532 - 2358 = 6174

 

输入样例 2：

2222

 

输出样例 2：

2222 - 2222 = 0000


一开始的代码如下：

#include <iostream>
using namespace std;
int main(){
    int num;
    int hash[10] = {0};
    cin >> num;
    while(1){    //此处条件不能写为 num != 6174，如果此时输入6174则无任何输出
        int num1 = 0;
        int num2 = 0;
        int NUM = num;
        int temp = 1000;
        while(NUM != 0){
            hash[NUM % 10]++;
            if(hash[NUM % 10] == 4){
                int k = (NUM % 10) * 1000 + (NUM % 10) * 100 + (NUM % 10) * 10 + (NUM % 10);
                printf("%04d - %04d = 0000\n",k, k);
                return 0;
            }
            NUM /= 10;
        }
        for(int i = 9; i > 0; i--){
            int cnt = hash[i];
            while(cnt){
                num1 += i * temp;
                temp /= 10;
                cnt--;
            }
        }
        temp = 1000;
        for(int i = 0; i < 10; i++){
            while(hash[i]){
                num2 += i * temp;
                temp /= 10;
                hash[i]--;
            }
        }
        printf("%04d - %04d = %04d\n", num1, num2, num1 - num2);
        num = num1 - num2;
        if(num == 6174) break;
    }
    return 0;
}

此代码的逻辑是先通过取余，相除的方式依次取出数字的每一位数字，而后存储进哈希表中，再通过哈希表升序降序遍历的方式对数字进行排序，

排序过程中通过num += 进行还原，但是这种方式存在一个问题，当我输入0023时，左边的数字应该为3200，而右边的数字应该为0023，但是由于

提取数据中数字的方式无法识别前面的0，比如0023%10 = 3   0023 / 10 = 002，    002 % 10 = 2   002 / 10 = 00，此时结束提取，因此提取数字的方式不应如此

我们考虑另一种提取方式，利用数组的方式，依次将数字存入数字A[4]中，如此既可对数组中的数字通过sort()来进行升序，降序排列。

 

#include <iostream>
#include <algorithm>
using namespace std;
bool down(int a,int b){//降序
    return a>=b;
}
int main(){
    int num;
    int hash[4] = {0};
    cin >> num;
    while(1){    //此处条件不能写为 num != 6174，如果此时输入6174则无任何输出
        int num1 = 0;
        int num2 = 0;
        int NUM = num;
        int temp = 1000;
        for(int i = 3; i >= 0; i--){
            hash[i] = NUM % 10;
            NUM /= 10;
        }
        if(hash[0] == hash[1] && hash[1] == hash[2] && hash[2] == hash[3]){
            printf("%04d - %04d = 0000\n",num, num);
            return 0;
        }
        sort(hash,hash+4,down);
        for(int i = 0; i < 4; i++){
            num1 += hash[i] * temp;
            temp /= 10;
        }
        temp = 1000;
        sort(hash,hash+4);
        for(int i = 0; i < 4; i++){
            num2 += hash[i] * temp;
            temp /= 10;
        }
        printf("%04d - %04d = %04d\n", num1, num2, num1 - num2);
        num = num1 - num2;
        if(num == 6174) break;
    }
    return 0;
}

 

 

此题有如下几个值得学习的点：

1.printf("%04d - %04d = 0000\n",num, num); 自动补足前面的0，且使得输出的数字控制在四位数

2.题目有升降序思想，应考虑引用#include<algorithm> 使用其中的sort()函数，且应注意，降序时需自己写一个函数

 

#include <algorithm> 
4 bool down(int a,int b){//降序
 5     return a>=b;
 6 }
sort(A,A+n,down);