关于回文数

Question

前几天做了个上机题
定义： 一个整数如12521 反转后还是12521为一个Symmetrical integer
如果一个整数将他反转后相加得到P，P如果是Symmetrical integer，则这个整数也为Symmetrical integer。
譬如：1. 47+74=121 则47也是Symmetrical integer
     2. 349 + 943 = 1292      1292 + 2921 = 4213      4213 + 3124 = 7337    349也为Symmetrical integer求1到15000的整数中不是Symmetrical integer的整数   反转相加次数不能超过60次

Answer 1

原文是
Definition: a Symmetrical integer number P is defined as the same number when all its digits are reversed. E.g. 12521.If we take an integer, repeatedly reverse it and add to itself, some integers eventually become P.e.g. 1. Take 4747 + 74 = 121e.g. 2. Take 349349 + 943 = 12921292 + 2921 = 42134213 + 3124 = 7337Write a console application in C# to find how many integers from 1 to 15000After 60 repetitions (sum of itself and its reverse number) NOT to become P.Your program should demonstrate1.      Correctness. It should result in the correct answer.
2.      Consideration for execution speed and memory space consumption.
3.      Proper organization of code and comments of code. Use Object Oriented programming if you feel applicable.

Answer 2

我在网上找到一段
不过运行时出错了，找了好久不知道怎么改
望大侠们指点下小弟
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;namespace SymmetricalArithmetic
{
    class Program
    {
        static void Main(string[] args)
        {
            bool isSymmetry;
            for (int i = 1; i <= 15000; i++)
            {
                if (lessThanFive(i))//此数是不是小于5,如果是小于5肯定是对称
                    continue;                isSymmetry = isSymmetrical(i, 0);                if (!isSymmetry)
                {
                    count++;
                    Console.WriteLine(i);
                }
            }            Console.Write(count.ToString());            Console.ReadLine();
        }        static StringBuilder builder;
        static char[] chs;
        static int count;        /// <summary>
        /// 反转方法
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        static Int64 reverse(Int64 i)
        {
            if (i > 10)
            {
                if (builder == null)
                    builder = new StringBuilder();                builder.Remove(0, builder.ToString().Length);                chs = i.ToString().ToCharArray();                for (int k = chs.Length - 1; k >= 0; k--)
                {
                    builder.Append(chs[k].ToString());
                }                return Int64.Parse(builder.ToString());
            }
            return i;
        }        /// <summary>
        /// 判断是否为匀称
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        static bool verdictSymmetrical(Int64 i)
        {
            Int64 j = reverse(i);            if (i == j)
                return true;
            else
                return false;
        }
        /// <summary>
        /// 此数是不是小于5,如果是小于5肯定是对称
        /// </summary>
        /// <param name="num"></param>
        /// <returns></returns>
        static bool lessThanFive(Int64 num)
        {
            chs = num.ToString().ToCharArray();            for (int i = 0; i < chs.Length; i++)
            {
                if (Convert.ToInt32(chs[i]) > 5)
                    return false;
            }            return true;
        }        /// <summary>
        /// 递归（在60次之内判断是否为对称）
        /// </summary>
        /// <param name="num"></param>
        /// <param name="time"></param>
        /// <returns></returns>
        static bool isSymmetrical(Int64 num, int time)
        {
            if (time <= 60)
            {
                Int64 num2 = reverse(num);//反转                Int64 sum = num2 + num;//相加                if (verdictSymmetrical(sum))//判断是否为对称
                    return true;                isSymmetrical(sum, time +1);//递归
               
            }
            return false;
        }
    }
}

Answer 3

/// <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;/// <summary>
/// 判断经过指定次数后是否出现对称数
/// </summary>
/// <param name="number">数字字符串</param>
/// <returns>返回是否出现对称数</returns>
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 = 1; i < 15000; i++)
        if (!SymmetryExists(i.ToString()))
            count++;
    Console.WriteLine(count);
}

Answer 4

zswang
伴水 清洁工 看帖要回贴牛程中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 string SymmetryAdd(string number)
{
            char[] c=number.ToCharArray();
            Array.Reverse(c);
            return (Int32.Parse(number) + Int32.Parse(new string(c))).ToString();
}

Answer 5

简化后出现一个问题,"值对于 Int32 太大或太小。"好像溢出了

Answer 6

呜呜呜，今天面试到这道题了，我是用数组做的，中间全是对的，只是忘记用15000-我的结果，
因为是NOT to become P
读题时，我还看到了，结果做的时候忘记这一点了，郁闷死了。

Answer 7

就应该把数变成十进制串，然后变成int[](byte[]都可以啊)存放每一位上的数为一个一位数,
然后再对int[]及其反过来的数相加，一定要考虑到进位
就是这么简单。我太伤心了