Move from brute-force thinking to an efficient approach using two pointers strategy.
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.
Example 1:
Input: str1 = "abc", str2 = "ad" Output: true Explanation: Select index 2 in str1. Increment str1[2] to become 'd'. Hence, str1 becomes "abd" and str2 is now a subsequence. Therefore, true is returned.
Example 2:
Input: str1 = "zc", str2 = "ad" Output: true Explanation: Select indices 0 and 1 in str1. Increment str1[0] to become 'a'. Increment str1[1] to become 'd'. Hence, str1 becomes "ad" and str2 is now a subsequence. Therefore, true is returned.
Example 3:
Input: str1 = "ab", str2 = "d" Output: false Explanation: In this example, it can be shown that it is impossible to make str2 a subsequence of str1 using the operation at most once. Therefore, false is returned.
Constraints:
1 <= str1.length <= 1051 <= str2.length <= 105str1 and str2 consist of only lowercase English letters.Problem summary: 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.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Two Pointers
"abc" "ad"
"zc" "ad"
"ab" "d"
is-subsequence)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2825: Make String a Subsequence Using Cyclic Increments
class Solution {
public boolean canMakeSubsequence(String str1, String str2) {
int i = 0, n = str2.length();
for (char c : str1.toCharArray()) {
char d = c == 'z' ? 'a' : (char) (c + 1);
if (i < n && (str2.charAt(i) == c || str2.charAt(i) == d)) {
++i;
}
}
return i == n;
}
}
// Accepted solution for LeetCode #2825: Make String a Subsequence Using Cyclic Increments
func canMakeSubsequence(str1 string, str2 string) bool {
i, n := 0, len(str2)
for _, c := range str1 {
d := byte('a')
if c != 'z' {
d = byte(c + 1)
}
if i < n && (str2[i] == byte(c) || str2[i] == d) {
i++
}
}
return i == n
}
# Accepted solution for LeetCode #2825: Make String a Subsequence Using Cyclic Increments
class Solution:
def canMakeSubsequence(self, str1: str, str2: str) -> bool:
i = 0
for c in str1:
d = "a" if c == "z" else chr(ord(c) + 1)
if i < len(str2) and str2[i] in (c, d):
i += 1
return i == len(str2)
// Accepted solution for LeetCode #2825: Make String a Subsequence Using Cyclic Increments
// Rust example auto-generated from java reference.
// Replace the signature and local types with the exact LeetCode harness for this problem.
impl Solution {
pub fn rust_example() {
// Port the logic from the reference block below.
}
}
// Reference (java):
// // Accepted solution for LeetCode #2825: Make String a Subsequence Using Cyclic Increments
// class Solution {
// public boolean canMakeSubsequence(String str1, String str2) {
// int i = 0, n = str2.length();
// for (char c : str1.toCharArray()) {
// char d = c == 'z' ? 'a' : (char) (c + 1);
// if (i < n && (str2.charAt(i) == c || str2.charAt(i) == d)) {
// ++i;
// }
// }
// return i == n;
// }
// }
// Accepted solution for LeetCode #2825: Make String a Subsequence Using Cyclic Increments
function canMakeSubsequence(str1: string, str2: string): boolean {
let i = 0;
const n = str2.length;
for (const c of str1) {
const d = c === 'z' ? 'a' : String.fromCharCode(c.charCodeAt(0) + 1);
if (i < n && (str2[i] === c || str2[i] === d)) {
++i;
}
}
return i === n;
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair of elements. The outer loop picks one element, the inner loop scans the rest. For n elements that is n × (n−1)/2 comparisons = O(n²). No extra memory — just two loop variables.
Each pointer traverses the array at most once. With two pointers moving inward (or both moving right), the total number of steps is bounded by n. Each comparison is O(1), giving O(n) overall. No auxiliary data structures are needed — just two index variables.
Review these before coding to avoid predictable interview regressions.
Wrong move: Advancing both pointers shrinks the search space too aggressively and skips candidates.
Usually fails on: A valid pair can be skipped when only one side should move.
Fix: Move exactly one pointer per decision branch based on invariant.