Compare Strings by Frequency of the Smallest Character

Compare Strings by Frequency of the Smallest Character - Problem

Imagine you're a linguist analyzing the characteristics of different languages! You have a special function f(s) that finds the lexicographically smallest character in a string and returns how many times it appears.

For example, if s = "dcce", then f(s) = 2 because the smallest character is 'c' (comes first alphabetically among d, c, c, e), and it appears 2 times.

You're given two arrays:

words - An array of strings to analyze
queries - An array of query strings

For each query queries[i], count how many words in words have a larger f-value than the query. In other words, find how many words W satisfy f(queries[i]) < f(W).

Goal: Return an array where answer[i] is the count for the i-th query.

Input & Output

example_1.py — Basic Example

$ Input: queries = ["cbd"], words = ["zaaaz"]

› Output: [1]

💡 Note: f("cbd") = 1 (char 'b' appears once), f("zaaaz") = 3 (char 'a' appears 3 times). Since 1 < 3, we count 1 word.

example_2.py — Multiple Queries

$ Input: queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]

› Output: [1,2]

💡 Note: f("bbb") = 3, f("cc") = 2. For words: f("a")=1, f("aa")=2, f("aaa")=3, f("aaaa")=4. Query "bbb": only "aaaa" has f-value > 3. Query "cc": "aaa" and "aaaa" have f-values > 2.

example_3.py — Edge Case

$ Input: queries = ["bba"], words = ["aaa","aa","aaba"]

› Output: [2]

💡 Note: f("bba") = 2 (char 'a' appears twice). f("aaa")=3, f("aa")=2, f("aaba")=3. Words "aaa" and "aaba" have f-values > 2.

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 only

Visualization

Tap to expand

Understanding the Visualization

Calculate F-Values

For each string, find the lexicographically smallest character and count its occurrences

Sort Word F-Values

Create a sorted array of all word f-values for efficient searching

Binary Search Queries

For each query, use binary search to find how many words have higher f-values

Key Takeaway

🎯 Key Insight: Pre-sorting the f-values transforms each query from O(n) linear search to O(log n) binary search, dramatically improving performance for multiple queries.

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses preprocessing and binary search. First, calculate f-values for all words and sort them in O(w log w) time. Then for each query, calculate its f-value and use binary search to find how many words have larger f-values in O(log w) time. This gives us O(w log w + q log w) total time complexity, much better than the brute force O(q*w) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(q * w * (L1 + L2))	O(1)	Calculate f-values on-the-fly and compare each query with every word
Preprocessing + Binary Search	O(wL + wlog(w) + qL + qlog(w))	O(w)	Pre-calculate and sort all word f-values, then use binary search for each query

Brute Force (Nested Loops) — Algorithm Steps

For each query string, calculate f(query)
For each word in words array, calculate f(word)
Count how many f(word) > f(query)
Store the count in result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Query F-Value

Find smallest char and its frequency in query string

Compare with Each Word

Calculate f-value for each word and compare with query

Count Valid Words

Increment counter for words with f-value greater than query

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int f(char* s) {
    char minChar = 'z' + 1;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        if (s[i] < minChar) {
            minChar = s[i];
        }
    }
    int count = 0;
    for (int i = 0; i < len; i++) {
        if (s[i] == minChar) {
            count++;
        }
    }
    return count;
}

int* numSmallerByFrequency(char** queries, int queriesSize, char** words, int wordsSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int queryF = f(queries[i]);
        int count = 0;
        for (int j = 0; j < wordsSize; j++) {
            if (f(words[j]) > queryF) {
                count++;
            }
        }
        result[i] = count;
    }
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * w * (L1 + L2))

For each query (q), we check all words (w), and calculate f-values (L1 + L2 where L1, L2 are string lengths)

✓ Linear Growth

Space Complexity

O(1)

Only using variables for counting, no extra arrays

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

947 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler