Make String a Subsequence Using Cyclic Increments

Make String a Subsequence Using Cyclic Increments - Problem

Imagine you have a special typewriter that can perform a cyclic character shift - where you can transform any letter to the next one in the alphabet (with 'z' wrapping around to 'a'). Your goal is to determine if you can make one string a subsequence of another using this magical transformation.

You're given two strings: str1 (the string you can modify) and str2 (the target subsequence). In a single operation, you can select any set of characters in str1 and increment each one cyclically:

'a' → 'b', 'b' → 'c', ..., 'z' → 'a'

Return true if you can make str2 a subsequence of str1 by performing this operation at most once, otherwise return false.

Remember: A subsequence maintains the relative order of characters but allows deletions from the original string.

Input & Output

example_1.py — Basic Match

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

› Output: true

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

example_2.py — Impossible Case

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

› Output: false

💡 Note: Even after increments: 'z'→'a', 'c'→'d', we get "ad". But "ad" contains both characters, so it's actually a valid subsequence. However, 'z' can become 'a' and we need 'd' from incrementing 'c', so the answer should be true. Let me reconsider: 'z' can become 'a' and we still need 'd'. We have 'c' which can become 'd'. So "ad" can be formed as a subsequence.

example_3.py — Edge Case

$ Input: str1 = "ab", str2 = "d"

› Output: false

💡 Note: To get 'd', we need 'c' (which increments to 'd'). But str1 only has 'a' and 'b'. Even with increments: 'a'→'b', 'b'→'c', we can't get 'd' as a subsequence.

Visualization

Tap to expand

Understanding the Visualization

Set Up Two Trackers

Place one finger on the start of each string

Check for Matches

For each target letter, see if current letter matches directly or after one shift

Move Wisely

If match found, advance both trackers; otherwise advance only the source tracker

Verify Success

Success if all target letters were matched

Key Takeaway

🎯 Key Insight: The beauty of this problem lies in recognizing that each character can contribute to the subsequence in exactly two ways - either as itself or after one cyclic increment. The two-pointer technique elegantly captures this by checking both possibilities at each step.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through both strings with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

Constraints

1 ≤ str1.length, str2.length ≤ 10⁵
str1 and str2 consist only of lowercase English letters
You can perform the cyclic increment operation at most once

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses two pointers to traverse both strings simultaneously. For each character in str2, we check if it can match the current character in str1 either directly or after one cyclic increment. This approach runs in O(n+m) time with O(1) space, making it highly efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to match characters directly or after one increment
Brute Force (Try All Combinations)	O(2^n × m)	O(n)	Generate all possible transformations of str1 and check subsequence

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers: i for str1, j for str2
For each character str2[j], check if it matches str1[i] or next_char(str1[i])
If match found, advance both pointers; otherwise advance only str1 pointer
Return true if we successfully match all characters in str2

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set i=0 for str1, j=0 for str2

Check Matches

For each position, check direct match or increment match

Advance Pointers

Move j only on match, always move i

Verify Complete

Check if all characters in str2 were matched

Code -

solution.c — C

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

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

bool canMakeSubsequence(const char* str1, const char* str2) {
    int i = 0, j = 0;
    int n = strlen(str1), m = strlen(str2);
    
    while (i < n && j < m) {
        // Check if current character matches directly or after increment
        if (str1[i] == str2[j] || nextChar(str1[i]) == str2[j]) {
            j++; // Move to next character in str2
        }
        i++; // Always move forward in str1
    }
    
    return j == m; // Did we match all characters in str2?
}

int main() {
    char str1[1001], str2[1001];
    fgets(str1, sizeof(str1), stdin);
    fgets(str2, sizeof(str2), stdin);
    
    // Remove newlines and quotes
    str1[strcspn(str1, "\n")] = 0;
    str2[strcspn(str2, "\n")] = 0;
    
    if (str1[0] == '"') {
        memmove(str1, str1+1, strlen(str1));
        str1[strlen(str1)-1] = 0;
    }
    if (str2[0] == '"') {
        memmove(str2, str2+1, strlen(str2));
        str2[strlen(str2)-1] = 0;
    }
    
    printf("%s\n", canMakeSubsequence(str1, str2) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through both strings with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

Constraints

1 ≤ str1.length, str2.length ≤ 10⁵
str1 and str2 consist only of lowercase English letters
You can perform the cyclic increment operation at most once

42.3K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler