1170. Compare Strings by Frequency of the Smallest Character

Let the function `f(s)` be the frequency of the lexicographically smallest character in a non-empty string `s`. For example, if `s = "dcce"` then `f(s) = 2` because the lexicographically smallest character is `'c'`, which has a frequency of 2.

You are given an array of strings `words` and another array of query strings `queries`. For each query `queries[i]`, count the number of words in `words` such that `f(queries[i])` < `f(W)` for each `W` in `words`.

Return an integer array `answer`, where each `answer[i]` is the answer to the `ith` query.

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]` consist of lowercase English letters.

1170. Compare Strings by Frequency of the Smallest Character
``````struct Solution;

impl Solution {
fn f(s: &str) -> usize {
let mut count = vec![0; 26];
let mut min = b'z';
for b in s.bytes() {
min = min.min(b);
count[(b - b'a') as usize] += 1;
}
count[(min - b'a') as usize]
}
fn num_smaller_by_frequency(queries: Vec<String>, words: Vec<String>) -> Vec<i32> {
let f_words: Vec<usize> = words.iter().map(|s| Self::f(s)).collect();
let mut counts = vec![0; 12];
for f in f_words {
counts[f] += 1;
}
for i in (1..10).rev() {
counts[i] += counts[i + 1];
}
queries
.iter()
.map(|s| Self::f(s))
.map(|f| counts[f + 1])
.collect()
}
}

#[test]
fn test() {
let queries = vec_string!["cbd"];
let words = vec_string!["zaaaz"];
let res = vec![1];
assert_eq!(Solution::num_smaller_by_frequency(queries, words), res);
let queries = vec_string!["bbb", "cc"];
let words = vec_string!["a", "aa", "aaa", "aaaa"];
let res = vec![1, 2];
assert_eq!(Solution::num_smaller_by_frequency(queries, words), res);
}
``````