我有一道算法题，谁能准确得出答案的给分

Question

题如下：
给出一个整数，将它进行倒置成B，然后A＋B，结果为C，C为对称数，如果不对称，
将C在进行以上的相加求和，直到它找到对称数为止
如：
1.21＋12＝33
2.165+561=726
  726+627=1353
  1353+3531=4884
3.14751+15741=30492
  30492+29403=59895现在要在1到15000之间，在60次循环之内，找到不能求出对称数的个数提示：在相加的过程中，任何数据类型都会溢出，所以只能通过字符串的形式来求和（就是网上说的大数运算）我写的代码见下一楼还有我算出的结果是441个，答案说是437个，不知道我问题出在哪儿

Answer 1

using System;
using System.Collections.Generic;
using System.Text;namespace SymmetricalArithmetic
{
    class NumOperation
    {
        #region 变量
        int _minValue, _maxValue;
        StringBuilder builder;
        int[] chs;
        int count;//不能算出对称数的个数
              public NumOperation(int MinValue, int MaxValue)
        {
            _minValue = MinValue;
            _maxValue = MaxValue;
        }        /// <summary>
        /// 得到最终运算结果
        /// </summary>
        /// <returns></returns>
        public int GetSymmetryCount()
        {
            //arrayList = new ArrayList();            bool isSymmetry;            for (int i = _minValue; i <= _maxValue; i++)
            {
                Console.WriteLine("****************" + i.ToString() + "*******************");                if (lessThanFive(i.ToString()))//判断此数是不是小于5,如果是小于5肯定是对称
                {
                    Console.WriteLine(i.ToString() + "此数小于5肯定是对称");
                    continue;
                }                  isSymmetry = isSymmetrical(i.ToString());//递归（在60次之内判断是否为对称）                if (!isSymmetry)
                {
                    Console.WriteLine(i.ToString()+"结果：不是对称");
                    count++;
                }
          }
            return count;
        }                /// <summary>
        /// 反转方法
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        string reverse(string i)
        {
            int count=0;//前面为0的个数            if (i.Length > 1)
            {
                if (builder == null)
                    builder = new StringBuilder();                builder.Remove(0, builder.ToString().Length);                chs = ConvertStrToArray(i);                /*判断反转后前面的数是否为0*/
                for(int k=0;k<chs.Length;k++)
                {
                    if (chs[k] == 0)
                        count++;
                    else
                        break;
                }                for (int k = count; k < chs.Length; k++)
                {
                    builder.Append(chs[k].ToString());
                }                return builder.ToString();
            }
            return i;
        }        /// <summary>
        /// 判断是否为匀称
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public bool verdictSymmetrical(string i)
        {            if (i == reverse(i))
                return true;
            else
                return false;
        }
        /// <summary>
        /// 此数是不是小于5,如果是小于5肯定是对称
        /// </summary>
        /// <param name="num"></param>
        /// <returns></returns>
        bool lessThanFive(string num)
        {
            chs = ConvertStrToArray(num);            for (int i = 0; i < chs.Length; i++)
            {
                if (chs[i] >= 5)
                    return false;
            }            return true;
        }        /// <summary>
        /// 递归（在60次之内判断是否为对称）
        /// </summary>
        /// <param name="num"></param>
        /// <param name="time"></param>
        /// <returns></returns>
        bool isSymmetrical(string num)
        {
            StringBuilder num1,num2, sum,gd;            num1 = new StringBuilder();            num2 = new StringBuilder();            sum = new StringBuilder();            gd = new StringBuilder();            num1.Append(num);            for (int i = 0; i <65; i++)
            {
                if (lessThanFive(num1.ToString()))//判断此数是不是小于5,如果是小于5肯定是对称
                {
                    Console.WriteLine(num1.ToString()+"此数小于5肯定是对称");
                    return true;
                }                Console.Write(num1.ToString());                /*反转*/
                gd.Remove(0, gd.Length);                gd.Append(reverse(num1.ToString()));                num2.Remove(0, num2.Length);                num2.Append(gd.ToString());                Console.Write("+"+num2.ToString());                /*相加*/
                gd.Remove(0, gd.Length);                gd.Append(OperationAdd(num1.ToString(), num2.ToString()).ToString());                sum.Remove(0, sum.Length);                sum.Append(gd.ToString());                Console.WriteLine("=" + sum.ToString());                                /*判断是否为对称*/
                if (verdictSymmetrical(sum.ToString()))
                {
                    Console.WriteLine("运算次数"+(i+1).ToString());
                    return true;
                }
                else
                {
                    num1.Remove(0, num1.Length);                    num1.Append(sum.ToString());
                }
            }            return false;
        }        /// <summary>
        /// 将字符串转换成整型数组
        /// </summary>
        /// <param name="A"></param>
        /// <returns></returns>
        int[] ConvertStrToArray(string A)
        {
            int[] str=new int[A.Length];            for (int i = 0; i < A.Length; i++)
            {
                str[i] = Convert.ToInt32(A.Substring(A.Length - 1 - i, 1));
            }
            return str;
        }
        /// <summary>
        /// 将整型数组转换成字符串
        /// </summary>
        /// <param name="A"></param>
        /// <returns></returns>
        string ConvertArrayToStr(int[] A)
        {
            int length = 0;             if (builder == null)
                    builder = new StringBuilder();            builder.Remove(0,builder.ToString().Length);            length = A.Length - (A[A.Length - 1] != 0 ? 0 : 1);            for (int i = length; i > 0; i--)
                builder.Append(A[i - 1].ToString());            return builder.ToString();
        }
        /// <summary>
        /// 两个字符串相加
        /// </summary>
        /// <param name="A"></param>
        /// <param name="B"></param>
        /// <returns></returns>
        string OperationAdd(string A, string B)
        {
            int[] strA = ConvertStrToArray(A);            int[] strB = ConvertStrToArray(B);            int[] newStr = new int[Math.Max(A.Length, B.Length) + 1];            int i, rem = 0;            bool incFl;            for (i = 0; i <newStr.Length; i++)
            {
                newStr[i] = (strA.Length > i ? strA[i] : 0);
            }            for (i = 0; i < strB.Length; i++)
            {
                if (newStr[i] + strB[i] + rem >= 10)
                {
                    newStr[i]+=strB[i] + rem - 10;
                    rem = 1;
                }
                else
                {
                    newStr[i] += strB[i] + rem;
                    rem = 0;
                }
            }
            /*判断最后一位是否要进一位*/
            while (rem == 1)
            {
                incFl = (newStr[i] == 9);
                newStr[i++] += (incFl ? -9 : 1);
                rem = (incFl ? 1 : 0);            
            }
            return ConvertArrayToStr(newStr);
        }
    }
}
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;namespace SymmetricalArithmetic
{
    class Program
    {
        static void Main()
        {
            int minValue, maxValue;
            minValue =1;
            maxValue = 15000;
            NumOperation oper = new NumOperation(minValue, maxValue);
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("*********************************************");
            Console.WriteLine(string.Format("在{0}和{1}之间不能运行得出对称数的个数:{2}",minValue,maxValue,oper.GetSymmetryCount()));//输出不能算出对称数的个数
            Console.ReadLine();
        }
    }
}

