任选4个不完全相同的数字（像1111就不行），让“最大排列”减“最小排列”（例如8753-3578），不断重复这个动作，最后一定会得到相同的结果：6174。神奇的是：这个“最大减最小”的动作，最多不会超过7次！

我们先来看看五组实验结果

请输入一个互不相同的四位数：3758
3 x) j' a: |! c4 x+ k" u& a输入的四位数是：3758
第1次：8753 - 3578 = 5175
, k* O+ K! }$ K第2次：7551 - 1557 = 5994
1 I' F+ p. j3 D' l第3次：9954 - 4599 = 5355
$ @7 V( l% k5 C5 s! Q第4次：5553 - 3555 = 1998
! t8 L- W# W) f7 h7 Q4 L! H9 V9 \+ E第5次：9981 - 1899 = 8082
第6次：8820 - 288 = 8532
第7次：8532 - 2358 = 6174
经过了7次最大减最小的动作
; d, U' o6 h$ p! ]) G' ^, ~请输入一个互不相同的四位数：2517
输入的四位数是：2517
( R/ B( U. g6 `1 }4 A# `第1次：7521 - 1257 = 6264
9 K3 b) ?1 C1 q  f8 L3 B第2次：6642 - 2466 = 4176
* a/ r1 v5 L* @! C! `# C- b' `& T; e第3次：7641 - 1467 = 6174
经过了3次最大减最小的动作
/ {% [( _& Q, ~1 r请输入一个互不相同的四位数：6915
/ n& ]" h# R5 A- a2 S输入的四位数是：6915
. U) t: m. s* @0 f1 o& M+ E# Y第1次：9651 - 1569 = 8082
' l- c8 a5 V- @8 q第2次：8820 - 288 = 8532
& n  F) \) ~6 \  V, q/ ?第3次：8532 - 2358 = 6174
经过了3次最大减最小的动作
请输入一个互不相同的四位数：9073
( V6 E5 V( q* U9 K$ Z( A5 m输入的四位数是：9073
6 J* _5 v; `! c8 \/ h第1次：9730 - 379 = 9351
第2次：9531 - 1359 = 8172
9 s& C3 R7 K7 L- R0 X6 m/ J# d0 u/ t第3次：8721 - 1278 = 7443
3 Q$ o: Z3 F! j$ W& t第4次：7443 - 3447 = 3996
6 d% Q* ~% @$ L+ O9 V/ W9 W+ i* J3 M第5次：9963 - 3699 = 6264
第6次：6642 - 2466 = 4176
( E. ~3 r0 ~% ~$ e第7次：7641 - 1467 = 6174
( @0 H$ \" @  c  v9 c4 |1 a3 @+ {' s经过了7次最大减最小的动作
2 y" a& [* k. \; F请输入一个互不相同的四位数：5287
( E" e4 H+ U. P. U输入的四位数是：5287
第1次：8752 - 2578 = 6174
$ j% Q- @1 _- s经过了1次最大减最小的动作

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

代码实现#include <stdio.h>

% {" b, r. P0 [+ _+ C* Gint convert(int number[],int ans);
' G; s# F- G6 W3 I! O2 _* \int *sort(int number[],int len);

1 R" ?/ M( D( i6 fint main(void)
" s( m9 J: h# a1 G{
    int number[4] = {0};
4 o) T5 {2 U3 V1 Q6 v    int *p = NULL;
: h) }# h7 g( `  g3 J    int n = 0;
    int ans = 0;
    int count = 0;
    printf("请输入一个互不相同的四位数：");
    scanf("%d",&n);
    printf("输入的四位数是：%d\n",n);
    ans = n;
    while(ans!=6174)
. H4 K1 K, a  X8 Q4 S    {
; O2 H: Y6 I' {. D0 n1 A        ans = convert(number,ans);
        printf("第%d次：%d\n",count+1,ans);
        ++count;
- K* |0 u9 b1 i2 E- O/ j    }
    printf("经过了%d次最大减最小的动作\n",count);
% T9 B* O( z, z6 X    return 0;
}

int *sort(int number[],int len) //大到小的排序
{
! L! L9 h4 g" I5 w, a% _4 d    int a =0;
3 d0 z  x' f$ s; t0 _" R    for(int i=0; i<len; ++i)
    {
0 j  E1 b. J7 V4 |* a  A# s        for(int j=i+1;j<len;++j)
        {
            if(number <number[j])
7 R8 r* |" ~$ [6 y9 E) Q            {
                a = number;
                number = number[j];
                number[j] = a;
            }
        }
    }
0 ^5 G6 R! X8 V; D- O) d    return number;
}
3 Y3 J2 j" k, @, dint convert(int number[],int ans)//每次变换得到的数字
- Y6 w$ i% P1 P) g$ x5 w7 W, H{
: j. W' ?' P& A- D  r. t$ X( r    int *p = NULL;
    int m=0;
8 v( P$ v2 Z8 w% a! w: I+ G    number[0] = ans/1000;  //把这个数放入数组
- e: e3 B3 [7 X! {0 M# H& `    number[1] = ans%1000/100;
' A# d" J  a0 z: y5 }2 H    number[2] = ans%100/10;
! S( A9 k! K& i' v' z    number[3] = ans%10;
    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);//最大数字减去最小数字
3 {$ \/ o) W/ m1 {; r) [    return m;
}
运行结果：

这是什么原理？