Total Characters in String After Transformations I

Total Characters in String After Transformations I - Problem

You are given a string s and an integer t, representing the number of transformations to perform.

In one transformation, every character in s is replaced according to the following rules:

If the character is 'z', replace it with the string "ab"
Otherwise, replace it with the next character in the alphabet

For example, 'a' is replaced with 'b', 'b' is replaced with 'c', and so on.

Return the length of the resulting string after exactly t transformations.

Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Transformation

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

› Output: 2

💡 Note: After 1 transformation: 'a' becomes 'b', 'b' becomes 'c', so "ab" becomes "bc". Length is 2.

Example 2 — With 'z' Character

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

› Output: 2

💡 Note: After 1 transformation: 'z' becomes "ab", so "z" becomes "ab". Length changes from 1 to 2.

Example 3 — Multiple Transformations

$ Input: s = "a", t = 2

› Output: 1

💡 Note: t=1: 'a'→'b', string becomes "b". t=2: 'b'→'c', string becomes "c". Final length is 1.

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ t ≤ 10⁹
s consists only of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 12 f Meta 8 a Amazon 6

The key insight is to track character frequencies instead of building actual strings. The optimal approach uses matrix exponentiation to handle large values of t efficiently. Time: O(26³ × log t), Space: O(26²)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n × 2^t) Space: O(n × 2^t)

For each transformation, iterate through the current string and replace each character according to the rules. Build the new string character by character.

Character Frequency Tracking

⏱️ Time: O(t × 26) Space: O(1)

Instead of simulating the actual string transformations, maintain a count array for each character (a-z). For each transformation, calculate how many of each character we'll have in the next step.

Dynamic Programming with Optimization

⏱️ Time: O(26³ × log t) Space: O(26²)

Model the transformation as a matrix operation where each character's count is transformed by a transition matrix. Use matrix exponentiation to compute the result in logarithmic time.

Brute Force Simulation — Algorithm Steps

Start with original string
For each transformation, replace every character
Count final string length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with original string

Transform Each Character

Replace according to rules: a→b, z→ab

Count Length

Return length of final string

Code -

solution.c — C

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

int solution(char* s, int t) {
    const int MOD = 1000000007;
    char* current = malloc(1000001 * sizeof(char));
    strcpy(current, s);
    
    for (int i = 0; i < t; i++) {
        char* next = malloc(1000001 * sizeof(char));
        int nextIdx = 0;
        
        for (int j = 0; current[j]; j++) {
            if (current[j] == 'z') {
                next[nextIdx++] = 'a';
                next[nextIdx++] = 'b';
            } else {
                next[nextIdx++] = current[j] + 1;
            }
            
            if (nextIdx > 1000000) break;
        }
        next[nextIdx] = '\0';
        
        free(current);
        current = next;
        
        if (strlen(current) > 1000000) {
            int len = strlen(current);
            free(current);
            return len % MOD;
        }
    }
    
    int len = strlen(current);
    free(current);
    return len % MOD;
}

int main() {
    char s[1001];
    int t;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    scanf("%d", &t);
    
    printf("%d\n", solution(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^t)

String length doubles roughly every 26 transformations due to 'z' → 'ab', leading to exponential growth

✓ Linear Growth

Space Complexity

O(n × 2^t)

Need to store the entire string at each step, which grows exponentially

⚡ Linearithmic Space

8.9K Views

Medium Frequency

~35 min Avg. Time

234 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler