Sum of Prefix Scores of Strings - Practice Coding Problems

Sum of Prefix Scores of Strings - Problem

Imagine you're working for a search engine optimization company and need to analyze how popular different word prefixes are across a collection of terms. Given an array of words, your task is to calculate prefix popularity scores.

The score of any string prefix is defined as the number of words in the array that have this prefix. For example, if we have ["apple", "app", "application", "cat"], then the prefix "app" has a score of 3 because it appears at the beginning of "apple", "app", and "application".

Your goal is to return an array where each element represents the sum of scores of all possible non-empty prefixes for the corresponding word. Remember, a word is considered a prefix of itself!

Example: For words = ["abc", "ab", "bc", "b"]
• Word "abc" has prefixes: "a" (score=1), "ab" (score=2), "abc" (score=1) → total = 4
• Word "ab" has prefixes: "a" (score=1), "ab" (score=2) → total = 3
• And so on...

Input & Output

example_1.py — Basic Example

$ Input: ["abc", "ab", "bc", "b"]

› Output: [5, 4, 3, 2]

💡 Note: For "abc": prefixes are "a"(1), "ab"(2), "abc"(1) → 1+2+1=4. Wait, let me recalculate: "a" appears in "abc","ab" so score=2. "ab" appears in "abc","ab" so score=2. "abc" appears in "abc" so score=1. Total = 2+2+1=5.

example_2.py — Single Word

$ Input: ["programming"]

› Output: [11]

💡 Note: Only one word, so each prefix of "programming" has score 1. Total = 1+1+1+...+1 = 11 (length of word).

example_3.py — All Different Prefixes

$ Input: ["a", "aa", "aaa"]

› Output: [6, 5, 3]

💡 Note: For "a": prefix "a" appears in all 3 words, score = 3. For "aa": "a"(3) + "aa"(2) = 5. For "aaa": "a"(3) + "aa"(2) + "aaa"(1) = 6.

Constraints

1 ≤ words.length ≤ 1000
1 ≤ words[i].length ≤ 1000
words[i] consists of lowercase English letters
Sum of all words[i].length ≤ 2 × 10⁵

Visualization

Tap to expand

Understanding the Visualization

Build Index Tree

Create a tree structure where each path represents a prefix, and each node counts how many terms pass through it

Count Occurrences

As you add each search term, increment counters at each node along its path

Calculate Popularity

For any term, sum up all the counters along its path to get total prefix popularity

Key Takeaway

🎯 Key Insight: A Trie naturally maintains prefix counts at each node, making it the perfect data structure for prefix-related problems. No string comparisons needed!

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 32 f Meta 25

The optimal solution uses a Trie (prefix tree) data structure to efficiently count prefix occurrences. By storing counts at each node during insertion, we can calculate all prefix scores in O(n × m) time, where n is the number of words and m is the average word length. This approach naturally handles prefix relationships and avoids expensive string comparisons.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × m²)	O(1)	For each word, check every prefix against all words to count occurrences
Two-Pass Hash Table	O(n × m²)	O(n × m²)	First pass counts all prefix frequencies, second pass sums up scores for each word
Trie Data Structure (Optimal)	O(n × m)	O(n × m)	Use a Trie to efficiently store and count prefix occurrences in optimal time

Brute Force (Nested Loops) — Algorithm Steps

For each word in the array
Generate all possible prefixes of that word
For each prefix, scan through all words to count matches
Sum up all the counts for that word's prefixes

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Word

Pick the first word 'abc' and start generating its prefixes

Check Prefix 'a'

Scan all words to count how many start with 'a'

Check Prefix 'ab'

Scan all words again to count 'ab' prefixes

Repeat Process

Continue for all prefixes of all words

Code -

solution.c — C

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

int* sumPrefixScores(char** words, int wordsSize, int* returnSize) {
    *returnSize = wordsSize;
    int* result = (int*)calloc(wordsSize, sizeof(int));
    
    for (int i = 0; i < wordsSize; i++) {
        int wordLen = strlen(words[i]);
        // Generate all prefixes of current word
        for (int j = 1; j <= wordLen; j++) {
            // Count how many words have this prefix
            int count = 0;
            for (int k = 0; k < wordsSize; k++) {
                if (strncmp(words[i], words[k], j) == 0) {
                    count++;
                }
            }
            result[i] += count;
        }
    }
    
    return result;
}

int main() {
    char* words[] = {"abc", "ab", "bc", "b"};
    int returnSize;
    int* result = sumPrefixScores(words, 4, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m²)

For n words with average length m: generating prefixes takes O(m²) per word, and checking each prefix against all words takes O(n×m)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters and temporary variables

✓ Linear Space

43.7K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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