C#数字黑洞之一(卡普雷卡尔黑洞：重排求差黑洞)

数字黑洞

数字黑洞，又称指的是某种运算，这种运算一般限定从某些整数出发，反复迭代后结果必然落入一个点或若干点的情况叫数字黑洞。

黑洞原是天文学中的概念，表示这样一种天体：它的引力场是如此之强，就连光也不能逃脱出来。

黑洞数又称陷阱数，类具有奇特转换特性，任何数字不全相同的整数，经有限重排求差操作，总会得某或些数，这些数即黑洞数重排求差操作即把组成该数数字重排得大数减去重排得小数。

卡普雷卡尔黑洞（重排求差黑洞）

1.三位数黑洞495：

只要你输入一个三位数，要求个，十，百位数字不相同，如不允许输入111，222等。那么你把这个三位数的三个数字按大小重新排列，得出最大数和最小数，两者相减得到一个新数，再按照上述方式重新排列，再相减，最后总会得到495这个数字。

举例：输入352，排列得最大数位532，最小数为235，相减得297；再排列得972和279，相减得693；接着排列得963和369，相减得594；最后排列得到954和459，相减得495。

2.四位数黑洞6174：

把一个四位数的四个数字由小至大排列，组成一个新数，又由大至小排列排列组成一个新数，这两个数相减，之后重复这个步骤，只要四位数的四个数字不重复，数字最终便会变成 6174。

例如 3109，9310 - 0139 = 9171，9711 - 1179 = 8532，8532 - 2358 = 6174。而 6174 这个数也会变成 6174，7641 - 1467 = 6174。

任取一个四位数，只要四个数字不全相同，按数字递减顺序排列，构成最大数作为被减数；按数字递增顺序排列，构成最小数作为件数，其差就会得6174；如不是6174，则按上述方法再作减法，至多不过7步就必然得到6174。

如取四位数5679，按以上方法作运算如下：

9765-5679==4086，8640-0468=8172，

8721-1278=7443， 7443-3447=3996，

9963-3699=6264， 6642-2466=4176

7641-1467=6174

我们使用VS2017新建控制台应用程序DigitalBlackHoleDemo

测试三位数黑洞495，四位数黑洞黑洞6174。源程序如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DigitalBlackHoleDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.SetWindowSize(100, 60);
            for (int i = 0; i < 3; i++)
            {
                ThreeDigitBlackHole(new Random(Guid.NewGuid().GetHashCode()).Next(100, 999));
                Console.WriteLine();
            }
            for (int i = 0; i < 5; i++)
            {
                FourDigitBlackHole(new Random(Guid.NewGuid().GetHashCode()).Next(1000, 9999));
                Console.WriteLine();
            }
            Console.ReadLine();
        }

        /// <summary>
        /// 三位数黑洞495
        /// </summary>
        /// <param name="threeDigit">任何一个不能被111整除的三位数</param>
        static void ThreeDigitBlackHole(int threeDigit)
        {
            Console.WriteLine($"开始计算三位数【{threeDigit}】的卡普雷卡尔黑洞数...");
            if (threeDigit < 100 || threeDigit > 999)
            {
                Console.WriteLine($"卡普雷卡尔黑洞三位数必须在100~999之间,当前数组【{threeDigit}】非法");
                return;
            }
            if (threeDigit % 111 == 0)
            {
                Console.WriteLine($"卡普雷卡尔黑洞三位数字不能完全一致,当前数组【{threeDigit}】非法");
                return;
            }
            int index = 1;
            //CalculateProcedure计算过程，使用三个数组成的最大数 减去 最小数
            while (true)
            {
                int[] descendingArray = GetdescendingNumber(threeDigit, 3);
                int maxNumber = int.Parse(string.Join("", descendingArray));
                int minNumber = int.Parse(string.Join("", descendingArray.Reverse()));
                int differenceNumber = maxNumber - minNumber;
                Console.WriteLine($"第【{index}】次运算：三位数【{threeDigit}】排列后的最大值【{maxNumber}】，最小值【{minNumber}】，差值【{differenceNumber}】");
                if (differenceNumber == threeDigit)
                {
                    Console.WriteLine($"已获得最终数字黑洞结果：【{differenceNumber}】，共运算【{index}】次");
                    break;
                }
                //使用差值重新运算
                threeDigit = differenceNumber;
                index++;
            }
        }

        /// <summary>
        /// 四位数黑洞6174
        /// </summary>
        /// <param name="fourDigit">任何一个不能被1111整除的四位数</param>
        static void FourDigitBlackHole(int fourDigit)
        {
            Console.WriteLine($"开始计算四位数【{fourDigit}】的卡普雷卡尔黑洞数...");
            if (fourDigit < 1000 || fourDigit > 9999)
            {
                Console.WriteLine($"卡普雷卡尔黑洞四位数必须在1000~9999之间,当前数组【{fourDigit}】非法");
                return;
            }
            if (fourDigit % 1111 == 0)
            {
                Console.WriteLine($"卡普雷卡尔黑洞四位数字不能完全一致,当前数组【{fourDigit}】非法");
                return;
            }
            int index = 1;
            //CalculateProcedure计算过程，使用三个数组成的最大数 减去 最小数
            while (true)
            {
                //唯一不同的就是参数不同
                int[] descendingArray = GetdescendingNumber(fourDigit, 4);
                int maxNumber = int.Parse(string.Join("", descendingArray));
                int minNumber = int.Parse(string.Join("", descendingArray.Reverse()));
                int differenceNumber = maxNumber - minNumber;
                Console.WriteLine($"第【{index}】次运算：四位数【{fourDigit}】排列后的最大值【{maxNumber}】，最小值【{minNumber}】，差值【{differenceNumber}】");
                if (differenceNumber == fourDigit)
                {
                    Console.WriteLine($"已获得最终数字黑洞结果：【{differenceNumber}】，共运算【{index}】次");
                    break;
                }
                //使用差值重新运算
                fourDigit = differenceNumber;
                index++;
            }
        }

        /// <summary>
        /// 返回逆序排序的三个数字 或 四个数字,如果返回数字低于digitCount个,那么尾巴按0处理
        /// 返回的数组的每一个元素都在0~9之间
        /// </summary>
        /// <param name="digit">源数，可能三位数，也可能是四位数，也可能是小于100的数</param>
        /// <param name="digitCount">返回的数字个数</param>
        /// <returns></returns>
        static int[] GetdescendingNumber(int digit, int digitCount)
        {
            int index = 0;
            Stack<int> stack = new Stack<int>();
            while (digit != 0)
            {
                stack.Push(digit % 10);
                digit = digit / 10;
                index++;
            }
            //Console.WriteLine(string.Join(",", stack));
            int[] descendingArray = stack.ToArray();
            //对数字进行逆序排序
            Array.Sort(descendingArray, (x, y) => y - x);
            int[] destArray = new int[digitCount];
            Array.Copy(descendingArray, destArray, descendingArray.Length);
            return destArray;
        }
    }
}

程序运行如图：