Append Characters to String to Make Subsequence

Append Characters to String to Make Subsequence - Problem

You are given two strings s and t consisting of only lowercase English letters.

Your task is to find the minimum number of characters that need to be appended to the end of s so that t becomes a subsequence of the modified string.

A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.

Example: If s = "coaching" and t = "coding", we need to append 2 characters because "coaching" already contains "co" as a subsequence, but we need to add "ding" to get the full "coding" subsequence.

Input & Output

example_1.py — Basic Example

$ Input: s = "coaching", t = "coding"

› Output: 4

💡 Note: We can match 'c' and 'o' from "coaching" with the first two characters of "coding". We need to append "ding" (4 characters) to make "coding" a subsequence.

example_2.py — Complete Match

$ Input: s = "abcde", t = "ace"

› Output: 0

💡 Note: "ace" is already a subsequence of "abcde" (positions 0, 2, 4), so we don't need to append any characters.

example_3.py — No Match

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

› Output: 3

💡 Note: None of the characters in "xyz" match with "abc", so we need to append all 3 characters of "abc".

Visualization

Tap to expand

Understanding the Visualization

Start with Both Lists

You have your ingredients (s) and the recipe requirements (t)

Match in Order

Go through your ingredients and check off recipe items in sequence

Count Missing Items

Whatever recipe items couldn't be checked off need to be purchased

Key Takeaway

🎯 Key Insight: We only need to find the longest prefix of the target that exists as a subsequence in the source, then append the remaining suffix.

Time & Space Complexity

Time Complexity

⏱️

O(2^n * m)

We generate 2^n subsequences where n is length of s, and for each we compare with t of length m

⚠ Quadratic Growth

Space Complexity

O(2^n)

We need to store all possible subsequences

⚠ Quadratic Space

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist only of lowercase English letters
Follow-up: Can you solve this in O(n + m) time and O(1) space?

Asked in

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

The optimal solution uses the two pointers technique to traverse both strings simultaneously. We maintain one pointer for each string and advance the target pointer only when characters match. The remaining unmatched characters in the target string represent the minimum characters to append. This achieves O(n + m) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subsequences)	O(2^n * m)	O(2^n)	Generate all possible subsequences of s and check if any matches a prefix of t
Two Pointers (Optimal)	O(n + m)	O(1)	Use one pointer for each string to find the longest matching subsequence

Brute Force (Check All Subsequences) — Algorithm Steps

Generate all possible subsequences of string s
For each subsequence, check how many characters from the beginning of t it matches
Keep track of the maximum number of characters matched
Return length of t minus the maximum matched characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subsequences

Create all possible subsequences of string s

Match Each Subsequence

Check how many characters each subsequence matches with t from the beginning

Find Maximum

Keep track of the maximum number of characters matched

Calculate Result

Return t.length - maxMatched

Code -

solution.c — C

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

int appendCharacters(char* s, char* t) {
    int sLen = strlen(s);
    int tLen = strlen(t);
    int maxMatched = 0;
    
    // Generate all subsequences using bit manipulation
    for (int mask = 0; mask < (1 << sLen); mask++) {
        char subseq[1001] = {0};
        int subseqLen = 0;
        
        for (int i = 0; i < sLen; i++) {
            if (mask & (1 << i)) {
                subseq[subseqLen++] = s[i];
            }
        }
        
        int matched = 0;
        int minLen = subseqLen < tLen ? subseqLen : tLen;
        
        for (int i = 0; i < minLen; i++) {
            if (subseq[i] == t[i]) {
                matched++;
            } else {
                break;
            }
        }
        
        if (matched > maxMatched) {
            maxMatched = matched;
        }
    }
    
    return tLen - maxMatched;
}

int main() {
    char s[1001], t[1001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    
    // Remove quotes and newlines
    s[strcspn(s, "\"\n")] = 0;
    t[strcspn(t, "\"\n")] = 0;
    
    printf("%d\n", appendCharacters(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * m)

We generate 2^n subsequences where n is length of s, and for each we compare with t of length m

⚠ Quadratic Growth

Space Complexity

O(2^n)

We need to store all possible subsequences

⚠ Quadratic Space

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist only of lowercase English letters
Follow-up: Can you solve this in O(n + m) time and O(1) space?

24.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force (Check All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler