C# 如果给定一个正整数，我的代码查找下一个回文是否有效？

问题陈述：对于给定的正数，我必须找出下一个回文。例如：

For 808, output:818
2133, output:2222

我想知道我的代码是否有效率，效率有多高？这是解决问题的好办法吗

逻辑解释：我已将

I

设置为数字的最左侧位置，

j

设置为最右侧位置，我基本上是在比较这两个数字。我总是分配

num[j]=num[I]

，并跟踪数字是否大于原始值、小于或等于原始值。最后，也就是说：

j-i==1或j==i

，根据数字的位数是偶数还是奇数，我看数字是否变大，并据此做出决定

编辑：该数字最多可长达100000位！。。这是问题陈述的一部分，所以我试图避免暴力手段

int LeftNineIndex = 0, RightNineIndex = 0;
bool NumberLesser = false, NumberGreater = false;
string number = Console.ReadLine();
char[] num = number.ToCharArray();
int i, j, x, y;
for (i = 0, j = num.Length - 1; i <= j; i++, j--)
{
      char m;
      Int32.TryParse(num[i].ToString(),out x);
      Int32.TryParse(num[j].ToString(), out y);
      if (x > y)
      {
           NumberGreater = true;
           NumberLesser = false;
      }
      else if (x < y)
      {
           if (j - i == 1)
           {
                NumberGreater = true;
                NumberLesser = false;
                x = x + 1;
                Char.TryParse(x.ToString(), out m);
                num[i] = m;
           }
           else
           {
                NumberGreater = false;
                NumberLesser = true;
           }             
     }

     if ((j == i && NumberGreater == false) || (j - i == 1 && x == y &&  NumberGreater == false))
     {
           if (x != 9)  // if the number is 9, then i can't add 1 to it
           {
                x = x + 1;
                Char.TryParse(x.ToString(), out m);
                num[i] = m;
           }
           else
           {
                if (num.Length != 1)
                {
                    Int32.TryParse(num[LeftNineIndex].ToString(), out x);
                    Int32.TryParse(num[RightNineIndex].ToString(), out y);
                    x = x + 1;
                    Char.TryParse(x.ToString(), out m);
                    num[LeftNineIndex] = m;
                    num[RightNineIndex] = m;
                }
                else
                {
                    // user has entered just '9', in which case I've hard-coded
                    Console.WriteLine("11");
                }
           }
     }
     num[j] = num[i];
     if (x != 9)  //gives us the index of the number closest to the middle, which is not 9
     {
          LeftNineIndex = i;
          RightNineIndex = j;
     }
}
Console.WriteLine(num);

int LeftNineIndex=0，RightNineIndex=0；
bool numbersser=false，NumberGreater=false；
字符串编号=Console.ReadLine（）；
char[]num=number.ToCharArray（）；
int i，j，x，y；
对于（i=0，j=num.Length-1；i y）
{
NumberGreater=true；
NumberLesser=假；
}
else if（x

我就是这样做的。似乎有效

        private int FindNextPaladindrone(int value)
    {
        int result = 0;
        bool found = false;

        while (!found)
        {
            value++;
            found = IsPalindrone(value);
            if (found)
                result = value;
        }

        return result;
    }

    private bool IsPalindrone(int number)
    {
        string numberString = number.ToString();
        int backIndex;

        bool same = true;
        for (int i = 0; i < numberString.Length; i++)
        {
            backIndex = numberString.Length - (i + 1);
            if (i == backIndex || backIndex < i)
                break;
            else
            {
                if (numberString[i] != numberString[backIndex])
                {
                    same = false;
                    break;
                }
            }
        }
        return same;
    }

private int FindNextPaladindrone（int值）
{
int结果=0；
bool-found=false；
而（！found）
{
值++；
found=isAlinDrone（值）；
如果（找到）
结果=值；
}
返回结果；
}
私人bool IsPalindrone（国际号码）
{
字符串numberString=number.ToString（）；
int-backIndex；
布尔相同=正确；
for（int i=0；i

在固定时间内查找下一个回文相对简单：

• 将输入分成两半（如果长度为奇数，则前半部分较大）
• 现在，对于下一个回文，有两个候选人：
• 保留前半部分，修复后半部分
• 将前半部分增加1，然后固定后半部分
• 如果第一个候选值大于输入值，则选择第二个候选值，否则选择第二个候选值

该类型对于实现以下功能非常有用：

这种方法在输入长度上具有成本线性，即在数字大小上是对数的

public static BigInteger NextPalindrome(BigInteger input)
{
    string firstHalf=input.ToString().Substring(0,(input.ToString().Length+1)/2);
    string incrementedFirstHalf=(BigInteger.Parse(firstHalf)+1).ToString();
    var candidates=new List<string>();
    candidates.Add(firstHalf+new String(firstHalf.Reverse().ToArray()));
    candidates.Add(firstHalf+new String(firstHalf.Reverse().Skip(1).ToArray()));
    candidates.Add(incrementedFirstHalf+new String(incrementedFirstHalf.Reverse().ToArray()));
    candidates.Add(incrementedFirstHalf+new String(incrementedFirstHalf.Reverse().Skip(1).ToArray()));
    candidates.Add("1"+new String('0',input.ToString().Length-1)+"1");
    return candidates.Select(s=>BigInteger.Parse(s))
              .Where(i=>i>input)
              .OrderBy(i=>i)
              .First();
}

公共静态BigInteger NextPalindrome（BigInteger输入）
{
string firstHalf=input.ToString（）.Substring（0，（input.ToString（）.Length+1）/2）；
字符串incrementedFirstHalf=（biginger.Parse（firstHalf）+1.ToString（）；
var候选者=新列表（）；
Add（firstHalf+新字符串（firstHalf.Reverse（）.ToArray（））；
Add（firstHalf+新字符串（firstHalf.Reverse（）.Skip（1.ToArray（）））；
Add（incrementedFirstHalf+新字符串（incrementedFirstHalf.Reverse（）.ToArray（））；
Add（incrementedFirstHalf+新字符串（incrementedFirstHalf.Reverse（）.Skip（1.ToArray（））；
添加（“1”+新字符串（'0'，input.ToString（）.Length-1）+“1”）；
返回候选项。选择（s=>biginger.Parse）
.其中（i=>i>input）
.OrderBy（i=>i）
.First（）；
}

通过与本机实现进行比较，测试可使用100000以下的所有正整数

---

第五个案例很容易被遗漏。如果数字由所有的

9

s组成，增加前半部分会改变长度，如果当前长度为奇数（

9

，

999

，…），则需要额外处理。

那么这是一个家庭作业问题吗？不……只是我在一些网站上读到的一个编程难题所有具有偶数位数的回文都可以被11整除。简洁的事实和可能有用的捷径。例如2222/11=202@BeRecursive：因此，我必须检查它是否为偶数，然后继续递增并除以11？。是这样吗？我觉得您当前的代码太复杂了<代码>大整数以及一些高级函数，