[NOIP] 1999 普及组 回文数 （含测试用例）

洛谷题目地址：[NOIP1999 普及组] 回文数 - 洛谷

题目描述

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

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

又如：对于十进制数 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（100位之内），求最少经过几步可以得到回文数。如果在 30 步以内（包含 30 步）不可能得到回文数，则输出 Impossible!。

输入格式

两行，分别是 N M。

输出格式

如果能在 30 步以内得到回文数，输出格式形如 STEP=ans，其中 ans 为最少得到回文数的步数。

否则输出 Impossible!。

输入输出样例

输入 #1

10
87

输出 #1

STEP=4

`````额外测试用例：

输入 #2

10
89        (会超过Integer, 得用Long) 

输出 #2

STEP=24

输入 #3

16
AC27

输出 #3

STEP=6

``````

将给出的n进制数和反转之后的数转为十进制相加，再将十进制数转为n进制数，重复操作，记录次数，判断是否是回文数。

Java代码：

import java.util.Scanner;

public class test {

    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int binary = scn.nextInt();
        String num = scn.next();
        int count = 0;
        while (!isPalindromes(num) && count < 30) {
            count++;
            String inverse = getPalindrome(num);
            long tenNum = Long.parseLong(toTenNum(num, binary));
            long tenInNum = Long.parseLong(toTenNum(inverse, binary));
            num = toBinaryNum(String.valueOf(tenNum +tenInNum), binary);
            //System.out.println(num);
        }
        if (count < 30) {
            System.out.println("STEP=" + count);
        } else {
            System.out.println("Impossible!");
        }
    }
    //将数转为10进制数
    public static String toTenNum(String num, int binary) {
        long ans = 0;
        StringBuilder numStr = new StringBuilder(num);
        for (int i = 0; i < numStr.length(); i++) {
            char character = numStr.charAt(i);
            // 大小写字母数字区分
            if (character >= 48 && character <= 57) {
                ans += (character - '0') * Math.pow(binary, (numStr.length() - 1 - i));
            } else if (character >= 65 && character <= 90) {
                ans += (character - 'A' + 10) * Math.pow(binary, (numStr.length() - 1 - i));
            } else {
                ans += (character - 'a' + 10) * Math.pow(binary, (numStr.length() - 1 - i));
            }
        }
        return String.valueOf(ans);
    }
    //将十进制数转为n进制数
    public static String toBinaryNum(String numStr, int binary) {
        long num1 = Long.parseLong(numStr);
        long remaindernum = 0;
        StringBuilder str = new StringBuilder("");
        //碾转相除法
        while (num1  != 0 ) {
            remaindernum = num1 % binary;
            num1 /= binary;
            if (remaindernum > 9) {
                str.insert(0, (char) (remaindernum - 10 + 97));
            } else {
                str.insert(0, (char) (remaindernum  + 48));
            }
        }
        return str.toString();
    }
    //判断是不是回文数
    public static boolean isPalindromes(String num) {
        int l = 0;
        int r = num.length() - 1;
        while (l < r) {
            if (num.charAt(l) == num.charAt(r)) {
                l++;
                r--;
            } else {
                return false;
            }
        }
        return true;
    }
    //获得反向字符串
    public static String getPalindrome(String num) {
        StringBuilder str = new StringBuilder();
        for (int i = num.length() - 1; i >= 0; i--) {
            str.append(num.charAt(i));
        }
        return str.toString();
    }
}

​