gistfile1.txt

class Solution {
    
    var perf = 0
    var perf2 = 0
    
    var hitCache = 0
    
    func longestPalindrome(_ s: String) -> String {
        
        var cache = [Range: String]()
        
        func longest(range: Range) -> String {
            
            if range.count == 1 {
                return s.from(range: range)
            }
            
            if let c = cache[range] {
                hitCache += 1
                return c
            }
            
            if range.start < 0 || range.end > s.count - 1 || range.end < 0 {
                return ""
            }
            
            var leftIndex: Int
            var rightIndex: Int
            
            if range.isEven {
                leftIndex = range.midIndex
                rightIndex = range.midIndex + 1
            } else {
                leftIndex = range.midIndex
                rightIndex = range.midIndex
            }
            
            var left = s.safeStr(i: leftIndex)
            var right = s.safeStr(i: rightIndex)
            
            
            while left == right && range.start >= 0 && range.end < s.count - 1 {
                
                perf += 1
                
                left = s.safeStr(i: leftIndex)
                right = s.safeStr(i: rightIndex)
                
                let currRange = Range(start: leftIndex, end: rightIndex)
                let currStr = s.from(range: currRange)
                cache[currRange] = currStr
                
                if rightIndex + 1 > range.end || leftIndex - 1 < range.start {
                    return s.from(range: range)
                }
                
                let leftRange = longest(range: Range(start: range.start, end: leftIndex - 1))
                let rightRange = longest(range: Range(start: rightIndex + 1, end: range.end))
                
                if leftRange == rightRange {
                    
                    if leftRange != "" && rightRange != "" {
                        let str = leftRange + currStr + rightRange
                        cache[range] = str
                        return str
                    }
                }
                
                leftIndex -= 1
                rightIndex += 1
            }
            
            cache[range] = ""
            return ""
        }
            
        
        for i in 0..<s.count {
            let range = Range(start: 0, end: i)
            let p = longest(range: range)
            cache[range] = p
        }
        
        for i in 0..<s.count {
            let range = Range(start: i, end: s.count - 1)
            let p = longest(range: range)
            cache[range] = p
        }
        
        
        
        let final = cache.reduce("") { a,b in
            return b.value.count > a.count ? b.value : a
        }
        
        return final
    }
}