第4关：循环结构：黑洞陷阱

编程要求

在右侧编辑器中的Begin-End之间补充代码，获取输入的一个小于1000且三个数字不全相等的整数（数据由平台提供，你需获取后使用），并输出进入黑洞的重排求差过程。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：123
预期输出：
1:321-123=198
2:981-189=792
3:972-279=693
4:963-369=594
5:954-459=495

测试输入：18
预期输出：
1:810-18=792
2:972-279=693
3:963-369=594
4:954-459=495

// 包含两种I/O库，可以使用任一种输入输出方式
#include <stdio.h>
#include <iostream>

using namespace std;

/**
 * 获取一个数字的每位数的数组，不足三位补 0
 * @param num
 */
int *getDigits(int num) {
    int *digits = new int[3];
    if (num < 10) {
        digits[0] = num;
        digits[1] = digits[2] = 0;
    } else if (num < 100) {
        digits[0] = num / 10;
        digits[1] = num % 10;
        digits[2] = 0;
    } else if (num < 1000) {
        digits[0] = num / 100;
        digits[1] = (num / 10) % 10;
        digits[2] = num % 10;
    }
    return digits;
}

/**
 * 获取最大值
 * @param nums
 * @return
 */
int getMax(const int nums[3]) {
    int max = 0;
    for (int i = 0; i < 3; ++i) {
        max = max > nums[i] ? max : nums[i];
    }
    return max;
}

/**
 * 获取最小值
 * @param nums
 * @return
 */
int getMin(const int nums[3]) {
    int min = 10;
    for (int i = 0; i < 3; ++i) {
        min = min < nums[i] ? min : nums[i];
    }
    return min;
}

/**
 * 一个数重组后的最大值
 * @param num
 * @return
 */
int getMaxNum(int num) {
    int *digits = getDigits(num);
    int max = getMax(digits);
    int min = getMin(digits);
    int mid = digits[0] + digits[1] + digits[2] - max - min;
    return max * 100 + mid * 10 + min;
}

/**
 * 一个数重组后的最小值
 * @param num
 * @return
 */
int getMinNum(int num) {
    int *digits = getDigits(num);
    int max = getMax(digits);
    int min = getMin(digits);
    int mid = digits[0] + digits[1] + digits[2] - max - min;
    return max + mid * 10 + min * 100;
}

int main() {
    int n;
    // 请在此添加代码，输出整数进入黑洞过程
    /********** Begin *********/
    int max, min, index = 0;
    cin >> n;
    while (n != 495) {
        index++;
        max = getMaxNum(n);
        min = getMinNum(n);
        n = max - min;
        cout << index << ":" << max << "-" << min << "=" << n << endl;
    }
    /********** End **********/
    return 0;
}

123
1:321-123=198
2:981-189=792
3:972-279=693
4:963-369=594
5:954-459=495