[Swift]LeetCode1170. 比较字符串最小字母出现频次 | Compare Strings by Frequency of the Smallest Character

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

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

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

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

Let's define a function f(s) over a non-empty string s, which calculates the frequency of the smallest character in s. For example, if s = "dcce" then f(s) = 2 because the smallest character is "c" and its frequency is 2.

Now, given string arrays queries and words, return an integer array answer, where each answer[i] is the number of words such that f(queries[i]) < f(W), where W is a word in words.

 

Example 1:

Input: queries = ["cbd"], words = ["zaaaz"]
Output: [1]
Explanation: On the first query we have f("cbd") = 1, f("zaaaz") = 3 so f("cbd") < f("zaaaz").

Example 2:

Input: queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]
Output: [1,2]
Explanation: On the first query only f("bbb") < f("aaaa"). On the second query both f("aaa") and f("aaaa") are both > f("cc").

 

Constraints:

• 1 <= queries.length <= 2000
• 1 <= words.length <= 2000
• 1 <= queries[i].length, words[i].length <= 10
• queries[i][j], words[i][j] are English lowercase letters.

---

我们来定义一个函数 f(s)，其中传入参数 s 是一个非空字符串；该函数的功能是统计 s  中（按字典序比较）最小字母的出现频次。

例如，若 s = "dcce"，那么 f(s) = 2，因为最小的字母是 "c"，它出现了 2 次。

现在，给你两个字符串数组待查表 queries 和词汇表 words，请你返回一个整数数组 answer 作为答案，其中每个 answer[i] 是满足 f(queries[i]) < f(W) 的词的数目，W 是词汇表 words 中的词。

 

示例 1：

输入：queries = ["cbd"], words = ["zaaaz"]
输出：[1]
解释：查询 f("cbd") = 1，而 f("zaaaz") = 3 所以 f("cbd") < f("zaaaz")。

示例 2：

输入：queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]
输出：[1,2]
解释：第一个查询 f("bbb") < f("aaaa")，第二个查询 f("aaa") 和 f("aaaa") 都 > f("cc")。

 

提示：

• 1 <= queries.length <= 2000
• 1 <= words.length <= 2000
• 1 <= queries[i].length, words[i].length <= 10
• queries[i][j], words[i][j] 都是小写英文字母

---

Runtime: 188 ms

Memory Usage: 21.5 MB

class Solution {
    func numSmallerByFrequency(_ queries: [String], _ words: [String]) -> [Int] {
        let n:Int = queries.count
        let m:Int = words.count
        var ws:[Int] = [Int](repeating:0,count:m)
        for i in 0..<m
        {
            ws[i] = f(words[i])
        }
        var ret:[Int] = [Int](repeating:0,count:n)
        for i in 0..<n
        {
            var u:Int = f(queries[i])
            for j in 0..<m
            {
                if u < ws[j]
                {
                    ret[i] += 1
                }
            }
        }
        return ret        
    }
    
    func f(_ s:String) -> Int
    {
        var f:[Int] = [Int](repeating:0,count:26)
        for c in s
        {
            f[c.ascii - 97] += 1
        }
        for i in 0..<26
        {
            if f[i] > 0
            {
                return f[i]
            }
        }
        return 0
    }
}

//Character扩展 
extension Character  
{  
  //Character转ASCII整数值(定义小写为整数值)
   var ascii: Int {
       get {
           return Int(self.unicodeScalars.first?.value ?? 0)
       }       
    }
}

---

248ms 

class Solution {
    func freOf(_ str: String) -> Int {
        var lastChar: Character = "z"
        let chars = Array(str)
        var dic = [Character: Int]()
        for c in chars {
            dic[c, default: 0] += 1
            if c < lastChar {
                lastChar = c
            }
        }
        return dic[lastChar, default: 0]
    }

    func numSmallerByFrequency(_ queries: [String], _ words: [String]) -> [Int] {
        var freword = [Int]()
        for w in words {
            freword.append(freOf(w))
        }

        freword = freword.sorted()
        var freq = [Int]()
        for f in queries {
            freq.append(freOf(f))
        }
        var ans = [Int]()
        for fi in freq {
            var l = 0, r = freword.count - 1, idx = 0, valid = false
            while l <= r {
                let mid = (l+r)/2
                if fi < freword[mid] {
                    idx = mid
                    r -= 1
                    valid = true
                } else {
                    l += 1
                }
            }
            if valid {
                ans.append(freword.count - idx)
            } else {
                ans.append(0)   
            }
        }
        return ans
    }
}

---

256ms

class Solution {
func freOf(_ str: String) -> Int {
        var lastChar: Character = "z"
        let chars = Array(str)
        var dic = [Character: Int]()
        for c in chars {
            dic[c, default: 0] += 1
            if c < lastChar {
                lastChar = c
            }
        }
        return dic[lastChar, default: 0]
    }

    func numSmallerByFrequency(_ queries: [String], _ words: [String]) -> [Int] {
        var freword = [Int]()
        for w in words {
            freword.append(freOf(w))
        }

        freword = freword.sorted()
        var freq = [Int]()
        for f in queries {
            freq.append(freOf(f))
        }
        var ans = [Int]()
        for fi in freq {
            var l = 0, r = freword.count - 1, idx = 0, valid = false
            while l <= r {
                let mid = (l+r)/2
                if fi < freword[mid] {
                    idx = mid
                    r -= 1
                    valid = true
                } else {
                    l += 1
                }
            }
            if valid {
                ans.append(freword.count - idx)
            } else {
                ans.append(0)   
            }
        }
        return ans
    }
}

---

1220ms

class Solution {
    func numSmallerByFrequency(_ queries: [String], _ words: [String]) -> [Int] {
        var ret = [Int]()
        var wArr = [Int]()
        for w in words {
            wArr.append(f(w))
        }
        for q in queries {
            let freq = f(q)
            var count = 0
            for w in wArr {
                if freq < w { count += 1 }
            }
            ret.append(count)
        }
        return ret
    }
    
    private func f(_ str: String) -> Int {
        guard str.count > 0 else { return 0 }
        
        var minC = str[str.index(str.startIndex, offsetBy: 0)]
        var minCount = 0
        for c in str {
            if c == minC { minCount += 1 }
            else if c < minC {
                minCount = 1
                minC = c
            }
        }
        return minCount
    }
}

---

1268ms

class Solution {
    func numSmallerByFrequency(_ queries: [String], _ words: [String]) -> [Int] {
        var res = [Int]()
        
        let f = { (s: String) -> Int in
            var a = [Int](repeating: 0, count: 26)
            let chars = s.map{ $0 }
            for c in chars {
                a[Int(c.asciiValue! - Character("a").asciiValue!)] += 1
            }
            
            for t in a where t > 0 {
                return t
            }
            
            return 0
        }
        
        var ws = [Int]()
        for w in words {
            ws.append(f(w))
        }
        
        for q in queries {
            let a = f(q)
            var c = 0
            for w in ws where a < w {
                c += 1
            }
            res.append(c)
        }
        
        return res
    }
}

---

1284ms

class Solution {
    func f(_ str: String) -> Int? {
    guard str.count > 0 else {return nil}
    var freq : [Character: Int] = [:]
    for ch in str {
        freq[ch, default: 0] += 1
    }

    return freq.min{a, b in
        a.key <= b.key
    }?.value
}
    func numSmallerByFrequency(_ queries: [String], _ words: [String]) -> [Int] {
    var output : [Int] = []
    var fwords : [Int] = []
    
    for word in words {
        fwords.append(f(word)!)
    }
    
    for query in queries {
        var localOutput = 0
        let fquery = f(query)!
        for word in fwords {
            if fquery < word {
                localOutput += 1
            }
        }
        output.append(localOutput)
    }
    return output  
    }
}

---

1292ms

class Solution {
    func f(_ str: String) -> Int? {
    guard str.count > 0 else {return nil}
    var freq : [Character: Int] = [:]
    for ch in str {
        freq[ch, default: 0] += 1
    }

    return freq.min{a, b in
        a.key <= b.key
    }?.value
}
    func numSmallerByFrequency(_ queries: [String], _ words: [String]) -> [Int] {
    var output : [Int] = []
    var fwords : [Int] = []
    
    for word in words {
        fwords.append(f(word)!)
    }
    
    for query in queries {
        var localOutput = 0
        let fquery = f(query)!
        for word in fwords {
            if fquery < word {
                localOutput += 1
            }
        }
        output.append(localOutput)
    }
    return output  
    }
}

---

1436ms

class Solution {
    func numSmallerByFrequency(_ queries: [String], _ words: [String]) -> [Int] {
        let worsCounter = words.map { (s) -> Int in
            return f(s: s)
        }
        let queriesCounter = queries.map { (s) -> Int in
            return f(s: s)
        }
        
        return queriesCounter.map({ (val) -> Int in
            worsCounter.filter({ (v) -> Bool in
                v >  val
            }).count
        })
    }
    private func f(s: String) -> Int {
        var  arr = Array<Int>(repeating: 0, count: 26)
        let  aToInt = Character("a").asciiValue!
        for ch in s {
            let index = ch.asciiValue! - aToInt
            arr[Int(index)] += 1
        }
        for i in 0...25 {
            if arr[i] != 0 {
                return arr[i]
            }
        }
        return  -1
    }
}