Total Characters in String After Transformations I

Total Characters in String After Transformations I - Problem

Imagine a magical string transformation system where each letter evolves through the alphabet! You are given a string s and an integer t representing the number of transformation rounds to perform.

In each transformation, every character follows these evolution rules:

If the character is 'z', it splits into the string "ab"
Otherwise, it advances to the next character in the alphabet ('a' → 'b', 'b' → 'c', etc.)

Your task is to determine the total length of the resulting string after exactly t transformations. Since the result can grow exponentially large, return the answer modulo 10⁹ + 7.

Example: Starting with "az" and t=2:
Round 1: "az" → "bab" (a→b, z→ab)
Round 2: "bab" → "cbab" (b→c, a→b, b→c)
Final length: 4

Input & Output

example_1.py — Basic Transformation

$ Input: s = "abcxyz", t = 1

› Output: 7

💡 Note: After 1 transformation: 'a'→'b', 'b'→'c', 'c'→'d', 'x'→'y', 'y'→'z', 'z'→'ab'. Result: "bcdyzab" with length 7.

example_2.py — Multiple Z's

$ Input: s = "aaz", t = 1

› Output: 4

💡 Note: After 1 transformation: 'a'→'b', 'a'→'b', 'z'→'ab'. Result: "bbab" with length 4.

example_3.py — No Transformations

$ Input: s = "abc", t = 0

› Output: 3

💡 Note: With t=0, no transformations are applied, so the length remains 3.

Visualization

Tap to expand

Understanding the Visualization

Population Census

Count how many of each letter type we have initially

Evolution Rules

Each generation: a→b, b→c, ..., y→z, z→ab (splits!)

Track Populations

Update counts without tracking individual organisms

Key Takeaway

🎯 Key Insight: Count character frequencies instead of building the actual string - this transforms an exponential problem into a linear one!

Time & Space Complexity

Time Complexity

⏱️

O(26 * t)

For each of t transformations, we update counts for 26 characters

✓ Linear Growth

Space Complexity

O(1)

Only need arrays of size 26 to store character counts

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ t ≤ 10⁴
s consists only of lowercase English letters
Answer must be returned modulo 10⁹ + 7

Asked in

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

The optimal solution uses dynamic programming with character counting instead of building the actual string. By tracking how many of each character we have after each transformation, we avoid the exponential space complexity of string manipulation. The key insight is that position doesn't matter - only the count of each character type. Time complexity: O(26 × t), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Counting (Optimal)	O(26 * t)	O(1)	Track character counts through transformations using DP
Brute Force String Building	O(2^t * n)	O(2^t * n)	Build the actual transformed string at each step

Dynamic Programming with Counting (Optimal) — Algorithm Steps

Initialize a count array for each character a-z
Count initial characters in the input string
For each transformation:
Create new count array for next state
Each 'z' becomes one 'a' and one 'b'
Each other character advances to next letter
Sum all counts to get total length
Return result modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Initial Characters

Create frequency map of input string

Apply Transformation Rules

Update counts based on character evolution

Handle 'z' Special Case

Each 'z' becomes one 'a' and one 'b'

Code -

solution.c — C

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

int lengthAfterTransformations(char* s, int t) {
    const int MOD = 1e9 + 7;
    
    // Initialize character counts
    long long count[26] = {0};
    for (int i = 0; s[i]; i++) {
        count[s[i] - 'a']++;
    }
    
    // Apply t transformations
    for (int i = 0; i < t; i++) {
        long long newCount[26] = {0};
        
        for (int j = 0; j < 26; j++) {
            if (count[j] > 0) {
                if (j == 25) {  // 'z' case
                    newCount[0] = (newCount[0] + count[j]) % MOD;  // 'a'
                    newCount[1] = (newCount[1] + count[j]) % MOD;  // 'b'
                } else {
                    newCount[j + 1] = (newCount[j + 1] + count[j]) % MOD;
                }
            }
        }
        
        memcpy(count, newCount, sizeof(newCount));
    }
    
    long long result = 0;
    for (int i = 0; i < 26; i++) {
        result = (result + count[i]) % MOD;
    }
    
    return (int)result;
}

int main() {
    char s[1000];
    int t;
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s+1, strlen(s));
        s[strlen(s)-1] = '\0';
    }
    scanf("%d", &t);
    printf("%d\n", lengthAfterTransformations(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26 * t)

For each of t transformations, we update counts for 26 characters

✓ Linear Growth

Space Complexity

O(1)

Only need arrays of size 26 to store character counts

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ t ≤ 10⁴
s consists only of lowercase English letters
Answer must be returned modulo 10⁹ + 7

43.7K Views

Medium 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler