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 {
            
            perf += 1
            
            if let c = cache[range] {
                hitCache += 1
                return c
            }
            
            if range.count == 1 {
                cache[range] = s.from(range: range)
                return s.from(range: range)
            }
            
            if !range.isEven {
                let left = longest(range: Range(start: range.start, end: range.midIndex))
                let right = longest(range: Range(start: range.midIndex, end: range.end))
                
                if left == right {
                    
                    if left == "" || right == "" {
                        cache[range] = ""
                    } else {
                        let str = s.from(range: range)
                        cache[range] = str
                        return str
                    }
                }
                
            } else {
                let left = longest(range: Range(start: range.start, end: range.midIndex))
                let right = longest(range: Range(start: range.midIndex + 1, end: range.end))
                
                if left == right {
                    
                    if left == "" || right == "" {
                        cache[range] = ""
                    } else {
                        let str = s.from(range: range)
                        cache[range] = str
                        return str
                    }
                }
            }
            
            func expand(range: Range) -> String {
                
                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 = ""
                var right = ""
                
                var fullyExpanded = false
                
                while rightIndex <= range.end && leftIndex >= range.start {
                    
                    perf2 += 1
                    
                    
                    
                    left = s.safeStr(i: leftIndex)
                    right = s.safeStr(i: rightIndex)
                    
                    if left == right {
                        let currRange = Range(start: leftIndex, end: rightIndex)
                        let str = s.from(range: currRange)
                        cache[currRange] = str
                        
                        if leftIndex == range.start && rightIndex == range.end {
                            fullyExpanded = true
                        }
                    } else {
                        break
                    }
                    
                    leftIndex -= 1
                    rightIndex += 1
                }
                
                if fullyExpanded {
                    return s.from(range: range)
                } else {
                    return ""
                }
            }
            
            let r = expand(range: range)
            
            cache[range] = r
            
            return r
        }
        
        
        
        
        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
    }
}