Find the Original Typed String I - Practice Coding Problems

Find the Original Typed String I - Problem

String Easy

Alice is a programmer who's trying to type a specific string on her keyboard, but she's having a rough day! 🤦‍♀️ Sometimes when she presses a key, she accidentally holds it down a bit too long, causing that character to appear multiple times in a row.

Here's the catch: Alice knows she's clumsy, so she's being extra careful. She's confident that at most one character might have been accidentally repeated in her entire typing session.

Given the word that finally appeared on Alice's screen, your task is to determine how many different original strings Alice could have intended to type.

Example: If Alice's screen shows "aab", she could have intended to type either:

"aab" (no mistakes)
"ab" (the first 'a' was accidentally repeated)

So the answer would be 2 possible original strings.

Input & Output

example_1.py — Basic Case

$ Input: word = "aab"

› Output: 2

💡 Note: Alice could have intended "aab" (no mistake) or "ab" (first 'a' was held too long). The consecutive 'aa' gives us one additional possibility.

example_2.py — Multiple Groups

$ Input: word = "aaabbbccc"

› Output: 4

💡 Note: Original string plus 3 groups of consecutive characters: "aaa", "bbb", "ccc". Each group represents one way Alice might have made a mistake.

example_3.py — No Duplicates

$ Input: word = "abc"

› Output: 1

💡 Note: No consecutive duplicate characters, so Alice couldn't have made any typing mistakes. Only the original string is possible.

Constraints

1 ≤ word.length ≤ 10⁵
word consists of lowercase English letters only
Alice made at most one mistake (held one key too long)

Visualization

Tap to expand

Understanding the Visualization

Identify Patterns

Look for consecutive identical characters in the typed string

Count Possibilities

Each consecutive group could be a mistake - the character might have been intended just once

Add Original

Don't forget the possibility that Alice made no mistakes at all

Key Takeaway

🎯 Key Insight: Each group of consecutive identical characters represents exactly one potential typing mistake. The total possibilities equals 1 (original) plus the number of such groups.

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 15 f Meta 12

The optimal solution uses a one-pass counting approach that identifies groups of consecutive identical characters. Each group of length > 1 represents a potential typing mistake. The answer is simply 1 + (number of consecutive character groups), achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Counting (Optimal)	O(n)	O(1)	Count consecutive identical characters in a single pass through the string
Brute Force (Try All Positions)	O(n²)	O(n)	Try removing each possible consecutive character sequence and count valid options

One-Pass Counting (Optimal) — Algorithm Steps

Initialize count = 1 (original string is always valid)
Iterate through string, grouping consecutive identical characters
For each group of length > 1, increment count by 1
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set count = 1, start at beginning of string

Group Consecutives

For each character, find all consecutive duplicates

Count Groups

Each group of size > 1 adds one possibility

Return Result

Total possibilities = 1 + number of duplicate groups

Code -

solution.c — C

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

int possibleStringCount(char* word) {
    if (!word || strlen(word) == 0) return 1;
    
    int count = 1; // Original string is always valid
    int i = 0;
    int n = strlen(word);
    
    while (i < n) {
        // Count consecutive identical characters
        int j = i;
        while (j < n && word[j] == word[i]) {
            j++;
        }
        
        // If we have more than 1 consecutive character
        // Alice might have intended to type just 1
        if (j - i > 1) {
            count++;
        }
        
        i = j; // Move to next different character
    }
    
    return count;
}

int main() {
    char word[1001];
    fgets(word, sizeof(word), stdin);
    // Remove newline and quotes
    int len = strlen(word);
    if (word[len-1] == '\n') word[len-1] = '\0';
    if (word[0] == '"') {
        memmove(word, word+1, len-1);
        int newLen = strlen(word);
        if (word[newLen-1] == '"') word[newLen-1] = '\0';
    }
    printf("%d\n", possibleStringCount(word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count consecutive character groups

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

28.5K Views

Medium Frequency

~12 min Avg. Time

892 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

One-Pass Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler