Length of the Longest Alphabetical Continuous Substring

Length of the Longest Alphabetical Continuous Substring - Problem

String Medium

Imagine you're reading the alphabet sequence "abcdefghijklmnopqrstuvwxyz" and looking for the longest streak of consecutive letters within a given string.

An alphabetical continuous substring is a sequence of consecutive letters from the alphabet. For example:

"abc" ✅ (consecutive: a→b→c)
"def" ✅ (consecutive: d→e→f)
"acb" ❌ (not consecutive)
"za" ❌ (z→a wraps around, not consecutive)

Goal: Given a string s of lowercase letters, find the length of the longest alphabetical continuous substring.

Input: A string s containing only lowercase English letters
Output: An integer representing the maximum length of any alphabetical continuous substring

Input & Output

example_1.py — Basic continuous sequence

$ Input: s = "abcxyz"

› Output: 3

💡 Note: The longest alphabetical continuous substrings are "abc" and "xyz", both with length 3. We return 3.

example_2.py — Single character

$ Input: s = "a"

› Output: 1

💡 Note: The string contains only one character, so the longest continuous substring has length 1.

example_3.py — No continuous sequences

$ Input: s = "acegik"

› Output: 1

💡 Note: No two adjacent characters are consecutive in the alphabet, so the longest continuous substring is any single character with length 1.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters
Alphabetical continuous means consecutive letters in the alphabet (a→b→c, not a→c→e)

Visualization

Tap to expand

Understanding the Visualization

Start the race

Initialize with first character, set current streak to 1

Check next runner

Compare if next character's ASCII is exactly +1 from previous

Extend or reset

If consecutive, extend streak; otherwise reset to 1

Track best time

Keep updating maximum length throughout the race

Key Takeaway

🎯 Key Insight: We only need to compare adjacent characters - if `char[i] == char[i-1] + 1`, the alphabetical sequence continues. This single comparison per character gives us optimal O(n) performance!

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a single pass sliding window technique with O(n) time complexity. We maintain a current streak length and compare adjacent characters using ASCII values to check if they're consecutive. When the sequence breaks, we reset the counter. This efficiently finds the longest alphabetical continuous substring in one traversal.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Sliding Window (Optimal)	O(n)	O(1)	Track current streak length while iterating through the string once
Brute Force (Check All Substrings)	O(n²)	O(1)	Check every possible substring to see if it's alphabetically continuous

Single Pass Sliding Window (Optimal) — Algorithm Steps

Initialize current_length = 1 and max_length = 1
Iterate through string starting from index 1
If current character is consecutive to previous, increment current_length
Otherwise, reset current_length to 1
Update max_length with the maximum value seen so far

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize counters

Set current_length = 1, max_length = 1

Compare adjacent chars

Check if next character is consecutive

Update counters

Extend streak or reset to 1

Track maximum

Keep the best length seen so far

Code -

solution.c — C

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

int findLongestContinuous(char* s) {
    int len = strlen(s);
    if (len == 0) return 0;
    
    int maxLength = 1;
    int currentLength = 1;
    
    // Single pass through the string
    for (int i = 1; i < len; i++) {
        // Check if current character is consecutive to previous
        if (s[i] == s[i-1] + 1) {
            currentLength++;
            if (currentLength > maxLength) {
                maxLength = currentLength;
            }
        } else {
            currentLength = 1;
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = '\0';
        memmove(s, s+1, strlen(s));
    }
    
    printf("%d\n", findLongestContinuous(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, checking each character once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for counters

✓ Linear Space

28.4K Views

Medium Frequency

~12 min Avg. Time

945 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

Single Pass Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler