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

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

请输入一个互不相同的四位数：3758
输入的四位数是：3758
第1次：8753 - 3578 = 5175
第2次：7551 - 1557 = 5994
5 W3 }4 G- v4 }9 z0 Y$ Y第3次：9954 - 4599 = 5355
& e: K& G) m- ^  }; r  h第4次：5553 - 3555 = 1998
第5次：9981 - 1899 = 8082
第6次：8820 - 288 = 8532
第7次：8532 - 2358 = 6174
经过了7次最大减最小的动作
1 g9 g# ]4 k/ u6 e2 K: e6 [9 l* y5 J请输入一个互不相同的四位数：2517
输入的四位数是：2517
第1次：7521 - 1257 = 6264
第2次：6642 - 2466 = 4176
第3次：7641 - 1467 = 6174
0 x  K) r. O7 O0 ]( P经过了3次最大减最小的动作
请输入一个互不相同的四位数：6915
输入的四位数是：6915
# {5 k' C% Z; v' m- I第1次：9651 - 1569 = 8082
6 u  z) T& s; n; r& W9 d1 }第2次：8820 - 288 = 8532
0 g0 @( W. H: z% W第3次：8532 - 2358 = 6174
0 ?( E+ N$ i; j经过了3次最大减最小的动作
& u+ R" f* G$ c+ y请输入一个互不相同的四位数：9073
输入的四位数是：9073
+ k8 T0 R2 i' W  t/ `第1次：9730 - 379 = 9351
第2次：9531 - 1359 = 8172
第3次：8721 - 1278 = 7443
第4次：7443 - 3447 = 3996
第5次：9963 - 3699 = 6264
; C5 ~8 d  x' u1 \7 [! B/ [第6次：6642 - 2466 = 4176
第7次：7641 - 1467 = 6174
经过了7次最大减最小的动作
: w; [* T* j4 R. M. Z  L请输入一个互不相同的四位数：5287
输入的四位数是：5287
1 \* ?- a0 e3 X$ b- G2 [第1次：8752 - 2578 = 6174
2 T3 ~, t+ `& S; E经过了1次最大减最小的动作

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

代码实现#include <stdio.h>

" T* A1 {  p5 R" Q7 X. p/ Tint convert(int number[],int ans);
int *sort(int number[],int len);
" i7 y/ h2 Y) G+ {- K6 _
int main(void)
3 J  K; P2 B5 P, o1 i, {{
' `* P: W; U4 J8 o! n* L5 ^    int number[4] = {0};
    int *p = NULL;
0 L: [3 U0 k/ ?/ I+ j& U    int n = 0;
    int ans = 0;
    int count = 0;
    printf("请输入一个互不相同的四位数：");
! A* h1 O3 E; [2 M0 a% T: d+ J    scanf("%d",&n);
! v& h3 ^( ]1 Q# I. O0 ?4 k1 N) ?    printf("输入的四位数是：%d\n",n);
  }1 K! s( M2 N6 J& h    ans = n;
    while(ans!=6174)
    {
& W( C! j' c) V. o  R. G        ans = convert(number,ans);
2 z6 ?; N" p" l        printf("第%d次：%d\n",count+1,ans);
        ++count;
    }
$ w4 Z. B4 D( f# S, B    printf("经过了%d次最大减最小的动作\n",count);
0 n8 s) S. F: ^- ~5 o# \* j    return 0;
& I/ U/ {, d8 `}
4 l1 T. [8 k0 ^' l; Z' m( k) G: k; R
3 R$ S: ^# ]5 g# N' W+ z! pint *sort(int number[],int len) //大到小的排序
+ M- R9 m, E& X; e2 p1 G{
    int a =0;
    for(int i=0; i<len; ++i)
9 ^1 Q- q' r- y3 [! i    {
) g$ g( J% m% S        for(int j=i+1;j<len;++j)
/ @; `0 p- h* u% T4 A* v0 b2 c        {
            if(number <number[j])
6 Z% E' C! }9 p/ v7 S$ X; @: q/ y& z# ]            {
                a = number;
                number = number[j];
                number[j] = a;
            }
        }
    }
    return number;
}
. P9 D' i: R2 K. e1 Hint convert(int number[],int ans)//每次变换得到的数字
0 d8 x* W* ?. g) p: Y{
    int *p = NULL;
, F3 T+ E5 ~# L$ N. y8 `    int m=0;
    number[0] = ans/1000;  //把这个数放入数组
    number[1] = ans%1000/100;
! j2 ^% K& B: I    number[2] = ans%100/10;
$ ^# L% C# ?$ M9 X1 q, P5 \    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);//最大数字减去最小数字
' p! x6 Y6 |1 T  o: E5 [0 s. |5 S- y    return m;
8 _# Y2 Q: _- n; ?5 J}
) Y$ B9 b/ N( N, R, F0 {运行结果：
' D3 [' X; S  e" S/ B
* [1 [! ~$ D. Z& b+ j6 t, ~

这是什么原理？