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

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

请输入一个互不相同的四位数：3758
2 z( N) A8 U' E$ w) y* o+ u输入的四位数是：3758
第1次：8753 - 3578 = 5175
; m) K: H; j6 D9 E4 t* \# g第2次：7551 - 1557 = 5994
第3次：9954 - 4599 = 5355
3 w* c/ D* n* v+ u) P" E第4次：5553 - 3555 = 1998
  G! g; g$ ^: l8 b1 i& l. u+ e第5次：9981 - 1899 = 8082
第6次：8820 - 288 = 8532
) W. ?) @* W- Z第7次：8532 - 2358 = 6174
经过了7次最大减最小的动作
请输入一个互不相同的四位数：2517
输入的四位数是：2517
第1次：7521 - 1257 = 6264
/ G- M; M0 f( f$ @- _- I第2次：6642 - 2466 = 4176
第3次：7641 - 1467 = 6174
9 L4 m/ a3 }" t$ D! V+ O2 d经过了3次最大减最小的动作
4 Y8 w, X& Y2 s( c& f- q0 N  N请输入一个互不相同的四位数：6915
7 R$ S/ b* F% p/ \. s1 N输入的四位数是：6915
第1次：9651 - 1569 = 8082
第2次：8820 - 288 = 8532
第3次：8532 - 2358 = 6174
. {/ d9 K8 s9 k  I" ]1 U- L& B经过了3次最大减最小的动作
2 p& A- N0 s- Y1 G9 J$ M请输入一个互不相同的四位数：9073
输入的四位数是：9073
1 m5 D) `9 J7 O' h, n9 M第1次：9730 - 379 = 9351
第2次：9531 - 1359 = 8172
6 v$ v! u% y6 K# S9 x8 @8 X第3次：8721 - 1278 = 7443
5 E" Z$ }; E  E' n第4次：7443 - 3447 = 3996
  Z* L) M$ `8 z( Y第5次：9963 - 3699 = 6264
第6次：6642 - 2466 = 4176
第7次：7641 - 1467 = 6174
经过了7次最大减最小的动作
请输入一个互不相同的四位数：5287
输入的四位数是：5287
第1次：8752 - 2578 = 6174
经过了1次最大减最小的动作
( }4 m' y/ `( L- O

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

代码实现#include <stdio.h>

9 r% p* ]2 t1 O4 B" x$ X6 lint convert(int number[],int ans);
4 {* a! ~* K$ V, r, Y' _int *sort(int number[],int len);

int main(void)
{
3 x* t  {3 r( h" V2 _. Y    int number[4] = {0};
    int *p = NULL;
1 j3 e* z5 W, O8 E9 w    int n = 0;
8 ?  V/ [, ?* Q' \    int ans = 0;
, g( e! ^" g9 u' @, {    int count = 0;
( {! W$ k  l0 x5 m7 z' h0 x7 x% q    printf("请输入一个互不相同的四位数：");
  u/ u  v+ W; d% [' `/ q' W" G    scanf("%d",&n);
7 o1 n- W. N9 K' [" y    printf("输入的四位数是：%d\n",n);
    ans = n;
2 v+ u! G& [- E6 {2 q7 l* u) i3 k8 ?5 E    while(ans!=6174)
    {
        ans = convert(number,ans);
. M/ ^/ N8 }! \) U+ ?1 s        printf("第%d次：%d\n",count+1,ans);
        ++count;
* @  J) N9 V. C" {# [2 G9 {9 e    }
    printf("经过了%d次最大减最小的动作\n",count);
    return 0;
: J1 O% ^; V2 b; N* ]- c, H3 [5 B}
- O% M: F- S' _% i0 @
int *sort(int number[],int len) //大到小的排序
  z% l6 M: }+ O6 d2 y2 Q; O{
    int a =0;
( i8 c3 N0 [0 c4 r* D    for(int i=0; i<len; ++i)
3 L5 w7 _: }& a% R4 R- x9 H    {
        for(int j=i+1;j<len;++j)
1 |& C/ w" R1 a$ m" z6 ~6 e2 X) U        {
+ N) ~* _# x# j7 e# l/ t: S            if(number <number[j])
4 ]7 E. u1 N. O! T; l' D            {
- W  b9 F4 ~( p5 q: d                a = number;
2 q# v, f; c8 l4 z) Y6 l) v                number = number[j];
* h0 G# L$ T8 h9 z, [# e6 h                number[j] = a;
% |5 }8 O' S  f* ?" h            }
' ?: i" Z0 W* a5 P. E8 P        }
    }
    return number;
2 I/ p6 {" b8 z  A' x( e' y& t}
int convert(int number[],int ans)//每次变换得到的数字
* T( h2 o- O* q9 E{
7 |7 h- t9 j$ E8 b, g8 T/ ]# k" \    int *p = NULL;
& s- }% D1 o2 U: E5 c* W/ {# o    int m=0;
" N3 S% q3 s# ?- M/ r    number[0] = ans/1000;  //把这个数放入数组
  c1 E9 \; F5 C1 q' E    number[1] = ans%1000/100;
    number[2] = ans%100/10;
( x3 i, C+ J/ R% W9 G5 |  n    number[3] = ans%10;
4 F7 d/ t  }2 F, {% K  c7 h    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);//最大数字减去最小数字
    return m;
8 Q/ \- p6 L1 x' C+ ?# W# ]4 B}
" u$ p9 m) U( ^: E4 F/ S运行结果：

( P. H& F! o* N

这是什么原理？