Kaprekar constant（卡普雷卡尔黑洞）
昨天在朋友的微博里看到一条关于数字迭代的有趣的题目。然后正好自己刚刚放假就没事写写，正好检验下我最近算法是否提高，其中弯路很多，追求在多次实践中来锻炼自己的逻辑和编码能力。
其中描述是：
把一个四位数的四个数字由小至大排列，组成一个新数，又由大至小排列排列组成一个新数，这两个数相减，之后重复这个步骤，只要四位数的四个数字不重复，数字最终便会变成 6174。
例如：
3109，
9310 - 0139 = 9171，
9711 - 1179 = 8532，
8532 - 2358 = 6174。
而 6174 这个数也会变成 6174，7641 - 1467 = 6174。
任取一个四位数，只要四个数字不全相同，按数字递减顺序排列，构成最大数作为被减数；按数字递增顺序排列，构成最小数作为减数，其差就会得6174；如不是6174，则按上述方法再作减法，至多不过10步就必然得到6174。
但是其中需要8步的初始数，我还没找（我把99999个随机数所转换数据导入到txt中，大小为8M，也没找到）
一个7步的示例：
如取四位数5679，按以上方法作运算如下：
9765-5679=4086 8640-4068=4572 7542-2457=5085
8550-5058=3492 9432-2349=7083 8730-3078=5652
6552-2556=3996 9963-3699=6264 6642-2466=4176
7641-1467=6174
其中c#实现代码如下：
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; namespace ConsoleApplication3 { class Program { static int[] rnd; static int N = 0; const int result = 6174; static Random rn = new Random(); static StringBuilder output = new StringBuilder(); static void Main(string[] args) { for (int i = 0; i < 99999; i++) { rndArr(4); output.AppendLine("初始数为：" + arrToint(rnd).ToString()); output.Append("差值过程数分别为："); if (function(rnd)) { output.AppendLine("执行次数为" + N.ToString() + "次"); output.AppendLine(""); N = 0; } } try { string filepath = "d:/1.txt"; FileStream fs = new FileStream(filepath, FileMode.Create); StreamWriter sw = new StreamWriter(fs); sw.Write(output); sw.Close(); Console.WriteLine("success!"); Console.WriteLine("已经写到" + filepath); } catch { Console.Write("0"); } Console.ReadKey(); } /// <summary> /// 迭代求计算次数 /// </summary> /// <param name="rTemp">差值循环</param> /// <returns>找到固定值返回True</returns> static bool function(int[] rTemp) { cba(rnd); //整理成可转换成最大值的int[] int newint = arrToint(rTemp) - arrTointR(rTemp); N++; output.Append(newint + ","); if (newint == result) { return true; } else return function(cba(intToarr(newint))); } /// <summary> /// 数组转换成数值(确保参数为最大值) /// </summary> /// <param name="a"></param> /// <returns>最大值</returns> static int arrToint(int[] a) { string temp = ""; for (int i = 0; i < a.Length; i++) temp += a[i].ToString(); return Int16.Parse(temp); } /// <summary> /// 将数组反向再转换成数值(确保参数为最大值) /// </summary> /// <param name="a"></param> /// <returns>最小值</returns> static int arrTointR(int[] a) { string temp = ""; for (int i = 0; i < a.Length; i++) temp += a[a.Length - i - 1].ToString(); return Int16.Parse(temp); } /// <summary> /// int值转成数组 /// </summary> /// <param name="a"></param> /// <returns></returns> static int[] intToarr(int a) { int length = a.ToString().Length; int[] re = new int[length]; for (int i = 0; i < length; i++) { re[i] = a / Convert.ToInt16(Math.Pow(10, length - 1 - i)); a = a - re[i] * Convert.ToInt16(Math.Pow(10, length - 1 - i)); } return re; } /// <summary> /// 产生初始随机数组 /// </summary> /// <param name="length"></param> static void rndArr(int length) { rnd = new int[length]; int[] rndtemp = new int[rnd.Length]; for (int i = 0; i < length; i++) { do { rndtemp[i] = rn.Next(10); } while (validate(rndtemp, rndtemp[i], i) || rndtemp[0] == 0); } rnd = rndtemp; } /// <summary> /// Random Validate 如果存在返回true /// </summary> /// <param name="v"></param> /// <param name="x">当前序号标记</param> /// <returns></returns> static bool validate(int[] temp, int v, int x) { int k = 0; for (int i = 0; i < x; i++) { if (temp[i] == v) k++; } if (k > 0) return true; return false; } /// <summary> /// 随机数组转换成最大值数组 /// </summary> /// <param name="temp"></param> /// <returns></returns> static int[] cba(int[] temp) { for (int i = 0; i < temp.Length - 1; i++) { for (int j = 0; j < temp.Length - i - 1; j++) { if (temp[j] < temp[j + 1]) { temp[j] = temp[j] + temp[j + 1]; temp[j + 1] = temp[j] - temp[j + 1]; temp[j] = temp[j] - temp[j + 1]; } } } return temp; } } }
其中用到了迭代算法，这算是第一次尝试，路漫漫，其中可能有一定多绕步，过路人可以指出，在下在这感谢各位。
参考资料：http://en.wikipedia.org/wiki/D._R._Kaprekar#cite_note-4
下面是网友给出的利用Linq写的算法：
static void Main(string[] args) { Process(1234, 1); Console.ReadKey(); } private static void Process(int number, int deep) { var numbers = new int[] { number % 10, (number % 100) / 10, (number % 1000) / 100, number / 1000 }; var ascOrder = numbers.OrderBy(n => n).ToArray(); var descOrder = numbers.OrderByDescending(n => n).ToArray(); var weiQuan = 10000; var smaller = ascOrder.Select(a => { weiQuan = weiQuan / 10; return a * weiQuan; }).Sum(); weiQuan = 10000; var bigger = descOrder.Select(a => { weiQuan = weiQuan / 10; return a * weiQuan; }).Sum(); var diff = bigger - smaller; Console.WriteLine(string.Format("第{4}次:{0}:{1}-{2}={3}", number, bigger, smaller, diff, deep)); if (diff == number) { Console.WriteLine("That's just right"); return; } else if (deep >= 10) { Console.WriteLine("计算次数超过10次,尚未证明结果,退出"); return; } else { Process(diff, ++deep); } }
首先我在随机4个数里面写了算法，然后在排序里面也相对写复杂了，网友这算法正是突显Linq编码优势的地方。
