摘要：給定一個整數，你需要找到與它最近的回文數不包括自身。最近的定義為兩個整數差的絕對值最小。示例輸入輸出注意是由字符串表示的正整數，其長度不超過。如果有多個結果，返回最小的那個。

給定一個整數 n ，你需要找到與它最近的回文數（不包括自身）。

“最近的”定義為兩個整數差的絕對值最小。

示例 1:

輸入: "123"
輸出: "121"
注意:

n 是由字符串表示的正整數，其長度不超過18。
如果有多個結果，返回最小的那個。

基礎思路：

n的中間位，如果n為奇數，中間位是 n .length/ 2 - 0.5；如果為偶數，其實是沒有中間位，但是在實際修改時，中間位是 2個： n .length/ 2和 n.length/ 2 - 1

n的幾種可能性 和 基本結果

問題：

n的長度 <= 18, 而js不支持這么大位數的計算

解決：

除了n不是回文數且不是10的n次冪的情況都用字符串做判斷

n不是回文數且不是10的n次冪的情況下， 因為只有n的后半部分做了改變，所以只需要 

Math.floor(n.length/2  )位數 加減。但還需要考慮otherX的情況，otherX 可能會是 

x加或者減 10的 Math.floor(n.length/2  )次冪，所以最后計算位數為  Math.floor(n.length/2  ) + 1

代碼（很挫而且很～～～～～大一坨，還沒有注釋，也沒做過優化，還是js版）

/**

@param {string} n

@return {string}

*/

var nearestPalindromic = function(n) {
    if( n.length === 1 ){
        return (parseInt( n ) - 1).toString()
    }
    let len = n.length
    let isOdd =  len % 2 === 0 ? false : true
    let c = Math.floor(len / 2)
    
    let s1 = n.slice(0 , (len % 2 === 0 ? len /2  : len / 2 - 0.5));
    let s2 = n.slice( len % 2 === 0 ? len /2 : len / 2 + 0.5 )
    let s1R = s1.split("").reverse().join("")
    let s2R = s2.split("").reverse().join("")
    
    let same = true
    let isZero = true
    let isNine= true
    
    for( let i = 1 ; i < n.length ; i++){
        if(n[i-1] !== n[i]) same = false
        if( i !== n.length - 1 && n[i] !== "0"){
            isZero = false
        }
        if( n[i] != 9){
            
            isNine= false
        }
    }
    if( (n[0] === "1" && n[n.length - 1] === "1" && isZero) ||(n[0] === "1" && n[n.length - 1] === "0" && isZero) ){
        
        let str = ""
        for( let i = 0 ; i < n.length-1 ; i++){
            str += "9"
        }
        return str
    }
    if( same && n[0] === "9"){
        let str = "1"
        for( let i = 0 ; i < n.length - 1 ; i++){
            str += "0"
        }
        return str + "1"
    }
    if( isNine ){
        let str = 1 + n[0] * 1
        for( let i = 0 ; i < n.length - 2 ; i++){
            str += "0"
        }
        return str + ( 1 + n[0] * 1)
    }
    if( s1 === s2R ){
        let s = n
        if( n[c] === "0"){
            if( isOdd ){
                s = s1 + "1" + s2
            }else{
                s = s1.slice(0, -1) + 1 + 1 + s2.slice(1)
            }
        }else if(n[c] === "9"){
            let nowL = (s1 * 1 + 1).toString()
            let nowR = nowL.split("").reverse().join("")
            if(isOdd){
                if( n[c-1] !== "9"){
                    return s = s1 + (n[c] - 1) + s2
                }
                return nowL + 0 + nowR 
            }
            return nowL + nowR 

            
        }else{
            if( isOdd ){
                s = s1 + (n[c] - 1) + s2
            }else{
                s = s1.slice(0, -1) + (n[c] - 1)+ (n[c] - 1) + s2.slice(1)
            }
        }
        return s
    }else{
        let now = parseInt(n[isOdd ? c : c -1 ] + s1R)
        let old = parseInt(n[isOdd ? c : c -1 ] + s2)
        let otherNow = 0
        let num = Math.pow(10, c)
        if( !isOdd ){
            num +=  (c - 1 === 0 ? 1 : Math.pow( 10, c - 1))
        }
        if(now > old){
            otherNow = now - num
        }else{
            otherNow = now + num
        }
        let otherNowS = otherNow, nowS = now

        let zeroO =  Math.floor(len / 2) + 1 - otherNow.toString().length
        let zeroN = Math.floor(len / 2) + 1 - now.toString().length

        for( let i = 0 ; i < zeroO ; i++){
            otherNowS = "0" + otherNow
        }
        for( let i = 0 ; i < zeroN ; i++){
            nowS = "0" + nowS
        }

        if(Math.abs(old - now) > Math.abs(old - otherNow)){
            
            return isOdd ? s1 + otherNowS : s1.slice(0, -1) + otherNowS
        }else if (Math.abs(old - now)  ===  Math.abs(old - otherNow)){
            let rNow = otherNow > now ? nowS : otherNowS
            return isOdd ? s1 + rNow : s1.slice(0, -1) + rNow
        }else{
            return isOdd ? s1 + nowS : s1.slice(0, -1) + nowS
        }
    }
    
    
    
        
};

結尾吐槽：

這道題現在在leetcode上，等級為困難，通過率7.7%，但感覺好多簡單里的題都比它難。

再一個感覺自己這篇博客也沒寫明白啊，要是我看到這種東西肯定就罵街了，得再思考著改改嗚嗚嗚