[Swift]LeetCode567. 字符串的排列 | Permutation in String

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

Given two strings s1 and s2, write a function to return true if s2 contains the permutation of s1. In other words, one of the first string's permutations is the substring of the second string.

Example 1:

Input:s1 = "ab" s2 = "eidbaooo"
Output:True
Explanation: s2 contains one permutation of s1 ("ba"). 

Example 2:

Input:s1= "ab" s2 = "eidboaoo"
Output: False 

Note:

1. The input strings only contain lower case letters.
2. The length of both given strings is in range [1, 10,000].

---

给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的排列。

换句话说，第一个字符串的排列之一是第二个字符串的子串。

示例1:

输入: s1 = "ab" s2 = "eidbaooo"
输出: True
解释: s2 包含 s1 的排列之一 ("ba"). 

示例2:

输入: s1= "ab" s2 = "eidboaoo"
输出: False 

注意：

1. 输入的字符串只包含小写字母
2. 两个字符串的长度都在 [1, 10,000] 之间

---

36ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        guard s1.count <= s2.count else {
            return false
        }
        
        func allZero(_ counts: [Int]) -> Bool {
            for i in 0 ..< 26 {
                if counts[i] != 0 {
                    return false
                }
            }
            return true
        }
        
        let chars1 = Array(s1.unicodeScalars)
        let chars2 = Array(s2.unicodeScalars)
        let len1 = chars1.count
        let len2 = chars2.count
        var counts = [Int](repeatElement(0, count: 26))
        
        for i in 0 ..< len1 {
            counts[Int(chars1[i].value - 97)] += 1
            counts[Int(chars2[i].value - 97)] -= 1
        }
        
        if allZero(counts) { return true }
        
        for i in len1 ..< len2 {
            counts[Int(chars2[i].value - 97)] -= 1
            counts[Int(chars2[i - len1].value - 97)] += 1
            if allZero(counts) { return true }
        }
        
        return false
    }
}

---

48ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        
        var s1Array = Array(s1.characters)
        var s2Array = Array(s2.characters)
        
        if s1Array.count > s2Array.count {
            return false 
        }

        var array1 = Array(repeating:0,count:26)     
        
        var array2 = Array(repeating:0,count:26)
        
        for i in 0 ..< s1Array.count {
            let index1 = Int(s1Array[i].unicodeScalars.first!.value) - 97 
            let index2 = Int(s2Array[i].unicodeScalars.first!.value) - 97 
            
            array1[index1] += 1
            array2[index2] += 1 
        }
        
        var end = s1Array.count - 1  
        var start = 0 
        while end < s2Array.count{
            
              if isMatch(array1,array2){
                  return true
              }else{
                  
                  let index = Int(s2Array[start].unicodeScalars.first!.value) - 97 
                  array2[index] -= 1 
                  start += 1 
                  
                  end += 1 
                  if end < s2Array.count {
                      let index2 = Int(s2Array[end].unicodeScalars.first!.value) - 97 
                      array2[index2] += 1 
                  }
              }
        }
        
        return false 
        
    }
    
    func isMatch(_ array1:[Int], _ array2:[Int]) -> Bool{
        for i in 0 ..< array1.count {
            if array1[i] != array2[i]{
                return false 
            }
        }
        return true
    }
}

---

52ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        var s1 = Array(s1)
        var s2 = Array(s2)
        let len1 = s1.count
        let len2 = s2.count
        if len1 > len2 { return false }
        let base = Character("a").asciiValue
        var count = Array(repeating: 0, count: 26)
        
        for i in 0..<len1 {
            count[s1[i].asciiValue - base] += 1
            count[s2[i].asciiValue - base] -= 1
        }
        
        if isAllZero(count) { return true }
        
        for i in len1..<len2 {
            count[s2[i].asciiValue - base] -= 1
            count[s2[i-len1].asciiValue - base] += 1
            if isAllZero(count) { return true }
        }
        return false
    }
    
    func isAllZero(_ arr: [Int]) -> Bool {
        for num in arr {
            if num != 0 { return false }
        }
        return true
    }
}

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

---

Runtime: 56 ms

Memory Usage: 19.2 MB

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        var arr1:[Character] = Array(s1)
        var arr2:[Character] = Array(s2)
        var n1:Int = s1.count
        var n2:Int = s2.count
        var cnt:Int = n1
        var left:Int = 0
        var m:[Int] = [Int](repeating:0,count:128)
        for c in arr1
        {
            m[c.ascii] += 1
        }
        for right in 0..<n2
        {            
            if m[arr2[right].ascii] > 0
            {
                cnt -= 1
            }
            m[arr2[right].ascii] -= 1
            while(cnt == 0)
            {
                if right - left + 1 == n1 
                {
                    return true
                }
                 m[arr2[left].ascii] += 1
                if m[arr2[left].ascii] > 0
                {
                    cnt += 1
                }
                left += 1
            }            
        }
        return false
    }
}

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

---

72ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        
        // if s1 permutation is in s2
        
        let string1 = Array(s1)
        let string2 = Array(s2)
        
        let originalCharacterToCount = string1.reduce(into: [:], { $0[$1, default: 0] += 1 })
        
        var currentCharacterToCount: [Character:Int] = [:]
        var startIndex = 0
        
        for endIndex in 0..<string2.count {
            
            let character = string2[endIndex]
            
            guard let originalCount = originalCharacterToCount[character] else {
                // if this character doesn't exist, then we have to start searching for a new one
                currentCharacterToCount = [:]
                startIndex = endIndex+1
                continue
            }
            
            currentCharacterToCount[character, default: 0] += 1
            
            while let currentCount = currentCharacterToCount[character], currentCount > originalCount {
                // we can't have TOO many characters - it must match the substring
                //
                // the guard statment already ensures that we have the RIGHT characters
                //
                // now we have to worry about the COUNT of the characters
                let startCharacter = string2[startIndex]
                currentCharacterToCount[startCharacter, default: 0] -= 1
                startIndex += 1
            }
            
            if (endIndex - startIndex + 1) == string1.count {
                return true
            }
        }
        
        return false
    }
}

---

76ms

class Solution {

    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        
        let string1Count = s1.count
        let string2 = Array(s2)
        
        let originalCharacterToCount = s1.reduce(
            into: [:], 
            { $0[$1, default: 0] += 1 })
        
        var startIndex = 0
        var currentCharacterToCount: [Character:Int] = [:]
        
        for endIndex in 0..<string2.count {
            let character = string2[endIndex]
            
            guard let originalCount = originalCharacterToCount[character] else {
                // reset
                startIndex = endIndex+1
                currentCharacterToCount = [:]
                continue
            }
            
            // count
            currentCharacterToCount[character, default: 0] += 1
            
            // adjust startIndex in case we over-counted
            while let currentCount = currentCharacterToCount[character], currentCount > originalCount {
                let startCharacter = string2[startIndex]
                startIndex += 1
                currentCharacterToCount[startCharacter, default: 1] -= 1
            }
            
            // we don't need character count, we can just use startIndex - endIndex
            if (endIndex-startIndex+1) == string1Count {
                return true
            }
        }
        
        return false
    }
}

---

80ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        if s1.characters.count > s2.characters.count {
            return false
        }
        
        let chars1 = Array(s1.characters)
        let chars2 = Array(s2.characters)
        let len1 = chars1.count
        let len2 = chars2.count
        var counts = [Int](repeatElement(0, count: 256))
        
        for i in 0..<len1 {
            counts[Int((chars1[i].unicodeScalars.first?.value)!)] += 1
            counts[Int((chars2[i].unicodeScalars.first?.value)!)] -= 1
        }
        if allZero(counts) {
            return true
        }
        for i in len1..<len2 {
            counts[Int((chars2[i].unicodeScalars.first?.value)!)] -= 1
            counts[Int((chars2[i - len1].unicodeScalars.first?.value)!)] += 1
            if allZero(counts) {
                return true
            }
        }
        
        return false
    }
    
    private func allZero(_ counts: [Int]) -> Bool {
        for i in 0..<256 {
            if counts[i] != 0 {
                return false
            }
        }
        return true
    }    
}

---

84ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        let s1Lower = LowerCaseString(s1)
        let s2Lower = LowerCaseString(s2)

        let s1Counts = LowerCaseCounter(from: s1Lower).counts
        guard let s2Counter = LowerCaseCounter(from: s2Lower,
                                               using: s1Lower.data.count) else {
            return false
        }
        
        if s1Counts == s2Counter.counts { return true }
        
        while let s2Counts = s2Counter.step() {
            if s1Counts == s2Counts { return true }
        }

        return false
    }
}

func unicode(_ c: Character) -> Int {
     return Int(c.unicodeScalars.first!.value)
}

enum LowerCase: Int {
    case a = 97
    case b
    case c
    case d
    case e
    case f
    case g
    case h
    case i
    case j
    case k
    case l
    case m
    case n
    case o
    case p
    case q
    case r
    case s
    case t
    case u
    case v
    case w
    case x
    case y
    case z
}

struct LowerCaseString {
    private(set) var data: [LowerCase]
    
    init(_ s: String) {
        data = []
        data.reserveCapacity(s.count)
        for c in s {
            let u = unicode(c)
            guard let e = LowerCase(rawValue: u) else { continue }
            data.append(e)
        }
    }
}


class LowerCaseCounter {
    private static var len = 1 + LowerCase.z.rawValue - LowerCase.a.rawValue
    private(set) var counts: [Int] = Array(repeating: 0, count: Int(len))
    
    private var start: IndexingIterator<[LowerCase]>
    private var end: IndexingIterator<[LowerCase]>
    
    init(from s: LowerCaseString) {
        start = s.data.makeIterator()
        end = s.data.makeIterator()
        while let on = end.next() {
            let i = on.rawValue - LowerCase.a.rawValue
            counts[i] = counts[i] + 1
        }
    }
    
    init?(from s: LowerCaseString, using n: Int) {
        start = s.data.makeIterator()
        end = s.data.makeIterator()
        for _ in 0..<n {
            guard let on = end.next() else { return nil }
            let i = on.rawValue - LowerCase.a.rawValue
            counts[i] = counts[i] + 1
        }
    }
    
    func step() -> [Int]? {
        guard let on = end.next() else { return nil }
        guard let off = start.next() else { return nil }
        
        let i = on.rawValue - LowerCase.a.rawValue
        let j = off.rawValue - LowerCase.a.rawValue
        
        counts[i] = counts[i] + 1
        counts[j] = max(counts[j] - 1, 0)

        return counts
    }
}

---

92ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        
        let a1 = Array(s1).map { String($0) }
        let len = a1.count
        let a2 = Array(s2).map { String($0) }
        if a2.count < len { return false }
        var hashA = [String:Int]()
        for s in a1 {
            if let old = hashA[s] {
                hashA[s] = old+1
            } else {
                hashA[s] = 1
            }
        }
        
        
        var hashB = [String:Int]()
        
        var i = 0
        while i<len{
            let s = a2[i]
            if let old = hashB[s] {
                hashB[s] = old+1
            } else {
                hashB[s] = 1
            }
            i+=1
        }
        var runnerHashB = hashB
        
        if runnerHashB == hashA {
            return true
        }
        var j = 0
        
        while j < (a2.count - len) {
            
            if let old = runnerHashB[a2[j]] {
                if old == 1 {
                    runnerHashB[a2[j]] = nil
                } else {
                    runnerHashB[a2[j]] = old - 1
                }
                
            }
            
            if let old1 = runnerHashB[a2[j+len]] {
                runnerHashB[a2[j+len]] = old1 + 1
            } else {
                runnerHashB[a2[j+len]] = 1
            }
            if runnerHashB == hashA {
                return true
            }
            j+=1
        }
        return false
    }
}

