Make String a Subsequence Using Cyclic Increments

Make String a Subsequence Using Cyclic Increments - Problem

You are given two 0-indexed strings str1 and str2.

In an operation, you select a set of indices in str1, and for each index i in the set, increment str1[i] to the next character cyclically. That is 'a' becomes 'b', 'b' becomes 'c', and so on, and 'z' becomes 'a'.

Return true if it is possible to make str2 a subsequence of str1 by performing the operation at most once, and false otherwise.

Note: A subsequence of a string is a new string that is formed from the original string by deleting some (possibly none) of the characters without disturbing the relative positions of the remaining characters.

Input & Output

Example 1 — Basic Match

$ Input: str1 = "abc", str2 = "acd"

› Output: true

💡 Note: We can increment str1[1] from 'b' to 'c' and str1[2] from 'c' to 'd', making str1 = "acd". Then "acd" is a subsequence of "acd".

Example 2 — No Match Possible

$ Input: str1 = "zc", str2 = "ad"

› Output: false

💡 Note: Even with increments: 'z'→'a' and 'c'→'d' gives "ad", but we need "ad" as subsequence. Since both characters are used, we can't form the subsequence.

Example 3 — Cyclic Wrap Around

$ Input: str1 = "za", str2 = "aa"

› Output: true

💡 Note: We can increment str1[0] from 'z' to 'a' (cyclic), making str1 = "aa". Then "aa" is a subsequence of "aa".

Constraints

1 ≤ str1.length, str2.length ≤ 10⁵
str1 and str2 consist of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 M Meta 12 a Amazon 10

The key insight is that each character can either stay the same or be incremented by one cyclically. The optimal approach uses two pointers to greedily match characters in a single pass. Time: O(n + m), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

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

For each character in str1, we have 2 choices: keep it as is or increment it cyclically. Generate all 2^n possible strings and check if str2 is a subsequence of any.

Two Pointers - Greedy Matching

⏱️ Time: O(n + m) Space: O(1)

Use two pointers to traverse both strings. For each character in str2, try to find a matching character in str1 (either exact match or one increment away). This greedy approach works because we want the earliest possible match.

Brute Force - Try All Combinations — Algorithm Steps

Generate all 2^n possible strings by incrementing different subsets of characters
For each generated string, check if str2 is a subsequence
Return true if any generated string contains str2 as subsequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Variants

Create all 2^n possible strings by incrementing different character sets

Check Subsequence

For each variant, check if str2 is a subsequence

Return Result

Return true if any variant contains str2 as subsequence

Code -

solution.c — C

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

bool isSubsequence(const char* s, const char* t) {
    int i = 0;
    int tLen = strlen(t);
    for (int j = 0; s[j]; j++) {
        if (i < tLen && s[j] == t[i]) {
            i++;
        }
    }
    return i == tLen;
}

char nextChar(char c) {
    return (c - 'a' + 1) % 26 + 'a';
}

bool solution(char* str1, char* str2) {
    int n = strlen(str1);
    char* modified = malloc(n + 1);
    modified[n] = '\0';
    
    // Try all 2^n combinations
    for (int mask = 0; mask < (1 << n); mask++) {
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                modified[i] = nextChar(str1[i]);
            } else {
                modified[i] = str1[i];
            }
        }
        if (isSubsequence(modified, str2)) {
            free(modified);
            return true;
        }
    }
    free(modified);
    return false;
}

int main() {
    char str1[1001], str2[1001];
    fgets(str1, sizeof(str1), stdin);
    str1[strcspn(str1, "\n")] = 0;
    fgets(str2, sizeof(str2), stdin);
    str2[strcspn(str2, "\n")] = 0;
    
    bool result = solution(str1, str2);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n × m)

2^n possible strings to generate, each subsequence check takes O(m) time

✓ Linear Growth

Space Complexity

O(n)

Space for generating each string variant

✓ Linear Space

28.5K Views

Medium Frequency

~18 min Avg. Time

845 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler