算法题：回文数

描述

若一个数（首位不为零）从左向右读与从右向左读都一样，我们就将其称之为回文数。

例如：给定一个10进制数56，将56加65（即把56从右向左读），得到121是一个回文数。

又如：对于10进制数87：
STEP1：87+78 = 165 STEP2：165+561 = 726
STEP3：726+627 = 1353 STEP4：1353+3531 = 4884
在这里的一步是指进行了一次N进制的加法，上例最少用了4步得到回文数4884。

写一个程序，给定一个N（2<=N<=10或N=16）进制数M，其中16进制数字为0-9与A-F，求最少经过几步可以得到回文数。如果在30步以内（包含30步）不可能得到回文数，则输出“Impossible!”

格式

输入格式

共两行
第一行为进制数N（2<=N<=10或N=16）
第二行为N进制数M（0<=M<=maxlongint）

输出格式

共一行
第一行为“STEP=”加上经过的步数或“Impossible!”

样例1

样例输入1

9
87

Copy

样例输出1

STEP=6

Copy

限制

各个测试点1s

我的答案：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

class Main
{
    public static void main(String[] argv)
    {
        try {
            InputStreamReader inputStream = new InputStreamReader(System.in);
            BufferedReader buffer = new BufferedReader(inputStream);
            int type = Integer.parseInt(buffer.readLine());

            String numberStr = buffer.readLine();
            StringBuilder sourceNumber = new StringBuilder(numberStr);

            for (int i = 1; i <= 30; i++) {
                sourceNumber = NumberAddReverse.add(sourceNumber, type);
                PalindromeNumber palindromeNumber = new PalindromeNumber(sourceNumber);
                if (palindromeNumber.isPalindrome()) {
                    System.out.println("STEP=" + i);
                    return;
                }
            }
            System.out.println("Impossible!");
        } catch (Exception ex) {
            System.out.println("Error:" + ex.getMessage());
        }
    }
}

class NumberAddReverse
{
    public static StringBuilder add(StringBuilder number, int type)
    {
        long numberA = toDecimal(number, type);
        long numberB = toDecimal(number.reverse(), type);
        numberA += numberB;
        return toType(numberA, type);
    }

    public static long toDecimal(StringBuilder number, int type)
    {
        long total = 0;
        long pow = 1;
        for (int i = number.length() - 1; i >= 0; i--) {
            long num = 0;
            if (number.charAt(i) >= 'A') {
                num = number.charAt(i) - 65 + 10;
            } else {
                num = number.charAt(i) - 48;
            }
            total += num * pow;
            pow *= type;
        }
        return total;
    }

    public static StringBuilder toType(long number, int type)
    {
        StringBuilder result = new StringBuilder();
        while (true) {
            long mod = number % type;
            result.append(mod >= 10 ? (char)('A' + mod -10) : (char)('0' + mod));
            number /= type;
            if (number < type) {
                result.append(number >= 10 ? (char)('A' + number -10) : (char)('0' + number));
                break;
            }
        }
        return result.reverse();
    }
}

class PalindromeNumber
{
    StringBuilder numberStr;

    PalindromeNumber(StringBuilder numberStr)
    {
        this.numberStr = numberStr;
    }

    public boolean isPalindrome()
    {
        for (int i = numberStr.length() - 1; i >= 0; i--) {
            if (numberStr.charAt(i) == numberStr.charAt(numberStr.length() - 1 - i)) {
                if (i == numberStr.length() / 2) {
                    break;
                }
            } else {
                return false;
            }
        }
        return true;
    }
}