---

100ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        
        if s1.count > s2.count { return false }
        
        var dict1 = [Character: Int]()
        var dict2 = dict1
        s1.forEach {
            dict1[$0] = (dict1[$0] ?? 0) + 1
        }
        
        
        let s2 = Array(s2)
        let n = s1.count
        for i in 0..<s2.count {
            dict2[s2[i]] = (dict2[s2[i]] ?? 0) + 1
            if i >= n {
                let count = dict2[s2[i - n]]!
                dict2[s2[i - n]] = count == 1 ? nil : count - 1
            }
            if dict2 == dict1 {
                return true
            }
        }
        
        return false
    }
}

---

104ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        guard !s1.isEmpty && !s2.isEmpty && s2.count >= s1.count else {
            return false
        }
        
        var map: [Character: Int] = [:]
        for char in s1 {
            if let count = map[char] {
                map[char] = count + 1
            } else {
                map[char] = 1
            }
        }
        
        let chars = Array(s2)
        var temp = map
        var left = 0
        for (index, char) in chars.enumerated() {
            if let count = temp[char] {
                if count > 0 {
                    let newCount = count - 1
                    temp[char] = newCount
                    if newCount == 0 {
                        let empty = temp.contains { $0.value > 0 }
                        if !empty {
                            return true
                        }
                    }
                } else {
                    if chars[left] == char {
                        left += 1
                    } else {
                        var index2 = left
                        while true {
                            let char2 = chars[index2]
                            if char2 != char {
                                temp[char2] = temp[char2]! + 1
                            } else {
                                left = index2 + 1
                                break
                            }
                            index2 += 1
                        }
                    }
                }
            } else {
                temp = map
                left = index + 1
            }
        }
        
        return false
    }
}

---

148ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        
        if s1 == "" {
            return true
        }

        var hash = [Character: Int]()
        
        for ch in s1 {
            hash[ch] = hash[ch, default: 0] - 1
        }
        
        var count = hash.count 
       
        var frt = 0
        var chArr = Array(s2)
        for (i, ch) in s2.enumerated() {
            hash[ch] = hash[ch, default: 0] + 1
            if hash[ch] == 0 {
                hash[ch] = nil
                count -= 1
            }
            
            if count == 0 {
                while frt < i {
                    var f = chArr[frt]
                    if let val = hash[f] {
                        hash[f] = hash[f]! - 1
                        if hash[f] == 0 {
                            hash[f] = nil
                        }
                        frt += 1
                    } else {
                        break
                    }
                }
            }
            
            if hash.count == 0 {
                return true
            }
        }
        return false    
    }
}

---

232ms

class Solution {
    func checkInclusion(_ s1: String, _ s2: String) -> Bool {
        let len1 = s1.count 
        let len2 = s2.count
        
        guard len1 <= len2 else { return false }
        
        var countDict = [Character: Int]()
        
        var s1 = Array(s1)
        var s2 = Array(s2)
        
        for i in 0..<len1 {
            if let value = countDict[s1[i]] {
                countDict[s1[i]] = value + 1
            } else {
                countDict[s1[i]] = 1
            }
            
            if let value = countDict[s2[i]] {
                countDict[s2[i]] = value - 1
            } else {
                countDict[s2[i]] = -1
            }
        }
        
        if allZeroes(countDict.map { $0.value }) { return true }
        
        for i in len1..<len2 {
            if let value = countDict[s2[i]] {
                countDict[s2[i]] = value - 1
            } else {
                countDict[s2[i]] = -1
            }
            
            if let value = countDict[s2[i - len1]] {
                countDict[s2[i - len1]] = value + 1
            } else {
                countDict[s2[i - len1]] = 1
            }
            
            if allZeroes(countDict.map { $0.value }) { return true }
        }
        
        return false
    }
    
    func allZeroes(_ nums: [Int]) -> Bool {
        for num in nums {
            if num != 0 {
                return false
            }
        }
        
        return true
    }
}