Sum of Scores of Built Strings - Practice Coding Problems

Sum of Scores of Built Strings - Problem

Sum of Scores of Built Strings

Imagine you're building a string s character by character, but with a twist - each new character gets prepended to the front of the string! 🔄

Given the final string s of length n, we need to understand how it was built:
• s₁ = last character of s (added first)
• s₂ = last 2 characters of s (second character added)
• ... and so on
• sₙ = complete string s

For example, if s = "abaca":
• s₁ = "a" (started with 'a')
• s₂ = "ca" (prepended 'c')
• s₃ = "aca" (prepended 'a')
• s₄ = "baca" (prepended 'b')
• s₅ = "abaca" (prepended 'a')

The score of each sᵢ is the length of the longest common prefix between sᵢ and the final string s.

Goal: Return the sum of scores of all intermediate strings.

Input & Output

example_1.py — Basic Case

$ Input: s = "babab"

› Output: 9

💡 Note: s₁="b" (score=1), s₂="ab" (score=0), s₃="bab" (score=3), s₄="abab" (score=0), s₅="babab" (score=5). Total: 1+0+3+0+5=9

example_2.py — All Same Characters

$ Input: s = "aaaa"

› Output: 10

💡 Note: s₁="a" (score=1), s₂="aa" (score=2), s₃="aaa" (score=3), s₄="aaaa" (score=4). Total: 1+2+3+4=10

example_3.py — No Repeating Prefix

$ Input: s = "abc"

› Output: 3

💡 Note: s₁="c" (score=0), s₂="bc" (score=0), s₃="abc" (score=3). Total: 0+0+3=3

Visualization

Tap to expand

Understanding the Visualization

Start with last character

Begin building from the rightmost character of final string

Prepend characters

Add each new character to the front, creating intermediate versions

Calculate scores

For each version, count how many characters from start match the final string

Sum all scores

Add up all the similarity scores to get the final answer

Key Takeaway

🎯 Key Insight: The problem reduces to computing the Z-array of the string, where each Z[i] represents the score of suffix starting at position i. The Z-algorithm solves this optimally in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Z-algorithm processes each character at most twice using sliding window technique

✓ Linear Growth

Space Complexity

O(n)

Need to store the Z-array of size n

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Time limit: 2 seconds

Asked in

G Google 28 f Meta 15 a Amazon 12 ⊞ Microsoft 8

The optimal solution uses the Z-algorithm to compute longest common prefixes efficiently in O(n) time. The Z-array directly gives us the score for each suffix, and we simply sum all values. The key insight is that this problem is equivalent to computing the Z-array of the string, where Z[i] represents the length of the longest common prefix between the suffix starting at position i and the original string.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Compare each suffix with the original string character by character
Z-Algorithm (Optimal)	O(n)	O(n)	Use Z-algorithm to compute longest common prefixes efficiently in one pass

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each position i from n-1 to 0 (representing each sᵢ)
For each suffix starting at position i, compare with original string
Count matching characters from the beginning until mismatch
Add the count to total score

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with full string

Compare s with itself - full match

Check second suffix

Compare suffix with original from start

Continue for all suffixes

Repeat comparison for each remaining suffix

Code -

solution.c — C

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

long long sumScores(char* s) {
    int n = strlen(s);
    long long totalScore = 0;
    
    // For each suffix (representing each si)
    for (int i = 0; i < n; i++) {
        // Compare suffix starting at i with original string
        int prefixLength = 0;
        for (int j = 0; j < n - i; j++) {
            if (s[i + j] == s[j]) {
                prefixLength++;
            } else {
                break;
            }
        }
        totalScore += prefixLength;
    }
    
    return totalScore;
}

int main() {
    char s[100001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 1);
        s[len - 2] = '\0';
    }
    printf("%lld\n", sumScores(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n suffixes, we potentially compare up to n characters

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting and iteration

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Time limit: 2 seconds

31.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler