Find the Sequence of Strings Appeared on the Screen

Find the Sequence of Strings Appeared on the Screen - Problem

String Simulation Medium

Alice has a unique keyboard with only two keys to help her type any target string:

Key 1: Appends the character 'a' to the string on screen
Key 2: Changes the last character to its next character in the alphabet (e.g., 'c' → 'd', 'z' → 'a')

Starting with an empty screen, Alice wants to type a given target string using the minimum number of key presses.

Your task: Return a list of all intermediate strings that appear on the screen as Alice types, including the final target string, in the order they appear.

Example: To type "abc":

Press Key 1 → "a"
Press Key 1 → "aa"
Press Key 2 → "ab"
Press Key 1 → "aba"
Press Key 2 → "abb"
Press Key 2 → "abc"

Input & Output

example_1.py — Basic Example

$ Input: target = "abc"

› Output: ["a", "aa", "ab", "aba", "abb", "abc"]

💡 Note: To build 'abc': add 'a', then add 'a' and transform to 'b', then add 'a' and transform through 'b' to 'c'

example_2.py — Single Character

$ Input: target = "z"

› Output: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]

💡 Note: Start with 'a' then transform through all letters to reach 'z'

example_3.py — Edge Case

$ Input: target = "a"

› Output: ["a"]

💡 Note: Target is 'a', so we only need to press Key 1 once

Constraints

1 ≤ target.length ≤ 1000
target consists only of lowercase English letters
Key 1 always appends 'a'
Key 2 transforms last character to next in alphabet (z → a)

Visualization

Tap to expand

Understanding the Visualization

Start Fresh

Alice begins with an empty screen, ready to type her target word

Add Foundation

For each position, press the blue button to add an 'a' as the starting point

Transform to Target

Press the red button repeatedly to cycle through alphabet until reaching the desired letter

Record Progress

Every string that appears on screen is saved in the sequence

Key Takeaway

🎯 Key Insight: The optimal strategy is to append 'a' first, then transform it to the target character, ensuring minimum key presses for each position.

Asked in

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

The optimal approach is a simulation strategy where we build the target string character by character. For each character in the target, we first append an 'a' (Key 1), then repeatedly transform the last character (Key 2) until we reach the desired character. This ensures minimum key presses while recording all intermediate strings that appear on screen.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n * k)	O(m)	Simulate the typing process step by step for each character

Simulation Approach — Algorithm Steps

Initialize result list with empty strings seen so far
For each character in target string:
Add 'a' to current string and record it
Transform last character until it matches target character
Record each transformation step
Return all recorded strings

Visualization

Tap to expand

Step-by-Step Walkthrough

Add 'a'

Press Key 1 to append 'a' to current string

Transform

Press Key 2 repeatedly until last character matches target

Record

Save each intermediate string that appears on screen

Code -

solution.c — C

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

char** stringSequence(char* target, int* returnSize) {
    int targetLen = strlen(target);
    char** result = (char**)malloc(1000 * sizeof(char*));
    int resultIdx = 0;
    
    char* current = (char*)malloc(1000 * sizeof(char));
    current[0] = '\0';
    int currentLen = 0;
    
    for (int i = 0; i < targetLen; i++) {
        char targetChar = target[i];
        
        // First, add 'a' to the current string
        current[currentLen] = 'a';
        current[currentLen + 1] = '\0';
        currentLen++;
        
        result[resultIdx] = (char*)malloc((currentLen + 1) * sizeof(char));
        strcpy(result[resultIdx], current);
        resultIdx++;
        
        // Then transform the last character to target character
        while (current[currentLen - 1] != targetChar) {
            char lastChar = current[currentLen - 1];
            char nextChar = (lastChar == 'z') ? 'a' : lastChar + 1;
            current[currentLen - 1] = nextChar;
            
            result[resultIdx] = (char*)malloc((currentLen + 1) * sizeof(char));
            strcpy(result[resultIdx], current);
            resultIdx++;
        }
    }
    
    *returnSize = resultIdx;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

Where n is the length of target string and k is the average distance from 'a' to each character

✓ Linear Growth

Space Complexity

O(m)

Where m is the total number of intermediate strings generated

✓ Linear Space

26.5K Views

Medium Frequency

~15 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler