6174数学黑洞，即卡普雷卡尔（Kaprekar）常数。
任选4个不完全相同的数字（像1111就不行），让“最大排列”减“最小排列”（例如8753-3578），不断重复这个动作，最后一定会得到相同的结果：6174。
4 i+ `/ k, d! e; Z4 v* s1 }神奇的是：这个“最大减最小”的动作，最多不会超过7次！

我们先来看看五组实验结果↓↓请输入一个互不相同的四位数：3758
输入的四位数是：3758
第1次：8753 - 3578 = 5175
第2次：7551 - 1557 = 5994
! {/ w( [5 r' V第3次：9954 - 4599 = 5355
第4次：5553 - 3555 = 1998
7 m6 q' }- C+ x$ G第5次：9981 - 1899 = 8082
. h2 ^: w$ q0 @% N. K' H第6次：8820 - 288 = 8532
8 \, R. x' V) {0 q& W. P8 {0 k) x$ Y第7次：8532 - 2358 = 6174
* l& Y, X: k8 s; b% x( x* ?经过了7次最大减最小的动作
: z1 O% a; @: O5 i- L5 m% m, Y请输入一个互不相同的四位数：2517
输入的四位数是：2517
第1次：7521 - 1257 = 6264
第2次：6642 - 2466 = 4176
' |/ z' F  c$ q4 c第3次：7641 - 1467 = 6174
: a2 V; P, m' N* n; R* b经过了3次最大减最小的动作
请输入一个互不相同的四位数：6915
输入的四位数是：6915
8 n" t8 t$ p+ k" M' g  s$ w/ K7 q# [第1次：9651 - 1569 = 8082
第2次：8820 - 288 = 8532
第3次：8532 - 2358 = 6174
经过了3次最大减最小的动作
) ?+ W' ~0 P% p1 b$ M7 h. ?请输入一个互不相同的四位数：9073
- U8 ]3 b, u/ X8 p7 _( ?) h. P/ P+ [输入的四位数是：9073
: b  L. k% C; ?: ~第1次：9730 - 379 = 9351
7 E( h% O1 P, l+ o  ~0 G- g第2次：9531 - 1359 = 8172
第3次：8721 - 1278 = 7443
第4次：7443 - 3447 = 3996
第5次：9963 - 3699 = 6264
第6次：6642 - 2466 = 4176
第7次：7641 - 1467 = 6174
经过了7次最大减最小的动作
请输入一个互不相同的四位数：5287
6 \" J6 }% J5 j, A6 `. f输入的四位数是：5287
% b4 ]! U+ I, r  l; g2 h' Y9 n& E第1次：8752 - 2578 = 6174
4 v% `% R9 H' J. }4 i6 O2 |经过了1次最大减最小的动作
( w" w1 D" H1 W+ i. i1 x

接下来，我们用C语言代码进行验证，代码实现如下。

代码实现#include <stdio.h>
% I& r# ~1 ^2 c- `- v
8 O3 P, D7 Z6 L% }) u, k' F. C4 Q5 zint convert(int number[],int ans);
1 j: C; @7 d! n, x9 ]1 F% Z4 h# o* @int *sort(int number[],int len);
$ K- ~9 _7 ]8 J# F* g8 U9 H5 {
9 T3 h8 E- n, z! ~1 G* Aint main(void)
; }( l+ z1 R- h/ x9 B+ F{
    int number[4] = {0};
, _- [7 }6 V9 @. Y; o3 W3 c, R+ o' r    int *p = NULL;
% }, j) |4 M8 o2 X* x9 ]    int n = 0;
    int ans = 0;
    int count = 0;
9 }5 G0 _" l9 ?  _+ ^  H    printf("请输入一个互不相同的四位数：");
    scanf("%d",&n);
    printf("输入的四位数是：%d\n",n);
9 _! x, C$ ~7 \( ]7 H    ans = n;
    while(ans!=6174)
$ K, K2 ]5 P& Y# H4 L    {
1 ]( d# F* ]# `/ _, |        ans = convert(number,ans);
        printf("第%d次：%d\n",count+1,ans);
        ++count;
    }
4 g& v  _+ P  X  L, O4 U  k    printf("经过了%d次最大减最小的动作\n",count);
    return 0;
}
. X+ i! D+ e7 V1 Y! z3 S# {# p; t
' X* a# G% u, Nint *sort(int number[],int len) //大到小的排序
{
5 G2 Y1 |- e. L# |    int a =0;
7 s  U# X; j. Q! ^6 M# k7 F- \- n    for(int i=0; i<len; ++i)
    {
7 E. ~9 D& q! n- q$ k* K        for(int j=i+1;j<len;++j)
        {
: c( ~% A  ]2 a* V6 S& l            if(number <number[j])
            {
                a = number;
# x0 f0 W, w$ P7 B7 t                number = number[j];
                number[j] = a;
            }
        }
* Y% m( |5 y7 A  X* @    }
8 \, o8 W. F2 @' N" n! I- `    return number;
8 D( Z/ W9 Z' i/ P) F) v}
3 f7 u2 ^# S$ R; P$ nint convert(int number[],int ans)//每次变换得到的数字
{
    int *p = NULL;
' c" Y5 ?; y, m5 h  d/ W! n' s    int m=0;
    number[0] = ans/1000;  //把这个数放入数组
    number[1] = ans%1000/100;
+ W' K8 b0 i1 n# m2 Y    number[2] = ans%100/10;
* O) i/ Q3 e7 `    number[3] = ans%10;
' Y" ^- _, r% g% d9 g6 O& a    p = sort(number,4);
    m=(*p*1000+*(p+1)*100+*(p+2)*10+*(p+3))- ( *(p+3)*1000+*(p+2)*100+*(p+1)*10+*p);//最大数字减去最小数字
5 }* E% U' N1 _+ u% U    return m;
}
& @- g' z4 u8 C: `! o) O( G运行结果：