Loading…

easyStrings0Sometimes asked

HackerRank in a String

Q: How do you solve HackerRank in a String using the Recursive Subsequence Check (Baseline) approach?

When to use it: Mention to show you understand the recursive subsequence definition, then note the greedy one-pass is simpler and avoids overhead. Express the definition directly: `pat` is a subsequence of `s` starting at offsets `i, j` if either the pattern is exhausted (`j == len(pat)` → true), or `s` is exhausted first (false), or we match `s[i]` against `pat[j]` when equal and otherwise skip `s[i]`. **Why it's correct.** It mirrors the formal recursive definition of 'subsequence', so it cannot be wrong. **Why we don't ship it.** Recursion adds call-stack overhead and risks deep frames for long inputs, all to express something a single `for` loop captures cleanly. It's useful as a conceptual bridge — note that whenever `s[i] == pat[j]` you can *safely* consume the match (no need to also explore skipping it), which is exactly the greedy insight the iterative version exploits. Time complexity: O(n). Space complexity: O(n) recursion.

Q: How do you solve HackerRank in a String using the Greedy Two-Pointer Scan (Optimal) approach?

When to use it: The answer they want — one pass, advance the pattern index only on matches. Hold a pointer `j` into the target word `"hackerrank"`. Scan `s` left to right; whenever the current character equals `pat[j]`, advance `j`. After the scan, return `"YES"` iff `j` reached the end of the pattern. **Why greedy (earliest match) is optimal.** Suppose `pat[j]` first occurs at position `p` in the remaining input. Matching it at `p` rather than some later position `p' > p` can only help: it leaves the longer suffix `s[p+1:]` available for the rest of the pattern, which is a superset of `s[p'+1:]`. So if any valid matching exists, the greedy earliest-match matching also exists. There's never a reason to pass up the first opportunity. **Why advance only on a match.** `j` represents 'how much of the pattern is already placed'. Bumping it without a real match would claim progress that didn't happen, accepting strings that aren't actually supersequences. **Why the success test is `j == len(pat)`.** Reaching the end of `s` proves nothing; what matters is whether all ten pattern letters got placed. The double `r` falls out naturally — after the first `r` matches, `j` points at the second `r` and waits for another one. **Why O(1) space.** Just two indices; no recursion, no auxiliary structures. Time complexity: O(n). Space complexity: O(1).

Arrays & Hashing · 63 of 83 · 6 min

Given a string s, determine whether it contains the word "hackerrank" as a subsequence — that is, whether you can obtain "hackerrank" by deleting zero or more characters from s without reordering the rest.

Return "YES" if it does, "NO" otherwise.

In plain English

Subsequence means the letters of "hackerrank" must appear in s in the same relative order, but not necessarily next to each other. So we hunt for an 'h', then somewhere after it an 'a', then a 'c', and so on through the whole word. If we can thread all ten letters in order, the answer is YES.

Examples

Example 1

Input: s = "hereiamstackerrank"
Output: YES
Note: Thread h-a-c-k-e-r-r-a-n-k through: h(0)…a…c…k…e…r…r…a…n…k all appear in order, so 'hackerrank' is a subsequence.

Example 2

Input: s = "hackerworld"
Output: NO
Note: We match h,a,c,k,e,r but then need a second 'r' followed by a-n-k; 'world' provides none of that in order → NO.

Example 3

Input: s = "hhaacckkekraraannk"
Output: YES
Note: Greedy matches h(0), a(2), c(4), k(6), e(8), r(10), r(12), a(13), n(15), k(17) — all ten letters in order.

Constraints

1 ≤ |s| ≤ 10⁴
s consists of lowercase English letters
The target word is the fixed string "hackerrank" (length 10)

Clarifying questions4First question: Subsequence or substring?Explore questions

Q1.Subsequence or substring?
Subsequence — characters in order with arbitrary gaps allowed. 'hhaacckk…' qualifies even though 'hackerrank' isn't contiguous.
Q2.Is the target always exactly 'hackerrank'?
Yes — a fixed 10-letter word with a double 'r'. Both 'r's must be matched.
Q3.Case sensitivity?
All lowercase, so no normalization needed.
Q4.What if s is shorter than 10 characters?
Then it can't contain all ten letters in order → NO. The pointer simply never reaches the end of the pattern.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Check whether the fixed word "hackerrank" appears as a subsequence (not substring) of the input. Walk one pointer through the input and a second pointer through "hackerrank"; whenever the current input character matches the current target character, advance the target pointer. If the target pointer reaches the end, every letter was matched in order → "YES", otherwise "NO". O(n) time, O(1) space.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you recognize subsequence (order-preserving, gaps allowed) versus substring (contiguous), and implement the greedy two-pointer match correctly including the double 'r'.

Where candidates slip

Treating it as a substring/contains check, or advancing the pattern pointer even when characters don't match, or testing the wrong success condition (end of s instead of end of pattern).

How to stand out

Say why greedy is correct: taking the earliest match for each pattern letter is never worse than waiting, because it preserves the maximum remaining suffix of s for the rest of the pattern.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Recursive Subsequence Check (Baseline)	`O(n)`	`O(n) recursion`	Mention to show you understand the recursive subsequence definition, then note the greedy one-pass is simpler and avoids overhead.	Read
2	Greedy Two-Pointer Scan (Optimal)Optimal	`O(n)`	`O(1)`	The answer they want — one pass, advance the pattern index only on matches.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewj = 0 (into 'hackerrank')c == pat[j]?YesNoExplore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Recursive Subsequence Check (Baseline)

TimeO(n)SpaceO(n) recursion

Mention to show you understand the recursive subsequence definition, then note the greedy one-pass is simpler and avoids overhead.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Define match(i, j): can pat[j:] be a subsequence of s[i:]?

2Hint 2Explore hint

If pat[j] == s[i], you may consume both; you may also always skip s[i]. Recurse.

3Hint 3Explore hint

Base cases: j past the pattern → true; i past s with j remaining → false.

A · Core idea

Express the definition directly: pat is a subsequence of s starting at offsets i, j if either the pattern is exhausted (j == len(pat) → true), or s is exhausted first (false), or we match s[i] against pat[j] when equal and otherwise skip s[i].

Why it's correct. It mirrors the formal recursive definition of 'subsequence', so it cannot be wrong.

Why we don't ship it. Recursion adds call-stack overhead and risks deep frames for long inputs, all to express something a single for loop captures cleanly. It's useful as a conceptual bridge — note that whenever s[i] == pat[j] you can safely consume the match (no need to also explore skipping it), which is exactly the greedy insight the iterative version exploits.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "hackerworld"

Array state

match hacker

h a c k e r consumed

[0]

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

Current pointerResolved stateNot processed

Final resultNO

C · Code with teaching comments

Reference implementation previewprivate static final String PAT = "hackerrank"; public String hackerrankInString(String s) { return match(s, 0, 0) ? "YES" : "NO"; }Explore the full code

solution.javaJava

Recursive Subsequence Check (Baseline) — reference

3 teaching notes

1
private static final String PAT = "hackerrank";
2
 
3
public String hackerrankInString(String s) {
4
    return match(s, 0, 0) ? "YES" : "NO";
5
}
6
 
7
private boolean match(String s, int i, int j) {
8
    // Whole pattern matched → success.
9
    if (j == PAT.length()) return true;
10
    // Ran out of input with pattern left → failure.
11
    if (i == s.length()) return false;
12
    if (s.charAt(i) == PAT.charAt(j)) {
13
        return match(s, i + 1, j + 1);
14
    }
15
    return match(s, i + 1, j);
16
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.16 lines

D · Why it works and complexityO(n) timeO(n) recursion spaceOpen the invariant and proofExplore the proof

The recursion has a special property: when characters match, you never need to explore not taking the match. That collapses the branching recursion into a deterministic single forward scan — the greedy two-pointer.

ComplexityO(n) time, O(n) recursion space — Because the pattern is matched greedily even in recursion (once a needed character is found, taking it is safe), the recursion depth is O(n) and each character is visited a constant number of times → O(n) time, O(n) stack space.

E · Edge cases and pitfalls5s = "hackerrank" — Exact match → YES.Explore edge cases

Edge cases handled

s = "hackerrank"Exact match → YES.
s = ""Input exhausted immediately → NO.

Pitfalls

Deep recursion stack for long inputs.
Exploring the skip branch even on a match — unnecessary work.
Wrong base-case order (check pattern exhaustion before input exhaustion).

03.2

Approach 2 of 2 · Optimal

Greedy Two-Pointer Scan (Optimal)

TimeO(n)SpaceO(1)

The answer they want — one pass, advance the pattern index only on matches.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Keep an index j into 'hackerrank'. What do you do with j as you read each character of s?

2Hint 2Explore hint

If the current character equals pat[j], advance j; otherwise leave j alone and move on.

3Hint 3Explore hint

After scanning s, the answer is YES exactly when j reached the length of the pattern.

A · Core idea

Hold a pointer j into the target word "hackerrank". Scan s left to right; whenever the current character equals pat[j], advance j. After the scan, return "YES" iff j reached the end of the pattern.

Why greedy (earliest match) is optimal. Suppose pat[j] first occurs at position p in the remaining input. Matching it at p rather than some later position p' > p can only help: it leaves the longer suffix s[p+1:] available for the rest of the pattern, which is a superset of s[p'+1:]. So if any valid matching exists, the greedy earliest-match matching also exists. There's never a reason to pass up the first opportunity.

Why advance only on a match. j represents 'how much of the pattern is already placed'. Bumping it without a real match would claim progress that didn't happen, accepting strings that aren't actually supersequences.

Why the success test is `j == len(pat)`. Reaching the end of s proves nothing; what matters is whether all ten pattern letters got placed. The double r falls out naturally — after the first r matches, j points at the second r and waits for another one.

Why O(1) space. Just two indices; no recursion, no auxiliary structures.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "hhaacckkekraraannk"

Array state

early

match h,a,c,k,e → j=5

[0]

[1]

[2]

[3]

[4]

j ↓

[5]

[6]

[7]

[8]

[9]

Current pointerResolved stateNot processed

Final resultYES

C · Code with teaching comments

solution.javaJava

Greedy Two-Pointer Scan (Optimal) — optimal

3 teaching notes

1
public String hackerrankInString(String s) {
2
    String pat = "hackerrank";
3
    int j = 0;
4
    // Stop early once the whole pattern is matched.
5
    for (int i = 0; i < s.length() && j < pat.length(); i++) {
6
        if (s.charAt(i) == pat.charAt(j)) {
7
            j++;
8
        }
9
    }
10
    // Success is matching all 10 letters, not reaching the end of s.
11
    return j == pat.length() ? "YES" : "NO";
12
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.12 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

Subsequence existence is the canonical greedy-pointer problem: a single forward sweep with a pattern cursor that only moves on a hit. The 'earliest match is safe' argument is the same exchange argument behind many greedy proofs.

ComplexityO(n) time, O(1) space — A single sweep over s with O(1) work per character → O(n) time. Only two integer pointers are kept → O(1) space.

E · Edge cases and pitfalls6s = "hackerrank" — Exact match, j reaches 10 → YES.Explore edge cases

Edge cases handled

s = "hackerrank"Exact match, j reaches 10 → YES.
s = "hereiamstackerrank"Letters appear in order with gaps → j reaches 10 → YES.
s = "rhbaasdndfsdskgbfefdbrdfintwrwwrgikjwtrenaqyznnative"Pattern can't be threaded in order → NO.

Pitfalls

Using contains/indexOf — that tests substring, not subsequence.
Advancing j on non-matches, accepting strings that aren't supersequences.
Returning based on i reaching the end of s instead of j reaching the pattern length.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic String hackerrankInString(String s) { String pat = "hackerrank"; int j = 0; for (int i = 0; i < s.length() && j < pat.length(); i++) { if (s.charAt(i) == pat.charAt(j)) {Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Substring instead of subsequence

'hackerrank' rarely appears contiguously; the problem allows gaps. Using contains() returns NO for valid inputs like 'hhaacckk…'.

Explore the code comparison

Don't write this

return s.contains("hackerrank") ? "YES" : "NO";

Write this instead

int j = 0;
for (int i = 0; i < s.length() && j < 10; i++)
    if (s.charAt(i) == "hackerrank".charAt(j)) j++;
return j == 10 ? "YES" : "NO";

Advancing the pattern pointer on mismatch

j tracks confirmed progress through the pattern. Bumping it without a match fabricates matches and accepts strings missing required letters.

Explore the code comparison

Don't write this

for c in s:
    if c == pat[j]:
        j += 1
    else:
        j += 1  # WRONG

Write this instead

for c in s:
    if j < len(pat) and c == pat[j]:
        j += 1

Wrong success condition

The answer depends on whether the pattern was fully matched, not on consuming all of s. Test j == len(pattern).

Explore the code comparison

Don't write this

return "YES" if i == len(s) else "NO"

Write this instead

return "YES" if j == len(pat) else "NO"

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Greedy subsequence matching with two pointers

Code pattern to memorize

j = 0; pat = "hackerrank"
for c in s:
    if j < len(pat) and c == pat[j]: j++
return "YES" if j == len(pat) else "NO"

Rules to remember

1It's a subsequence check — characters must appear in order but not contiguously.
2Advance the pattern pointer only on a match; never skip a needed letter.
3Greedy (take the earliest match) is provably optimal for subsequence existence.
4Success condition is j == len(pattern) after the scan, not reaching the end of s.
5Note hackerrank has a double r — both must be matched in sequence.

Use this pattern when

Test whether a fixed pattern is a subsequence of a larger string
Order matters but gaps are allowed between matched characters
Single pass, O(1) extra space is desired
Matching is greedy — earliest valid character is always safe to take

Choose another pattern when

Pattern must be contiguous → substring search (KMP / indexOf), not subsequence
Count the number of distinct subsequence matches → DP, not a single greedy pass
Find the shortest window containing the pattern → sliding window
Pattern is not fixed and very long → still O(n·m) greedy, fine, but think about it

Interview takeaway

Subsequence existence is a one-pass greedy: keep a pointer into the pattern and bump it on each match. Taking the earliest possible match never hurts — it leaves the most of the input for the remaining pattern letters. Reaching the pattern's end means success.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternGreedy subsequence matching. To test whether a fixed pattern is a subsequence, keep a cursor into the pattern and advance it only on matches during a single pass. The earliest-match-is-safe exchange argument makes greedy optimal — the same idea powers Is Subsequence and Number of Matching Subsequences.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Is Subsequence
Exact same greedy two-pointer, but the pattern is an arbitrary input string.
Number of Matching Subsequences
Coming soon
Many patterns against one s — bucket waiting patterns by their next-needed char.
Distinct Subsequences
Coming soon
Count how many ways, not just existence → DP over both strings.
Longest Word in Dictionary through Deleting
Coming soon
Subsequence check applied to each dictionary word; keep the best.

Same pattern

←

Anagram

Continue · Next problem

Making Anagrams

easyStrings0Sometimes asked

HackerRank in a String

Arrays & Hashing · 63 of 83 · 6 min

Return "YES" if it does, "NO" otherwise.

In plain English

Examples

Example 1

Input: s = "hereiamstackerrank"
Output: YES
Note: Thread h-a-c-k-e-r-r-a-n-k through: h(0)…a…c…k…e…r…r…a…n…k all appear in order, so 'hackerrank' is a subsequence.

Example 2

Input: s = "hackerworld"
Output: NO
Note: We match h,a,c,k,e,r but then need a second 'r' followed by a-n-k; 'world' provides none of that in order → NO.

Example 3

Input: s = "hhaacckkekraraannk"
Output: YES
Note: Greedy matches h(0), a(2), c(4), k(6), e(8), r(10), r(12), a(13), n(15), k(17) — all ten letters in order.

Constraints

1 ≤ |s| ≤ 10⁴
s consists of lowercase English letters
The target word is the fixed string "hackerrank" (length 10)

Clarifying questions4First question: Subsequence or substring?Explore questions

Q1.Subsequence or substring?
Subsequence — characters in order with arbitrary gaps allowed. 'hhaacckk…' qualifies even though 'hackerrank' isn't contiguous.
Q2.Is the target always exactly 'hackerrank'?
Yes — a fixed 10-letter word with a double 'r'. Both 'r's must be matched.
Q3.Case sensitivity?
All lowercase, so no normalization needed.
Q4.What if s is shorter than 10 characters?
Then it can't contain all ten letters in order → NO. The pointer simply never reaches the end of the pattern.

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you recognize subsequence (order-preserving, gaps allowed) versus substring (contiguous), and implement the greedy two-pointer match correctly including the double 'r'.

Where candidates slip

Treating it as a substring/contains check, or advancing the pattern pointer even when characters don't match, or testing the wrong success condition (end of s instead of end of pattern).

How to stand out

Say why greedy is correct: taking the earliest match for each pattern letter is never worse than waiting, because it preserves the maximum remaining suffix of s for the rest of the pattern.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Recursive Subsequence Check (Baseline)	`O(n)`	`O(n) recursion`	Mention to show you understand the recursive subsequence definition, then note the greedy one-pass is simpler and avoids overhead.	Read
2	Greedy Two-Pointer Scan (Optimal)Optimal	`O(n)`	`O(1)`	The answer they want — one pass, advance the pattern index only on matches.	Read

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Recursive Subsequence Check (Baseline)

TimeO(n)SpaceO(n) recursion

Mention to show you understand the recursive subsequence definition, then note the greedy one-pass is simpler and avoids overhead.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Define match(i, j): can pat[j:] be a subsequence of s[i:]?

2Hint 2Explore hint

If pat[j] == s[i], you may consume both; you may also always skip s[i]. Recurse.

3Hint 3Explore hint

Base cases: j past the pattern → true; i past s with j remaining → false.

A · Core idea

Why it's correct. It mirrors the formal recursive definition of 'subsequence', so it cannot be wrong.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "hackerworld"

Array state

match hacker

h a c k e r consumed

[0]

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

Current pointerResolved stateNot processed

Final resultNO

C · Code with teaching comments

Reference implementation previewprivate static final String PAT = "hackerrank"; public String hackerrankInString(String s) { return match(s, 0, 0) ? "YES" : "NO"; }Explore the full code

solution.javaJava

Recursive Subsequence Check (Baseline) — reference

3 teaching notes

1
private static final String PAT = "hackerrank";
2
 
3
public String hackerrankInString(String s) {
4
    return match(s, 0, 0) ? "YES" : "NO";
5
}
6
 
7
private boolean match(String s, int i, int j) {
8
    // Whole pattern matched → success.
9
    if (j == PAT.length()) return true;
10
    // Ran out of input with pattern left → failure.
11
    if (i == s.length()) return false;
12
    if (s.charAt(i) == PAT.charAt(j)) {
13
        return match(s, i + 1, j + 1);
14
    }
15
    return match(s, i + 1, j);
16
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.16 lines

D · Why it works and complexityO(n) timeO(n) recursion spaceOpen the invariant and proofExplore the proof

E · Edge cases and pitfalls5s = "hackerrank" — Exact match → YES.Explore edge cases

Edge cases handled

s = "hackerrank"Exact match → YES.
s = ""Input exhausted immediately → NO.

Pitfalls

Deep recursion stack for long inputs.
Exploring the skip branch even on a match — unnecessary work.
Wrong base-case order (check pattern exhaustion before input exhaustion).

03.2

Approach 2 of 2 · Optimal

Greedy Two-Pointer Scan (Optimal)

TimeO(n)SpaceO(1)

The answer they want — one pass, advance the pattern index only on matches.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Keep an index j into 'hackerrank'. What do you do with j as you read each character of s?

2Hint 2Explore hint

If the current character equals pat[j], advance j; otherwise leave j alone and move on.

3Hint 3Explore hint

After scanning s, the answer is YES exactly when j reached the length of the pattern.

A · Core idea

Why O(1) space. Just two indices; no recursion, no auxiliary structures.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

s = "hhaacckkekraraannk"

Array state

early

match h,a,c,k,e → j=5

[0]

[1]

[2]

[3]

[4]

j ↓

[5]

[6]

[7]

[8]

[9]

Current pointerResolved stateNot processed

Final resultYES

C · Code with teaching comments

solution.javaJava

Greedy Two-Pointer Scan (Optimal) — optimal

3 teaching notes

1
public String hackerrankInString(String s) {
2
    String pat = "hackerrank";
3
    int j = 0;
4
    // Stop early once the whole pattern is matched.
5
    for (int i = 0; i < s.length() && j < pat.length(); i++) {
6
        if (s.charAt(i) == pat.charAt(j)) {
7
            j++;
8
        }
9
    }
10
    // Success is matching all 10 letters, not reaching the end of s.
11
    return j == pat.length() ? "YES" : "NO";
12
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.12 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

ComplexityO(n) time, O(1) space — A single sweep over s with O(1) work per character → O(n) time. Only two integer pointers are kept → O(1) space.

E · Edge cases and pitfalls6s = "hackerrank" — Exact match, j reaches 10 → YES.Explore edge cases

Edge cases handled

s = "hackerrank"Exact match, j reaches 10 → YES.
s = "hereiamstackerrank"Letters appear in order with gaps → j reaches 10 → YES.
s = "rhbaasdndfsdskgbfefdbrdfintwrwwrgikjwtrenaqyznnative"Pattern can't be threaded in order → NO.

Pitfalls

Using contains/indexOf — that tests substring, not subsequence.
Advancing j on non-matches, accepting strings that aren't supersequences.
Returning based on i reaching the end of s instead of j reaching the pattern length.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Substring instead of subsequence

'hackerrank' rarely appears contiguously; the problem allows gaps. Using contains() returns NO for valid inputs like 'hhaacckk…'.

Explore the code comparison

Don't write this

return s.contains("hackerrank") ? "YES" : "NO";

Write this instead

int j = 0;
for (int i = 0; i < s.length() && j < 10; i++)
    if (s.charAt(i) == "hackerrank".charAt(j)) j++;
return j == 10 ? "YES" : "NO";

Advancing the pattern pointer on mismatch

j tracks confirmed progress through the pattern. Bumping it without a match fabricates matches and accepts strings missing required letters.

Explore the code comparison

Don't write this

for c in s:
    if c == pat[j]:
        j += 1
    else:
        j += 1  # WRONG

Write this instead

for c in s:
    if j < len(pat) and c == pat[j]:
        j += 1

Wrong success condition

The answer depends on whether the pattern was fully matched, not on consuming all of s. Test j == len(pattern).

Explore the code comparison

Don't write this

return "YES" if i == len(s) else "NO"

Write this instead

return "YES" if j == len(pat) else "NO"

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Greedy subsequence matching with two pointers

Code pattern to memorize

j = 0; pat = "hackerrank"
for c in s:
    if j < len(pat) and c == pat[j]: j++
return "YES" if j == len(pat) else "NO"

Rules to remember

1It's a subsequence check — characters must appear in order but not contiguously.
2Advance the pattern pointer only on a match; never skip a needed letter.
3Greedy (take the earliest match) is provably optimal for subsequence existence.
4Success condition is j == len(pattern) after the scan, not reaching the end of s.
5Note hackerrank has a double r — both must be matched in sequence.

Use this pattern when

Test whether a fixed pattern is a subsequence of a larger string
Order matters but gaps are allowed between matched characters
Single pass, O(1) extra space is desired
Matching is greedy — earliest valid character is always safe to take

Choose another pattern when

Pattern must be contiguous → substring search (KMP / indexOf), not subsequence
Count the number of distinct subsequence matches → DP, not a single greedy pass
Find the shortest window containing the pattern → sliding window
Pattern is not fixed and very long → still O(n·m) greedy, fine, but think about it

Interview takeaway

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Is Subsequence
Exact same greedy two-pointer, but the pattern is an arbitrary input string.
Number of Matching Subsequences
Coming soon
Many patterns against one s — bucket waiting patterns by their next-needed char.
Distinct Subsequences
Coming soon
Count how many ways, not just existence → DP over both strings.
Longest Word in Dictionary through Deleting
Coming soon
Subsequence check applied to each dictionary word; keep the best.

Same pattern

←

Anagram

Continue · Next problem

Making Anagrams