1 class Solution {
 2     func camelMatch(_ queries: [String], _ pattern: String) -> [Bool] {
 3         var ans:[Bool] = [Bool]()
 4         for q in queries
 5         {
 6             ans.append(go(q,pattern))
 7         }
 8         return ans
 9     }
10
11     func go(_ q:String,_ p:String) -> Bool
12     {
13         var pos:Int = 0
14         var arrP:[Character] = Array(p)
15         for c in q
16         {
17             if pos < p.count && c == arrP[pos]
18             {
19                 pos += 1
20             }
21             else if c < "a" || c > "z"
22             {
23                 return false
24             }
25         }
26         return pos == p.count
27     }
28 }

 1 import Foundation
 2
 3 class Solution {
 4     func camelMatch(_ queries: [String], _ pattern: String) -> [Bool] {
 5         var result = [Bool]()
 6         let pattern = Array(pattern)
 7         for q in queries {
 8             result.append(check(Array(q), pattern))
 9         }
10         return result
11     }
12
13     func check(_ q: [Character], _ p: [Character]) -> Bool {
14         if p.count > q.count { return false }
15         var pIndex = 0
16         for i in 0..<q.count {
17             if pIndex > p.count - 1 {
18                 if isUpperCase(q[i]) { return false }
19             } else {
20                 if q[i] == p[pIndex] {
21                     pIndex += 1
22                 } else {
23                     if isUpperCase(q[i]) { return false }
24                 }
25             }
26         }
27         return pIndex == p.count
28     }
29
30     func isUpperCase(_ c: Character) -> Bool {
31         let tmd = String(c).unicodeScalars.first!
32         return CharacterSet.uppercaseLetters.contains(tmd)
33     }
34 }

 1 class Solution {
 2     func camelMatch(_ queries: [String], _ pattern: String) -> [Bool] {
 3         var result = [Bool]()
 4         for query in queries {
 5             result.append(isSubsequnce(pattern, query))
 6         }
 7         return result
 8     }
 9
10     fileprivate func isSubsequnce(_ pattern: String, _ word: String) -> Bool {
11         guard pattern.count <= word.count else {
12             return false
13         }
14         var index1 = 0, index2 = 0
15         let chars1 = Array(pattern)
16         let chars2 = Array(word)
17
18         let capitals1 = chars1.filter { String($0).uppercased() == String($0) }
19         let capitals2 = chars2.filter { String($0).uppercased() == String($0) }
20         guard capitals1 == capitals2 else {
21             return false
22         }
23
24         while index1 < chars1.count && index2 < chars2.count {
25             if chars1[index1] == chars2[index2] {
26                 index1 += 1
27                 index2 += 1
28             } else {
29                 index2 += 1
30             }
31         }
32         return (index1 == chars1.count && index2 == chars2.count) || index1 == chars1.count
33     }
34 }