标题：6174
6174猜想
6174
因数分解：2*3^2*7^3，科学家称这个数为“自我拷贝数”。
例如: 
k0=5298,k1=9852-2589=7263,k2=7632-2367=5265,k3=6552-2556=3996,k4=9963-3699=6264,k5=6642-2466=4176,k6=7641-1467=6174. 
后来,这个问题就流传下来,人们称这个问题为"6174问题",上述变换称为卡普耶卡变换,简称 K 变换. 
一般地,只要在0,1,2,...,9中任取四个不全相等的数字组成一个整数k0(不一定是四位数),然后从k0开始不断地作K变换,得出数k1,k2,k3,...,则必有某个m(m=<7),使得km=6174. 
更一般地,从0,1,2,...,9中任取n个不全相同的数字组成一个十进制数k0(不一定是n位数),然后,从k0开始不断地做K变换,得出k1,k2,...,那么结果会是怎样的呢?现在已经知道的是: 
n=2,只能形成一个循环:(27,45,09,81,63).例如取两个数字7与3,连续不断地做K变换,得出:36,27,45,09,81,27,...出现循环. 
n=3,只能形成一个循环:(495). 
n=4,只能形成一个循环:(6174). 
n=5,已经发现三个循环:(53955,59994),(62964,71973,83952,74943),(63954,61974,82962,75933). 
n=6,已经发现三个循环:(642654,...),(631764,...),(549945,...). 
n=7,已经发现一个循环:(8719722,8649432,7519743,8429652,7619733,8439552,7509843,9529641...). 
n=8,已经发现四个循环:(63317664),(97508421),(83208762,86526432,64308654...),(86308632,...) 
n=9,已经发现三个循环:(864197532),(975296421,...),(965296431,...) 
容易证明,对于任何自然数n>=2,连续做K变换必定要形成循环.这是因为由n个数字组成的数只有有限个的缘故.但是对于n>=5,循环的个数以及循环的长度(指每个循环中所包含数的个数)尚不清楚,这也是国内一些数学爱好者热衷于研究的一个课题. 
6174是一个非常神奇的数字。乍一看，它可能不这么明显。但是，正如我们即将看到，任何人都可以通过简单的减法去发现6174的特别之处。
C语言的证明
6174猜想：一个任意的四位正整数（全相同的除外，如1111）。将数字重新组合成一个最大的数和最小的数相减，重复这个过程，最多七步，必得6174。下面给出c源码证明该猜想（1000-9999除去全相同的）：输出量过于庞大故略去了输出。
----------------------------------c语言实现---------------------------------------
#include<stdio.h>
void insertSort(int r[],int len){
int i,k,tmp;
for(i=1;i<len;i++){
k=i-1;
tmp=r[i];
while(k>=0&&r[k]>tmp){
r[k+1]=r[k];
k--;
}
r[k+1]=tmp;
}
}
void main(){
int i,count,end;
int r[4];
count=0;
end=0;
for(i=1000;i<9999;i++){
r[0]=i%10;
r[1]=i/10%10;
r[2]=i/100%10;
r[3]=i/1000;
if(r[0]==r[1]&&r[1]==r[2]&&r[2]==r[3])
continue;
else{
while(end!=6174){
insertSort(r,4);
end=1000*r[3]+100*r[2]+10*r[1]+r[0]-(1000*r[0]+100*r[1]+10*r[2]+r[3]);
r[0]=end%10;
r[1]=end/10%10;
r[2]=end/100%10;
r[3]=end/1000;
count++;
}
printf("%d一共经过了%d步得到了6174\n",i,count);
}
}
printf("\n");
}
----------------------------------c语言实现---------------------------------------
C演示猜想计算过程
以上给出了6174猜想的c证明。下面用c演示了对任一猜想中的四位数计算过程，并总计了一共操作的步骤。编译连接后，输入输出结果见下图所示：
输入：2000
输出：
第1步：2000-0002=1998
第2步：9981-1899=8082
第3步：8820-0288=8532
第4步：8532-2358=6174
2000一共经过了4步得到了6174
----------------------------------c语言实现---------------------------------------
#include<stdio.h>
void insertSort(int r[],int len){
int i,k,tmp;
for(i=1;i<len;i++){
k=i-1;
tmp=r[i];
while(k>=0&&r[k]>tmp){
r[k+1]=r[k];
k--;
}
r[k+1]=tmp;
}
}
void main(){
int N,count,end,s;
int r[4];
int max,min;
printf("请输入一个任意的四位正整数（全相同的除外，如1111）:");
scanf("%d",&N);
count=0;
end=0;
s=N;
while(end!=6174){
r[0]=s%10;
r[1]=s/10%10;
r[2]=s/100%10;
r[3]=s/1000;
insertSort(r,4);
max=1000*r[3]+100*r[2]+10*r[1]+r[0];
min=1000*r[0]+100*r[1]+10*r[2]+r[3];
end=max-min;
count++;
printf("第%d步：%d%d%d%d-%d%d%d%d=%d%d%d%d\n",count,r[3],r[2],r[1],r[0],r[0],r[1],r[2],r[3],end/1000,end/100%10,end/10%10,end%10);
s=end;
}
printf("%d一共经过了%d步得到了6174\n",N,count);
}
----------------------------------c语言实现---------------------------------------
Kaprekar变换
1949年，来自印度德伏拉利(Devlali)数学家D.R.Kaprekar设计了一个现在被称为Kaprekar变换的操作。首先选择一个四位不全相同的整数（即不是1111，2222，...），然后重新安排每一位上的数字得到一个最大数和最小数。接着，用最大的数减去最小的数从而获得一个新的数。重复以上操作以不断得到新的数。
这是一个简单的变换，但Kaprekar却发现它导致了一个令人吃惊的结果。让我们试试吧，去年是2005年，那就从2005开始。重排这个数的四个位数得到最大数是5200，最小数是0025，即25（如果有一个以上的0，那就把0放左边）。接下来的过程如下：
5200 - 0025 = 5175
7551 - 1557 = 5994
9954 - 4599 = 5355
5553 - 3555 = 1998
9981 - 1899 = 8082
8820 - 0288 = 8532
8532 - 2358 = 6174
7641 - 1467 = 6174
当我们得到6174这个数后，下一步都会得到6174这个数，以后每一步都不断重复。我们把6174这个数称为这个变换的核。所以6174是一个Kaprekar变换的核，但这是不是仅仅由一个数出发而得到6174的特殊例子？接下来我们可以看到6174不仅仅是Kaprekar变换的特例，有更多的惊喜等待着我们。让我们用不同地点整数再试一次，比如1789。
9871 - 1789 = 8082
8820 - 0288 = 8532
8532 - 2358 = 6174
我们又得到了6174！
当我们从2005开始到6174需要7步操作，而1789需要3步。事实上，对于所有四位不全相同的数字通过以上操作都能达到6174这个唯一的数。很神奇，不是吗？Kaprekar变换是如此的简单却从中发现了这个有趣的结果。当我们去思考为什么会是这个神秘的数字6174时，这个过程会更加有趣。
只有6174？
任何四位整数的四个位数都可以通过降序排列得到一个最大的数，而通过升序排列得到一个最小的数。比如有四个整数a,b,c,d他们之间的关系如下：
9 ≥ a ≥ b ≥ c ≥ d ≥ 0
且a,b,c,d不全相同，则最大的数是abcd而最小的数是dcba
我们可以通过标准的竖式减法来得到Kaprekar变换的结果：

