1 class Solution {
 2     func longestDecomposition(_ text: String) -> Int {
 3         var result = 0
 4         var chars = Array(text)
 5         var n = text.count
 6         var l = ""
 7         var r = ""
 8         for i in 0..<n {
 9             l += String(chars[i])
10             r = String(chars[n-i-1]) + r
11             if l == r {
12                 result += 1
13                 l = ""
14                 r = ""
15             }
16         }
17         return result
18     }
19 }

 1 class Solution {
 2     func longestDecomposition(_ text: String) -> Int {
 3         let n:Int = text.count
 4         for i in 0..<(n/2)
 5         {
 6             if text.subString(0, i + 1) == (text.subString(n - 1 - i, n))
 7             {
 8                 return 2 + longestDecomposition(text.subString(i + 1, n - 1 - i))
 9             }
10         }
11         return (n == 0) ? 0 : 1
12     }
13 }
14 extension String {
15     // 截取字符串：指定索引和字符数
16     // - star: 开始索引
17     // - end: 结束索引
18     func subString(_ start:Int,_ end:Int) -> String {
19         let start = self.index(self.startIndex, offsetBy: start)
20         let end = self.index(self.startIndex, offsetBy: end)
21         return String(self[start..<end])
22     }
23 }

 1 class Solution {
 2     func longestDecomposition(_ text: String) -> Int {
 3         let chars = Array(text)
 4         var l = chars.startIndex
 5         var r = chars.endIndex - 1
 6         let mid = (l + r + 1) / 2
 7         var ans = 0
 8
 9         while l < r {
10             let range = 0..<mid-l
11             var next  = range.upperBound
12             for i in range where chars[l...l+i] == chars[r-i...r] {
13                 next = i + 1
14                 ans += 2
15                 if l + i + 1 == r - i {
16                     return ans
17                 }else{
18                     break
19                 }
20             }
21             l += next
22             r -= next
23         }
24         return ans + 1
25     }
26 }

 1 class Solution {
 2     func longestDecomposition(_ text: String) -> Int {
 3         let s = Array(text)
 4         var result = 0
 5
 6         let end = s.endIndex - 1
 7         var i = s.startIndex
 8         var j = s.startIndex
 9
10         //ghiabcdefhelloadamhelloabcdefghi
11         while i <= end{
12             while j <= end {
13                 let range1 = i...(i+j)
14                 let range2 = (end-i-j)...(end-i)
15                 j += 1
16                 guard s[range1] == s[range2] else { continue }
17                 result += 1
18                 break
19             }
20
21             i += j
22             j = 0
23         }
24         return result
25     }
26 }