[Swift]LeetCode438. 找到字符串中所有字母异位词 | Find All Anagrams in a String

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

Given a string s and a non-empty string p, find all the start indices of p's anagrams in s.

Strings consists of lowercase English letters only and the length of both strings s and pwill not be larger than 20,100.

The order of output does not matter.

Example 1:

Input:
s: "cbaebabacd" p: "abc"

Output:
[0, 6]

Explanation:
The substring with start index = 0 is "cba", which is an anagram of "abc".
The substring with start index = 6 is "bac", which is an anagram of "abc". 

Example 2:

Input:
s: "abab" p: "ab"

Output:
[0, 1, 2]

Explanation:
The substring with start index = 0 is "ab", which is an anagram of "ab".
The substring with start index = 1 is "ba", which is an anagram of "ab".
The substring with start index = 2 is "ab", which is an anagram of "ab".

---

给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。

字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。

说明：

• 字母异位词指字母相同，但排列不同的字符串。
• 不考虑答案输出的顺序。

示例 1:

输入:
s: "cbaebabacd" p: "abc"

输出:
[0, 6]

解释:
起始索引等于 0 的子串是 "cba", 它是 "abc" 的字母异位词。
起始索引等于 6 的子串是 "bac", 它是 "abc" 的字母异位词。

 示例 2:

输入:
s: "abab" p: "ab"

输出:
[0, 1, 2]

解释:
起始索引等于 0 的子串是 "ab", 它是 "ab" 的字母异位词。
起始索引等于 1 的子串是 "ba", 它是 "ab" 的字母异位词。
起始索引等于 2 的子串是 "ab", 它是 "ab" 的字母异位词。

---

56ms

class Solution {
    func findAnagrams(_ s: String, _ p: String) -> [Int] {
        let sCount = s.utf8.count
        let pCount = p.utf8.count
        guard sCount >= pCount else {
            return []
        }
        var a = 97
        var map = [Int](repeating: 0, count: 26)
        p.utf8.forEach({
            map[Int($0) - a] += 1
        })
        var sArray = Array(s.utf8)
        var left = 0
        var right = 0
        var count = 0 
        var res = [Int]()
        
        while right < sCount {
            let rightIndex = Int(sArray[right]) - a
            if map[rightIndex] > 0 {
                map[rightIndex] -= 1
                right += 1
                count += 1
            } else {
                let leftIndex = Int(sArray[left]) - a
                map[leftIndex] += 1
                left += 1
                count -= 1
            }
            if count == pCount {
                res.append(left)
            }
        }
        return res
    }
}

---

80ms

class Solution {
    func findAnagrams(_ s: String, _ p: String) -> [Int] {
        let s = s.map { letterIndex($0) }
        let p = p.map { letterIndex($0) }
        
        var ref = Array(repeating: 0, count: 26)
        for char in p {
            ref[char] += 1
        }
        
        var result = [Int]()
        var map = ref.map { _ in 0 }
        for i in 0..<s.count {
            map[s[i]] += 1
            if i - p.count >= 0 {
                map[s[i-p.count]] -= 1
            }

            if map == ref {
                result.append(i - p.count + 1)
            }
        }
        
        return result
    }
    
    func letterIndex(_ letter: Character) -> Int {
        return Int(letter.unicodeScalars.first!.value) - Int(Unicode.Scalar("a").value)
    }
}

---

84ms

class Solution {
    func findAnagrams(_ s: String, _ p: String) -> [Int] {
        if s.isEmpty {
            return []
        }
        var hash = Array(repeating: 0, count: 256)
        for letter in p {
            hash[letter.ascii] += 1
        }
        let s = [Character](s), p = [Character](p)
        var left = 0, right = 0, count = p.count
        var result = [Int]()
        
        while right < s.count {
            let index = s[right].ascii
            if hash[index] >= 1 {
                count -= 1
            }
            hash[index] -= 1
            right += 1
            
            if count == 0 {
                result.append(left)
            }
            
            if right - left == p.count {
                let leftIndex = s[left].ascii
                if hash[leftIndex] >= 0 {
                    count += 1
                }
                hash[leftIndex] += 1
                left += 1
            }
        }
        return result
    }
}

fileprivate extension Character {
    var ascii: Int {
        let utf8 = String(self).utf8
        return Int(utf8[utf8.startIndex])
    }
}

---

100ms

class Solution {
    func findAnagrams(_ s: String, _ p: String) -> [Int] {
        if s.count < p.count {
            return []
        }

        var s = Array(s)
        var i = 0, j = p.count - 1

        var pOcc = Array(repeating: 0, count: 26)
        var sOcc = Array(repeating: 0, count: 26)

        for char in p {
            pOcc[char.asciiValue - 97] += 1
        }

        for char in s.prefix(p.count) {
            sOcc[char.asciiValue - 97] += 1
        }

        var result = [Int]()
        while true {
            if isValidAnagram(pOcc, sOcc) {
                result.append(i)
            }

            i += 1
            j += 1
            if j >= s.count { break }

            sOcc[s[i - 1].asciiValue - 97] -= 1
            sOcc[s[j].asciiValue - 97] += 1
        }

        return result
    }

    func isValidAnagram(_ s: [Int], _ p: [Int]) -> Bool {
        return s == p
    }
}

extension Character {
    var asciiValue: Int {
        get {
            let s = String(self).unicodeScalars
            return Int(s[s.startIndex].value)
        }
    }
}

---

128ms