abcd-dcba
ABCD而结果各位数存在以下关系：
D = 10 + d - a (因为 a > d)C = 10 + c - 1 - b = 9 + c - b (因为 b > c - 1)B = b - 1 - c (因为 b > c)A = a - d因为a>b>c>d。
如果得出的ABCD可以通过4个最初给出的数a,b,c,d表示的话，那么一个数便会通过Kaprekar变换重复出现。所以我们可以通过考虑{a, b, c, d}的所有可能的组合来判断是否满足以上条件，若符合的话便找到了Kaprekar变换的核。 每个组合（一共有4！=24种组合）给出一个含有四个未知数的联立方程组，所以我们能够解出a,b,c,d。
容易得出只有一种组合得到整数解且满足9 ≥ a ≥ b ≥ c ≥ d ≥ 0的条件。这个组合便是ABCD=bdac，而这种情况下联立方程组的解为a=7, b=6, c=4 和 d=1，即ABCD=6174。 然而如果a=b=c=d，则方程无解。因此6174是Kaprekar变换下唯一不变的数字-我们的神秘数字的确是独特的。
而对于三位数，同样的现象发生了。例如对753进行Kaprekar变换，步骤如下：
753 - 357 = 396
963 - 369 = 594
954 - 459 = 495
954 - 459 = 495
数字495便是三位数在Kaprekar变换下的唯一的核，易验证所有的三位数通过这个变换都会得到495，有兴趣的读者可以自行验证。
达到6174最多需要几步？
我第一次知道6174这个奇特的数是1975年，一个朋友告诉我的，当时给我留下了深刻的印象。我认为弄清楚这个现象为何发生比证明它要难得多。我用计算机去验证是否所有的四位数（四位不全相同）能否通过有限步达到6174这个核。这个程序是大概50行的Visual Basic语言编写，验证了所有8991个符合条件的四位数。
下表显示了运算结果：每个四位不全相同的四位数通过Kaprekar变换达到6174最多仅需7步。如果你用一个四位数通过Kaprekar变换并未在七步之内达到6174那就是你算错了！
迭代次数数字数01135625193212441124513796150871980怎样达到6174？
我的计算机程序验证了所有8991个数，不过Malcolm Lines的文章解释说验证Kaprekar变换仅需验证30个数就包含了所有可能的情况。
如前文一样，设一个四位数abcd，满足
9 ≥ a ≥ b ≥ c ≥ d ≥ 0
让我们进行第一次减法。最大的数是1000a+100b+10c+d 而最小的数是1000d+100c+10b+a 。所以这一步减法过程如下：
1000a + 100b + 10c + d - (1000d + 100c + 10b + a)
= 1000(a-d) + 100(b-c) + 10(c-b) + (d-a)
= 999(a-d) + 90(b-c)