564. Find the Closest Palindrome

Description

Given an integer n, find the closest integer (not including itself), which is a palindrome.

The ‘closest’ is defined as absolute difference minimized between two integers.

Example 1:
Input: “123”
Output: “121”
Note:
The input n is a positive integer represented by string, whose length will not exceed 18.
If there is a tie, return the smaller one as answer.

Problem URL

Solution

给一个string表示回文数，找到最接近它的非自身回文数。

We use two helper to find a bigger palindrome and a smaller palindrome. Then return the one with smaller absolute difference.

To find higher, we conver string to long, then from long to string and to char array. Make target a palindrome first. Then compare each digit, it target is smaller, make it bigger from the middle j = (m - 1) /2. If out of ‘9’, become ‘0’; After that, make it palindrome again and return it.

For finding a smaller one, same as find higher one. But when chagnged target, if the leading digit is ‘0’, new a new char[] which is filled with ‘9’ and return it for special case.

Code

class Solution {
    public String nearestPalindromic(String n) {
        long num = Long.parseLong(n);
        long higher = findHigherPalindrom(num + 1);
        long lower = findLowerPalindrom(num - 1);
        return Math.abs(num - lower) > Math.abs(higher - num) ? String.valueOf(higher) : String.valueOf(lower);
    }
    
    private long findHigherPalindrom(long limit){
        String n = Long.toString(limit);
        char[] origin = n.toCharArray();
        int len = origin.length;
        char[] target = Arrays.copyOf(origin, len);
        
        for (int i = 0; i < len / 2; i++){
            target[len - 1 - i] = target[i];
        }
        for (int i = 0; i < len; i++){
            if (origin[i] < target[i]){
                return Long.parseLong(String.valueOf(target));
            }
            else if (origin[i] > target[i]){
                for (int j = (len - 1) / 2; j >= 0; j--){
                    if (++target[j] > '9'){
                        target[j] = '0';
                    }
                    else{
                        break;
                    }
                }
                for (int k = 0; k < len / 2; k++){
                    target[len - 1 - k] = target[k];
                }
                return Long.parseLong(String.valueOf(target));
            }
        }
        return Long.parseLong(String.valueOf(target));
    }
    
    private long findLowerPalindrom(long limit){
        String n = Long.toString(limit);
        char[] origin = n.toCharArray();
        int len = origin.length;
        char[] target = Arrays.copyOf(origin, len);
        
        for (int i = 0; i < len / 2; i++){
            target[len - 1 - i] = target[i];
        }
        for (int i = 0; i < len; i++){
            if (origin[i] > target[i]){
                return Long.parseLong(String.valueOf(target));
            }
            else if (origin[i] < target[i]){
                for (int j = (len - 1) / 2; j >= 0; j--){
                    if (--target[j] < '0'){
                        target[j] = '9';
                    }
                    else{
                        break;
                    }
                }
                if (target[0] == '0'){
                    char[] special = new char[len - 1];
                    Arrays.fill(special, '9');
                    return Long.parseLong(String.valueOf(special));
                }
                for (int k = 0; k < len / 2; k++){
                    target[len - 1 - k] = target[k];
                }
                return Long.parseLong(String.valueOf(target));
            }
        }
        return Long.parseLong(String.valueOf(target));
    }
}

Time Complexity: unknow
Space Complexity: unknow

Review

无语的题目