[Swift]LeetCode564. 寻找最近的回文数 | Find the Closest Palindrome

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10420417.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

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:

1. The input n is a positive integer represented by string, whose length will not exceed 18.
2. If there is a tie, return the smaller one as answer.

---

给定一个整数 n ，你需要找到与它最近的回文数（不包括自身）。

“最近的”定义为两个整数差的绝对值最小。

示例 1:

输入: "123"
输出: "121"

注意:

1. n 是由字符串表示的正整数，其长度不超过18。
2. 如果有多个结果，返回最小的那个。

---

Runtime: 16 ms

Memory Usage: 20.3 MB

class Solution {
    func nearestPalindromic(_ n: String) -> String {
        var arr:[Character] = Array(n) 
        var i:Int = 0
        var j:Int = arr.count - 1
        while(i < j)
        {
            arr[j] = arr[i]
            i += 1
            j -= 1
        }
        var curP:String = String(arr)
        var preP:String = nearestPalindrom(curP, false)
        var nextP:String = nearestPalindrom(curP, true)
        
        var num:Int = Int(n)!
        var cur:Int = Int(curP)!
        var pre:Int = Int(preP)!
        var next:Int = Int(nextP)!    
        
        var d1:Int = abs(num - pre)
        var d2:Int = abs(num - cur)
        var d3:Int = abs(num - next)
        
        if num == cur
        {
            return d1 <= d3 ? preP : nextP
        }
        else if num > cur
        {
            return d2 <= d3 ? curP : nextP
        }
        else
        {
            return d1 <= d2 ? preP : curP
        }
    }
    
    func nearestPalindrom(_ curP:String,_ dir:Bool) -> String
    {
        var k:Int = curP.count >> 1
        var p:Int = curP.count - k
        var l:Int = Int(curP.subString(0, p))!
        l += (dir ? 1 : -1)
        
        if l == 0 
        {
            return k == 0 ? "0" : "9"
        }
        var left:String = String(l)
        var right:String = String(left.reversed())
        if k > left.count
        {
            right.append("9")
        }
        return left + right.subString(right.count - k)      
    }
}

extension String 
{
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
    
    // 截取字符串：从index到结束处
    // - Parameter index: 开始索引
    // - Returns: 子字符串
    func subString(_ index: Int) -> String {
        let theIndex = self.index(self.endIndex, offsetBy: index - self.count)
        return String(self[theIndex..<endIndex])
    }
}

---

24ms

class Solution {
    func nearestPalindromic(_ n: String) -> String {
        let smallArr = ["1":"0","2":"1","3":"2","4":"3","5":"4","6":"5","7":"6","8":"7","9":"8","10":"9","11":"9",]
        if let s = smallArr[n]{
            return s
        }
        var half = n.count/2
        var mid = 0
        if n.count % 2 == 1{
            half += 1
            mid = 1
        }
        let backHalf = n.count - half
        let a = Int(n.prefix(half)) ?? 1
        let b = Int(n.suffix(backHalf)) ?? 0
        var r1:Int = Int.max
        var r2:Int = Int.max
        var r3:Int = Int.max

        //退位的问题  遇到  10..0 || 10..1
        if a%10 == 0 && b <= 1{
            var res = ""
            for _ in 1..<n.count{
                res.append("9")
            }
            return res
        }

        //前位数-1
        if a % 10 != 0{
            if mid == 1{
                r1 = b + complement(reversed((a - 1) / 10),backHalf)
            }else{
                r1 = b + complement(reversed((a - 1)),backHalf)
            }
        }
        //不变
        if mid == 1{
            r2 = b - reversed(a/10)
        }else{
            r2 = b - reversed(a)
        }
        r2 = (r2 > 0) ? r2 : -r2

        var jinwei = false
        //前位数+1
        if !isTensTimes(a+1){//判断是否会进位
            if mid == 1{
                r3 = complement(b,backHalf) + reversed((a + 1)/10)
            }else{
                r3 = complement(b,backHalf) + reversed((a + 1))
            }
        }else{
            r3 = complement(b,backHalf) + 1
            jinwei = true
        }

        if r2 == 0{
            r2 = r2 == 0 ? Int.max : r2
        }

        var re = 1
        if r1 <= r2 && r1 <= r3{
            re = -1
        }else if r2 <= r3 && r2 <= r1{
            re = 0
        }

        //拿进位的结果
        if re == 1 && jinwei == true{
            var res = "1"
            for _ in 1..<n.count{
                res.append("0")
            }
            res.append("1")
            return res
        }


        let resultHead = a + re

        var resultBack = String(resultHead)
        if n.count % 2 == 1{
            resultBack = String(resultBack.prefix(resultBack.count-1))
        }
        resultBack = String(resultBack.reversed())
        return String(resultHead)+resultBack
    }

    func complement(_ num:Int,_ length:Int) -> Int {
        var big = 1
        for _ in 0..<length{
            big *= 10
        }
        return big - num
    }

    func reversed(_ num:Int) -> Int{
        var s = String(num)
        s = String(s.reversed())
        return Int(s)!
    }

    //是否是10的倍数
    func isTensTimes(_ num:Int) -> Bool{
        let s = String(num)
        let back = String(s.suffix(s.count-1))
        let newNum = Int(back)
        if newNum == 0{
            return true
        }
        return false
    }
}