Answer 2

 for (int i = 0; i <65; i++) 
是不因为上边错了 i<=60

Answer 3

关键是对称加法，SymmetryAdd()参考如下代码：
/// <summary>
/// 判断是否为对称数
/// </summary>
/// <param name="number">数字字符串</param>
/// <returns>返回是否为对称数</returns>
private bool IsSymmetry(string number)
{
    for (int i = 0; i < number.Length / 2; i++)
        if (number[i] != number[number.Length - i - 1]) return false;
    return true;
}/// <summary>
/// 将数字颠倒和原数相加
/// </summary>
/// <param name="number">数字字符串</param>
/// <returns>返回相加的和</returns>
private string SymmetryAdd(string number)
{
    int t = 0; // 进位数
    char[] chars = new char[number.Length];
    for (int i = 0; i < number.Length; i++)
    {
        int j = (number[i] - '0') + (number[number.Length - i - 1] - '0') + t;
        chars[number.Length - i - 1] = (char)('0' + j % 10);
        t = j / 10; // 计算进位
    }
    if (t <= 0) return new string(chars);
    return t.ToString() + new string(chars);
}private const int calcCount = 60; // 计算次数
private bool SymmetryExists(string number)
{
    for (int i = 0; i < calcCount; i++)
    {
        if (IsSymmetry(number)) return true;
        number = SymmetryAdd(number);
    }
    return IsSymmetry(number);
}private void button1_Click(object sender, EventArgs e)
{
    int count = 0;
    for (int i = 165; i < 15000; i++)
        if (!SymmetryExists(i.ToString()))
            count++;
    Console.WriteLine(count);
}

Answer 4

zswang 谢谢你的回答，你的写法更加简单明了，我想你已经发现我的问题了