[2014亞馬遜amazon] 在線筆試題 大於非負整數N的第一個回文數 Symmetric Number

1.題目

　　如標題，求大於整數N(N>=0)的第一個回文數的字符串表示形式。

　　這個題目也是當時筆試第一次見到，花了一個小時才做出了。慢慢總結還是挺簡單的。

2.分析

　　分析如下:

　　(1)一位數N(9除外)。

　　　　第一個大於N回文數等於N+1，如大於3的第一個回文數是4。

　　　

　　(2)奇數位(一位數除外)

　　　　需要看“左邊反轉數字”是否大於"右邊數字"。

　　　　　1)如果小於等於，則“左邊+中間字母”組成的數字+1，再對稱就可以。

　　　　　2)如果大於，則左邊數字直接對稱到右邊就可以啦。

　　　　

　　(3)偶數位

　　　　需要看“左邊反轉數字”是否大於"右邊數字"。

　　　　　1)如果小於等於，則“左邊”組成的數字+1，再對稱就可以。

　　　　　2)如果大於，則左邊數字直接對稱到右邊就可以啦。

　　　　

　　(4)特殊情況(其實就一種)

　　　　1)N=9，大於N的下一個回文數是11，即N+2

　　　　2)奇數情況(位數!=1)。

　　　　　　N1=99900，右邊數字小於“左邊，翻轉數字”，直接對稱，所以大於N1的第一個回文數是99999。（滿足上面的討論規則）

　　　　　　N2=99999，右邊數組大於等於“左邊，翻轉數字”，使用上面的討論規則結果為1000 001 ，不正確。結果應該是N2+2

　　　　3)偶數情況。

　　　　　　N1=9900，右邊數字小於“左邊翻轉數字”，直接對稱，所以大於N1的第一個回文數是9999。（滿足上面的討論規則）

　　　　　　N2=9999，右邊數組大於等於“左邊翻轉數字”，使用上面的討論規則結果為100 001 ，不正確。結果應該是N2+2

　　所以，可以將特殊情況歸結為一種，當整數N滿足正則表達式"9+"時，大於N的第一個回文數是N+2。(9,99,999,9999,.....)

3.生成代碼+測試代碼

/**
 * 生成函數：
 *         firstBiggerPalindrome(String n)
 *         isLeftReverseBiggerRight(String left, String right)
 * 后期使用for循環校驗N in [0,1000000)時的情況函數：
 *         nextPalindromeUseFor(int num, boolean[] Palindrome)
 *         isPalindrome(int num)
 * 
 * 在main函數內進行算法生成 與 for循環暴力生成的校驗
 * */

public class Solution {
    static String firstBiggerPalindrome(String n) { // 生成大於整數N(字符串表示)的第一個回文整數
        n = String.valueOf(Integer.parseInt(n)); // 避免前導符"0"，如n="009"
        if (n.matches("9+")) // 特殊情況直接處理
            return String.valueOf(Integer.parseInt(n) + 2);

        int len = n.length();
        if (len == 1) // 長度為1
            return String.valueOf(Integer.parseInt(n) + 1);
        StringBuilder left = new StringBuilder(); // 左邊
        StringBuilder right = new StringBuilder(); // 右邊
        StringBuilder res = new StringBuilder(); // 結果
        if ((len & 0x1) == 1) { // 奇數位
            left.append(n.substring(0, len >> 1));
            right.append(n.substring((len >> 1) + 1));
            if (isLeftReverseBiggerRight(left.toString(), right.toString())) { // 如果左邊翻轉數字大於右邊，直接翻轉
                res.append(left);
                res.append(n.charAt(len >> 1));
                res.append(left.reverse().toString());
            } else { // 否則，“左邊+中間”數字加1，再翻轉
                left.append(n.charAt(len >> 1));
                int num = Integer.parseInt(left.toString()) + 1;
                left.setLength(0);
                left.append(num);

                res.append(num);
                res.append(left.deleteCharAt(left.length() - 1).reverse()
                        .toString());
            }
        } else { // 偶數為
            left.append(n.substring(0, len >> 1));
            right.append(n.substring(len >> 1));
            if (!isLeftReverseBiggerRight(left.toString(), right.toString())) {
                int num = Integer.parseInt(left.toString()) + 1;
                left.setLength(0);
                left.append(num);
            }
            res.append(left.toString());
            res.append(left.reverse().toString());
        }
        return res.toString();
    }

    static boolean isLeftReverseBiggerRight(String left, String right) { // 比較左邊翻轉后數字與右邊數字的大小關系
        StringBuilder sb = new StringBuilder(left);
        if (sb.reverse().toString().compareTo(right) > 0)
            return true;
        return false;
    }

    static String nextPalindromeUseFor(int num, boolean[] Palindrome) { // 求大於num的第一個回文數(最后的測試代碼使用)
        for (int i = num + 1; i < Palindrome.length; i++) {
            if (Palindrome[i] == true)
                return String.valueOf(i);
        }
        return null;
    }

    static boolean isPalindrome(int num) { // 判斷一個數字是不是回文數字(最后的測試代碼使用)
        String str = String.valueOf(num);
        int i = 0;
        int j = str.length() - 1;
        while (i < j) {
            if (str.charAt(i) != str.charAt(j))
                return false;
            i++;
            j--;
        }
        return true;
    }

    public static void main(String[] args) throws IOException {
        int n = 1000000; // 只測試[0,1000000)以內的結果
        boolean[] Palindrome = new boolean[n];    //默認為false
        for (int i = 0; i < n; i++) {
            if (isPalindrome(i))
                Palindrome[i] = true;    //如果是回文數字，標記為true。編譯下一步校驗，大於N的第一個回文數字
        }

        for (int i = 0; i < n; i++) {
            String val = firstBiggerPalindrome(String.valueOf(i));    //程序生成
            if (Integer.parseInt(val) < n) {    //如果在[0,1000000)內，進行校驗
                if (!val.equals(nextPalindromeUseFor(i, Palindrome)))
                    System.out.println("BAD\t" + i);
            }
        }
    }
}

通過代碼中的驗證程序，可以驗證算法的正確性，呵呵，nice!!!

 

Java編程小細節:

　　這個題目是字符串處理的，所以用了StringBuilder的reverse();注意一下

import java.io.*;

public class Solution {
    public static void main(String[] args) throws IOException {
        StringBuilder sb = new StringBuilder();
        sb.append("liuliuliu");
        System.out.println(sb.toString());
        sb.reverse();    //不需要返回值，也能翻轉，記住啊！！！
        System.out.println(sb.toString());
    }
}