[Swift]LeetCode686. 重复叠加字符串匹配 | Repeated String Match

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

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given two strings A and B, find the minimum number of times A has to be repeated such that B is a substring of it. If no such solution, return -1.

For example, with A = "abcd" and B = "cdabcdab".

Return 3, because by repeating A three times (“abcdabcdabcd”), B is a substring of it; and B is not a substring of A repeated two times ("abcdabcd").

Note:
The length of A and B will be between 1 and 10000.

---

给定两个字符串 A 和 B, 寻找重复叠加字符串A的最小次数，使得字符串B成为叠加后的字符串A的子串，如果不存在则返回 -1。

举个例子，A = "abcd"，B = "cdabcdab"。

答案为 3， 因为 A 重复叠加三遍后为 “abcdabcdabcd”，此时 B 是其子串；A 重复叠加两遍后为"abcdabcd"，B 并不是其子串。

注意:

 A 与 B 字符串的长度在1和10000区间范围内。

---

16ms

class Solution {
  func repeatedStringMatch(_ A: String, _ B: String) -> Int {
    var arrA: [UInt32] = []
    var arrB: [UInt32] = []
    var setA: Set<UInt32> = []
    
    for char in A.unicodeScalars {
      arrA.append(char.value)
      setA.insert(char.value)
    }
    
    for char in B.unicodeScalars {
      if !setA.contains(char.value) {
        return -1
      }
      arrB.append(char.value)
    }
    
    for i in 0..<arrA.count {
      if arrA[i] == arrB[0] {
        var times = 1
        var indexI = i
        var j = 0
        while j < arrB.count && arrA[indexI] == arrB[j] {
          indexI += 1
          j += 1
          if j < arrB.count && indexI >= arrA.count {
            indexI = 0
            times += 1
          }
        }
        
        if j == arrB.count {
          return times
        }
      }
    }
    
    return -1
  }
}

---

24ms

import Foundation

class Solution {
    func repeatedStringMatch(_ A: String, _ B: String) -> Int {
        if !Set(B).isSubset(of: Set(A)) {
            return -1
        }
        
        var s = String(repeating: A, count: B.count/A.count)
        repeat {
            if s.contains(B) {
                return s.count/A.count
            } else {
                s += A
            }
        } while (s.count < B.count + 2*A.count)
        return -1
    }
}

---

1372ms

class Solution {
    func repeatedStringMatch(_ A: String, _ B: String) -> Int {

        var setA = Set(Array(A))
        var setB = Set(Array(B))
        
        if !setB.isSubset(of:setA) {
            return -1
        }
        
        
        
        var string = A
        var count = 1
        while string.count < B.count {
            string.append(A)
            count += 1
        }
        
        if string.contains(B) {
            return count
        }
        
        string.append(A)
        
        if string.contains(B) {
            return count + 1
        }
        
        return -1
    }
}

---

1776ms

class Solution {
    func repeatedStringMatch(_ A: String, _ B: String) -> Int {
        if A.count == 0 || B.count == 0 {
            return -1
        }
        
        var setB = Set(B)
        var setA = Set(A)
        
        if !setB.isSubset(of: setA) {
            return -1
        }
        
        var string = A
        var count = 1
        while string.count < B.count {
            string.append(A)
            count += 1
        }
        
        if string.contains(B) {
            return count
        }
        
        string.append(A)
        
        if string.contains(B) {
            return count + 1
        }
        
        return -1
    }
}

---

1848ms

class Solution {
    func repeatedStringMatch(_ A: String, _ B: String) -> Int {
        if A.isEmpty || B.isEmpty {
            return 0
        }

        let A = Array(A)
        let B = Array(B)
        var result = Int.max
        for start in 0..<A.count {
            var c = 0
            var i = start
            var j = 0
            while j < B.count {
                if i == A.count {
                    c += 1
                    i = 0
                }
                if A[i] != B[j] {
                    break
                }
                i += 1
                j += 1
            }
            if j == B.count {
                result = min(result, c + 1)
            }
        }
        return result == Int.max ? -1 : result
    }
}

---

Runtime: 2116 ms

Memory Usage: 19.6 MB

class Solution {
    func repeatedStringMatch(_ A: String, _ B: String) -> Int {
        var m:Int = A.count
        var n:Int = B.count
        var arrA:[Character] = Array(A)
        var arrB:[Character] = Array(B)
        for i in 0..<m
        {
            var j:Int = 0
            while (j < n && arrA[(i + j) % m] == arrB[j])
            {
                j += 1
            }
            if j == n
            {
                return (i + j - 1) / m + 1
            }
        }
        return -1
    }
}

---

2392ms

class Solution {
    func repeatedStringMatch(_ A: String, _ B: String) -> Int {
        let arrayA = Array(A), arrayB = Array(B)
        guard let firstB = arrayB.first else { return -1 }
        var indexAs = arrayA.indices.filter { arrayA[$0] == firstB }
        guard indexAs.count > 0 else { return -1 }
        
        var minRepeatCount = -1
        for indexA in indexAs {
            var indexA = indexA
            var repeatCount = 1
            for indexB in arrayB.indices {
                if arrayB[indexB] != arrayA[indexA] {
                    repeatCount = -1
                    break
                }

                // important
                if indexB == arrayB.count - 1 {
                    break
                }

                if indexA == arrayA.count - 1 {
                    repeatCount += 1
                    indexA = 0
                } else {
                    indexA += 1
                }
            }
            
            if repeatCount != -1 {
                if minRepeatCount == -1 {
                    minRepeatCount = repeatCount
                } else {
                    minRepeatCount = min(minRepeatCount, repeatCount)
                }
            }
        }
        return minRepeatCount
    }
}

---

2572ms

class Solution {
    func repeatedStringMatch(_ A: String, _ B: String) -> Int {
        let aChars = A.unicodeScalars.map { $0.value }
        let bChars = B.unicodeScalars.map { $0.value }
        guard bChars.count > 0 else {
            return -1
        }

        var startComparing = false
        var i = 0
        var j = 0
        while true {
            if i >= aChars.count, !startComparing {
                break
            }
            if j >= bChars.count {
                break
            }
            if aChars[i % aChars.count] != bChars[j] {
                if startComparing {
                    startComparing = false
                    i -= j
                    j = 0
                }
                i += 1
                continue
            } else {
                if !startComparing {
                    startComparing = true
                }
                i += 1 
                j += 1
                continue
            }
        }
        return startComparing ? Int(ceil(Double(i)/Double(aChars.count))) : -1
    }
}

---

3956ms

class Solution {
    func repeatedStringMatch(_ A: String, _ B: String) -> Int {
        if A.isEmpty { return -1 }
        if A == B || A.contains(B) { return 1 }
        var i = 1
        var newString = A
        
        if Set(A).count != Set(B).count { return -1 }
        
        var limit = A.count > B.count ? 2 : (B.count / A.count) + 1
        
        while i <= limit {
            i += 1
            newString += A
            if newString.count >= B.count && newString.range(of: B) != nil {
                return i
            }
        }
        return -1
    }
}