class Solution {
    func findAnagrams(_ s: String, _ p: String) -> [Int] {
        guard s.count > 0, s.count >= p.count else {
            return []
        }
        let sarr:[Character] = Array(s)
        let parr:[Character] = Array(p)
        var count = parr.count
        var result = Array<Int>()
        var map = Dictionary<Character, Int>()
        
        for p in parr {
            if map[p] == nil {
                map[p] = 0
            }
            map[p]! += 1
        }
        
        var left = 0
        var right = 0
        
        while right < sarr.count {
            if map[sarr[right]] == nil {
                map[sarr[right]] = 0
            }
            
            if map[sarr[right]]! > 0 {
                count -= 1
            }
            map[sarr[right]]! -= 1
            right += 1
            
            if count == 0 {
                result.append(left)
            }
            
            if right - left == parr.count {
                if map[sarr[left]] == nil {
                    map[sarr[left]] = 0
                }
                if map[sarr[left]]! >= 0 {
                    count += 1
                }
                map[sarr[left]]! += 1
                left += 1
            }            
        }        
        return result
    }    
}

---

132ms

class Solution {
    
    let charToIntMap: [Character: Int] = [
        "a": 0,
        "b": 1,
        "c": 2,
        "d": 3,
        "e": 4,
        "f": 5,
        "g": 6,
        "h": 7,
        "i": 8,
        "j": 9,
        "k": 10,
        "l": 11,
        "m": 12,
        "n": 13,
        "o": 14,
        "p": 15,
        "q": 16,
        "r": 17,
        "s": 18,
        "t": 19,
        "u": 20,
        "v": 21,
        "x": 22,
        "w": 23,
        "y": 24,
        "z": 25
    ]
    
    
    func findAnagrams(_ s: String, _ p: String) -> [Int] {
        guard s.count >= p.count else { return [Int]() }
        var i = 0
        var j = 0
        let sArr = Array(s)
        let pArr = Array(p)
        
        var pInt = Array<Int>(repeating: 0, count: 26)
        var ans = [Int]()
        
        for ch in pArr {
            pInt[charToIntMap[ch]!] = pInt[charToIntMap[ch]!] + 1
        }
        var movingInt = Array<Int>(repeating: 0, count: 26)
        while i < sArr.count && j < pArr.count {
            let ch = sArr[i]
            movingInt[charToIntMap[ch]!] = movingInt[charToIntMap[ch]!] + 1 
            i += 1
            j += 1
        }
        if movingInt == pInt {
            ans.append(0)
        }
        while i < sArr.count {
            let ch = sArr[i]
            let prevCh = sArr[i - j]
            movingInt[charToIntMap[ch]!] = movingInt[charToIntMap[ch]!] + 1 
            movingInt[charToIntMap[prevCh]!] = movingInt[charToIntMap[prevCh]!] - 1 
            if movingInt == pInt {
                ans.append(i - j + 1)
            }
            i += 1
        }
        return ans
    }
}

---

164ms

class Solution {
    func findAnagrams(_ s: String, _ p: String) -> [Int] {
        guard s.count >= p.count else { return [] }
        let sChars = Array(s.characters.map { String($0).uppercased() })
        let pChars = Array(p.characters.map { String($0).uppercased() })
        var result = [Int]()
        var pCount = Array(repeating: 0, count: 26)
        var windowCount = Array(repeating: 0, count: 26)
        
        for i in 0..<pChars.count {
            pCount[Int(UnicodeScalar(pChars[i])!.value) - Int(UnicodeScalar("A")!.value)] += 1
            windowCount[Int(UnicodeScalar(sChars[i])!.value) - Int(UnicodeScalar("A")!.value)] += 1
        }
        
        for i in pChars.count..<sChars.count {
            if compareArrays(pCount, windowCount) { result.append(i - pChars.count) }
            
            windowCount[Int(UnicodeScalar(sChars[i - pChars.count])!.value) - Int(UnicodeScalar("A")!.value)] -= 1
            windowCount[Int(UnicodeScalar(sChars[i])!.value) - Int(UnicodeScalar("A")!.value)] += 1
        }
        
        if compareArrays(pCount, windowCount) { result.append(sChars.count - pChars.count) }
        
        return result
    }
    
    func compareArrays(_ a: [Int], _ b: [Int]) -> Bool {
        guard a.count == b.count else { return false }
        for i in 0..<a.count {
            if a[i] != b[i] { return false }
        }
        return true
    }
}

---

Runtime: 1776 ms

Memory Usage: 20.5 MB

class Solution {
    func findAnagrams(_ s: String, _ p: String) -> [Int] {
        if s.isEmpty || p.count > s.count {return []}
        var res:[Int] = [Int]()
        var m1:[Int] = [Int](repeating:0,count:256)
        var m2:[Int] = [Int](repeating:0,count:256)
        var arrS = Array(s).map{$0.ascii}
        var arrP = Array(p).map{$0.ascii}
        for i in 0..<p.count
        {
            m1[arrS[i]] += 1
            m2[arrP[i]] += 1
        }
        if m1 == m2
        {
            res.append(0)
        }
        for i in p.count..<s.count
        {
            m1[arrS[i]] += 1
            m1[arrS[i - p.count]] -= 1
            if m1 == m2
            {
                res.append(i - p.count + 1)
            }
        }
        return res
    }
}

extension Character  
{  
  //属性：ASCII整数值(定义小写为整数值)
   var ascii: Int {
        get {
            let s = String(self).unicodeScalars
            return Int(s[s.startIndex].value)
        }
    }
}