一、4位数的数字黑洞

       任意给定一个4位数(不能所有位都相同)，比如：3278，重新组合出最大数：8732，再重新组合出最小数：2378，相减，得到新的4位数（如不足则补0），重复这个过程，最后必然得到一个数字：6174。这个现象被称为：数字黑洞。

       编写一个程序，验证这个现象。

例如，给出四位数3278，则有验证过程如下：

8732-2378=6354

6543-3456=3087

8730-378=8352

8532-2358=6174

再如，给出四位数1011，则有验证过程如下：

1110-111=999  （不足4位，补0）

9990-999=8991 

9981-1899=8082

8820-288=8532

8532-2358=6174

        （1）编程思路。

编写函数void parse(int n,int *max,int *min)，该函数的功能求出由整数n的四位数字组合成的最大数和最小数，分别通过形参max和min返回。

在函数中，定义一个数组int a[4]，用于保存整数n的4位数字，然后将数组a按从小到大的顺序排列，之后各数字顺序组成最小数，逆序组成最大数。

（2）源程序。

#include <stdio.h>
void parse(int n,int *max,int *min)
{
    int a[4],i,j,t;
    for (i=0; i<4; i++)
    {
        a[3-i] = n%10;
        n/=10;
    }
    for (i=0; i<3; i++)    // 将四个数字按从小到大顺序排列
        for (j=0; j<3-i; j++)
            if (a[j]>a[j+1])
            {
                t = a[j+1];
                a[j+1] = a[j];
                a[j] = t;
            }
    t=0;
    for (i=0; i<4; i++)
        t = t * 10 + a[i] ;
    *min=t;
    t = 0;
    for (i=3; i>=0; i--)
        t= t * 10 + a[i];
    *max=t;
}
int main()
{
    int n,max,min;
    scanf("%d",&n);
    do
    {
       parse(n,&max,&min);
       printf("%d-%d=%d\n",max,min,max-min);
       n=max-min;
    }while (n!=6174);
    return 0;
}

        二、5位数的数字黑洞

        任意一个5位数，比如：12345，把它的各位数字打乱，重新排列，可以得到一个最大的数：54321，一个最小的数12345。求这两个数字的差，得：41976，把这个数字再次重复上述过程（如果不足5位，则前边补0）。如此往复，数字会落入某个循环圈（称为数字黑洞）。

例如，刚才的数12345会落入：[82962, 75933, 63954, 61974] 这个循环圈。计算过程如下：

54321 - 12345 = 41976

97641 - 14679 = 82962

98622 - 22689 = 75933

97533 - 33579 = 63954

96543 - 34569 = 61974

97641 - 14679 = 82962

[82962,75933,63954,61974] 

再如，整数11211会落入：[74943,62964,71973,83952]这个循环圈。计算过程如下：

21111 - 11112 = 9999   （不足5位，则前边补0）

99990 - 9999 = 89991

99981 - 18999 = 80982

98820 - 2889 = 95931

99531 - 13599 = 85932

98532 - 23589 = 74943

97443 - 34479 = 62964

96642 - 24669 = 71973

97731 - 13779 = 83952

98532 - 23589 = 74943

[74943,62964,71973,83952]

还如，整数50000会落入：[53955,59994]这个循环圈。计算过程如下：

50000 - 5 = 49995

99954 - 45999 = 53955

95553 - 35559 = 59994

99954 - 45999 = 53955

[53955,59994]

         编写一个程序，找到5位数所有可能的循环圈，并输出，每个循环圈占1行。其中5位数全都相同则循环圈为 [0]，这个可以不考虑。循环圈的输出格式仿照：

[82962, 75933, 63954, 61974]   其中数字的先后顺序可以不考虑。

         （1）编程思路。

 如同上面4位数的数字黑洞，编写函数int next(int n) ，其功能是求5位整数n的各位数字所组成的最大数与最小数的差值，并将求得的差值作为函数值返回。

为了找出一个整数n的循环圈，编写一个函数void heidong(int n)，寻找整数n的循环圈。在函数中，定义一个数组int a[20]用于保存计算过程中的每一个差值。

初始时，置a[0]=n，之后用next()函数求得n的各位数字组成的最大数与最小数的差值，保存到a[1]中，即a[1]=next(a[0])，再求 a[2]=next(a[1])，…，a[i]=next(a[i-1])。

每次求得了a[i]后，将a[i]与a[0]~a[i-1]中保存的各数依次比较，若每个a[j]==a[i]（0≤j≤i-1），则找到了循环圈 a[j]~a[i-1]。输出这个循环圈。并将这个循环圈中的各个数保存到全局数组b中。

       之所以要将循环圈中的数保存到全局数组中，是因为很多5位数会落在同一个循环圈中。例如，整数10000会落在[74943,62964,71973,83952]循环圈中，11112、11121、11211、…这些数同样落在这个循环圈中。这样当计算10000找到了循环圈后，将74943、62964、71973、83952这4个数保存在全局数组b中，当以后计算到11112时，找到了循环圈，由于循环圈中的数74943已在全局数组b中存在，因此这个循环圈是重复的，无需输出。这样，可以用循环

        for(i=10000;i<99999;i++)
        {
                 if (next(i)==0) continue; // 各位数字全部相同，忽略
                 heidong(i);
        }

找出所有5位数可能的循环圈。

（2）源程序。

#include<stdio.h>
int b[12]={0}, cnt=0; // 保存各循环圈中的数避免重复，cnt为黑洞中数的个数
int next(int n)       // 整数n各位数字组成的最大数与最小数的差
{
    int a[5],i,j;
    for (i=0;i<5;i++)
    {
        a[i]=n%10;
        n/=10;
    }
    for (i=0;i<4;i++)
        for (j=0;j<4-i;j++)
           if (a[j]>a[j+1])
           {
              int t;
              t=a[j]; a[j]=a[j+1]; a[j+1]=t;
           }
    int max=0,min=0;
    for (i=0;i<5;i++)
    {
        min=min*10+a[i];
        max=max*10+a[4-i];
    }
    return max-min;
}
void heidong(int n)
{
    int a[20],flag=0;
    a[0]=n;
    int i,j,k;
    for (i=1; ;i++)
    {
        a[i]=next(a[i-1]);
        for (j=0;j<i;j++)
        {
            if(a[i]==a[j])          // a[j]~a[i-1]之间的数构成循环圈
            {
                for (k=0;k<cnt;k++) // 看当前循环圈中的数是否保存过，本质是查重
                {
                    if(a[i]==b[k]) { flag=1; break;}
                }
                if (flag!=1)      // 输出循环圈中的各数，同时保存到全局数组b中
                {
                    printf("[%d",a[j]);
                    b[cnt++]=a[j];
                    for (k=j+1;k<i;k++)
                    {
                       printf(",%d",a[k]);
                       b[cnt++]=a[k];
                    }
                    printf("]\n");
                    flag=1;
                }
            }
        }
        if (flag==1) break;
    }
}
int main()
{
    int i;
    for(i=10000;i<99999;i++)
    {
       if (next(i)==0) continue;  // 各位数字全部相同，忽略
       heidong(i);
    }
    return 0;
}

        运行程序可知，所有5位数可能的循环圈有3个，如下。

[74943,62964,71973,83952]
[63954,61974,82962,75933]
[53955,59994]