Find the Original Typed String II - Practice Coding Problems

Find the Original Typed String II - Problem

Alice is trying to type a specific string, but she's a bit clumsy with her keyboard! 🖮

When Alice types, she sometimes holds keys for too long, causing characters to be repeated multiple times. Given the final string that appears on her screen and a minimum length k, you need to find how many different original strings Alice might have intended to type.

The Challenge: Alice's original string must be at least k characters long. Each group of consecutive identical characters in the typed string could represent 1 or more of that character in the original string.

Example: If Alice typed "aabbcc" and k=3, the original could be "abc", "aabc", "abbc", "abcc", etc.

Return the total count modulo 10⁹ + 7 since the answer can be very large!

Input & Output

example_1.py — Basic Case

$ Input: word = "aabbcc", k = 3

› Output: 4

💡 Note: The possible original strings of length ≥ 3 are: "abc" (length 3), "aabc", "abbc", "abcc" (each length 4). Total: 4 ways.

example_2.py — Single Character

$ Input: word = "aaaa", k = 2

› Output: 3

💡 Note: Original could be "aa" (length 2), "aaa" (length 3), or "aaaa" (length 4). All meet k=2 requirement. Total: 3 ways.

example_3.py — Minimum Length Edge Case

$ Input: word = "ab", k = 3

› Output: 0

💡 Note: The typed string "ab" has maximum possible original length of 2, but we need k=3. No valid solutions exist.

Constraints

1 ≤ word.length ≤ 1000
1 ≤ k ≤ word.length
word consists only of lowercase English letters
Answer should be returned modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Group Consecutive Characters

Identify runs of identical characters: 'aabbcc' → ['aa', 'bb', 'cc']

Calculate Possibilities

Each group can contribute 1 to group_size characters to original

Apply Length Constraint

Only count combinations where total length ≥ k

Use DP for Efficiency

Build table to avoid recalculating subproblems

Key Takeaway

🎯 Key Insight: This is a dynamic programming problem where we systematically count combinations of character group sizes that meet the minimum length requirement, avoiding the exponential complexity of generating all possible strings.

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses Dynamic Programming to efficiently count valid original strings. We group consecutive characters, then use a DP table where dp[i][j] represents ways to achieve length j using the first i groups. The key insight is that each group of consecutive characters can contribute 1 to group_size characters to the original string, and we need at least k total characters.

Common Approaches

Approach	Time	Space	Notes
✓ Bottom-Up Dynamic Programming (Optimal)	O(n * L * m)	O(n * L)	Build solution iteratively using DP table for optimal time and space complexity
Brute Force (Recursive Enumeration)	O(m^n)	O(n)	Try all possible combinations of original characters for each consecutive group
Dynamic Programming (Memoized Recursion)	O(n * k * m)	O(n * k)	Use memoization to avoid recalculating the same subproblems

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Group consecutive identical characters into counts array
Create DP table: dp[i][j] = ways to get length j using first i groups
Initialize: dp[0][0] = 1 (one way to get length 0 with 0 groups)
Fill table: for each group and each possible length, add all valid transitions
Sum dp[n][k] through dp[n][max_length] for final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Case

dp[0][0] = 1 (one way to get length 0)

Process Each Group

For each character group, calculate all possible transitions

Fill DP Table

dp[i][j] += dp[i-1][j-count] for each valid count

Sum Results

Add up dp[n][k] through dp[n][total_length]

Code -

solution.c — C

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

#define MOD 1000000007
#define MAXN 1005

int solution(char* word, int k) {
    int len = strlen(word);
    int groups[MAXN];
    int groupCount = 0;
    
    // Group consecutive characters
    int i = 0;
    while (i < len) {
        char ch = word[i];
        int count = 1;
        while (i + count < len && word[i + count] == ch) {
            count++;
        }
        groups[groupCount++] = count;
        i += count;
    }
    
    // dp[i][j] = number of ways to get length j using first i groups
    long long dp[MAXN][MAXN];
    memset(dp, 0, sizeof(dp));
    dp[0][0] = 1;
    
    for (int idx = 1; idx <= groupCount; idx++) {
        int groupSize = groups[idx - 1];
        
        // Copy previous state
        for (int j = 0; j <= len; j++) {
            dp[idx][j] = dp[idx-1][j];
        }
        
        // Add ways using current group
        for (int j = 0; j <= len; j++) {
            if (dp[idx-1][j] > 0) {
                int maxCount = groupSize < (len - j) ? groupSize : (len - j);
                for (int count = 1; count <= maxCount; count++) {
                    if (j + count <= len) {
                        dp[idx][j + count] = (dp[idx][j + count] + dp[idx-1][j]) % MOD;
                    }
                }
            }
        }
    }
    
    // Sum all ways with length >= k
    long long result = 0;
    for (int length = k; length <= len; length++) {
        result = (result + dp[groupCount][length]) % MOD;
    }
    
    return (int) result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * L * m)

Where n is groups, L is total string length, m is average group size

✓ Linear Growth

Space Complexity

O(n * L)

DP table storing ways for each (group, length) combination

⚡ Linearithmic 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

Bottom-Up Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler