回文数Palindromic Number
正读倒读相同的整数
回文数是指一个整数，从左向右读和从右向左读完全相同，就像数字照镜子一样 。例如 121、1331、0 都是回文数，而 123、10 则不是 。
大多数正整数都不是回文数，我们这里进行一个运算：
一个数字加上自己的反转数，结果变成回文数就终止，如果不是，继续对结果数进行递归处理。
比如 56,倒过来是 65，加起来 121------121 正着读、反着读都一样，这叫回文数，一次就结束。
再来个复杂一点的 59：59 + 95 = 154，154 + 451 = 605，605 + 506 = 1111。三步结束。
但有些数字无法回归，比如196。
【自身+反转数】是否是回文数：递归运算
我们设定逻辑规则如下：如果当前数字是回文数，直接返回,
如果经过运算，【自身+反转数】的相加之和是回文数也结束，记录(运算次数,是否可以回归)。
最多运算50次，超过50次就认为【疑似无法回归数字】
验证C#程序
cs
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/*
* 回文数 palindromic number。
* 指正读和反读都相同的数字（如121、1331）。
*/
namespace PalindromicNumberSnake
{
class Program
{
static void Main(string[] args)
{
const int maxNumber = 300;
List<(int, bool, long, long)> mazyList = new List<(int, bool, long, long)>();
for (int i = 1; i <= maxNumber; i++)
{
(int count, bool isRegress, long calcNumber) = IsPalindromicAfterCalculate(i);
if (count >= 5)
{
//如果可以回归，并且运算次数超过5次，就认为是复杂的
mazyList.Add((count, isRegress, calcNumber, i));
}
}
Console.WriteLine("----------------------------------------------------");
string path = "E:\\snake.log";
if (File.Exists(path))
{
File.Delete(path);
}
File.AppendAllText(path, $"记录【1~{maxNumber}】内超过5次【自身+反转数】运算后的回归数{Environment.NewLine}", Encoding.UTF8);
for (int i = 0; i < mazyList.Count; i++)
{
string contents = $"第【{i + 1}】个运算【{mazyList[i].Item1}】次，是否回归【{mazyList[i].Item2}】,计算结果数字【{mazyList[i].Item3}】，原数【{mazyList[i].Item4}】";
Console.WriteLine(contents);
File.AppendAllText(path, $"{contents}{Environment.NewLine}", Encoding.UTF8);
}
Console.ReadLine();
}
/// <summary>
/// 某一个数是否是回文数：一个数字与反转后的数字一致就是回文数
/// 如8、161、1441
/// </summary>
/// <param name="number"></param>
/// <returns></returns>
static bool IsPalindromicNumber(long number)
{
return number == ReverseNumber(number);
}
/// <summary>
/// 将一个数字反转 ，比如 254，反转后为452。9200反转后为 0029，也就是29
/// </summary>
/// <param name="number"></param>
/// <returns></returns>
static long ReverseNumber(long number)
{
if (number <= 0)
{
throw new ArgumentException("回文数必须是正数");
}
//long temp = number;
//Queue<long> queue = new Queue<long>();
//while (temp > 0)
//{
// queue.Enqueue(temp % 10);
// temp = temp / 10;
//}
//long reverseNumber = long.Parse(string.Join("", queue));
long reverseNumber = 0;
while (number != 0)
{
long digit = number % 10;
reverseNumber = reverseNumber * 10 + digit;
number = number / 10;
}
return reverseNumber;
}
/// <summary>
/// 逻辑如下：如果当前数字是回文数，直接返回,
/// 如果经过一系列运算，【自身+反转数】的相加之和是回文数也结束，记录(运算次数,是否可以回归)
/// 最多运算50次，超过50次就认为【疑似无法回归数字】
/// 规则：把一个数和它倒过来写的数相加，得到结果，再重复这个动作。
/// 比如 56,倒过来是 65，加起来 121------121 正着读、反着读都一样，这叫回文数，一次就结束。
/// 再来个难一点的 59：59 + 95 = 154，154 + 451 = 605，605 + 506 = 1111。三步收工。
/// </summary>
/// <param name="number"></param>
/// <returns>元组：(运算次数,是否回文数)</returns>
static (int, bool, long) IsPalindromicAfterCalculate(long number)
{
long srcNumber = number;//记录原数
int count = 0;
while (count < 50)
{
if (IsPalindromicNumber(number))
{
Console.WriteLine($"【{srcNumber}】是回归数，运算【{count}】次后转变为回文数。当前运算结果数【{number}】");
return (count, true, number);
}
number = number + ReverseNumber(number);
//遇到溢出变成负数的处理，比如196，运算多次就变成负数了
if (number < 0)
{
Console.WriteLine($"【{srcNumber}】【疑似无法回归数字】已运算【{count}】次，仍然不是回文数。当前运算结果数【{number}】");
return (count, false, number);
}
count++;
}
Console.WriteLine($"【{srcNumber}】【疑似无法回归数字】已运算【{count}】次，仍然不是回文数。当前运算结果数【{number}】");
return (count, false, number);
}
}
}运算结果：
