Length of the Longest Alphabetical Continuous Substring

Length of the Longest Alphabetical Continuous Substring - Problem

String Medium

An alphabetical continuous string is a string consisting of consecutive letters in the alphabet. In other words, it is any substring of the string "abcdefghijklmnopqrstuvwxyz".

For example, "abc" is an alphabetical continuous string, while "acb" and "za" are not.

Given a string s consisting of lowercase letters only, return the length of the longest alphabetical continuous substring.

Input & Output

Example 1 — Basic Continuous Sequence

$ Input: s = "abacabad"

› Output: 2

💡 Note: The longest alphabetical continuous substring is "ab" which has length 2

Example 2 — Multiple Sequences

$ Input: s = "abcde"

› Output: 5

💡 Note: The entire string "abcde" is alphabetically continuous with length 5

Example 3 — Single Character

$ Input: s = "a"

› Output: 1

💡 Note: Single character strings have alphabetical continuous length of 1

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Input String

String with mixed alphabetical sequences

Find Sequences

Identify consecutive alphabet letter groups

Return Length

Length of the longest continuous sequence

Key Takeaway

🎯 Key Insight: Track current sequence length, reset when alphabetical continuity breaks

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is to track the current alphabetical sequence length in a single pass. The optimal approach uses a sliding window technique that resets the counter when continuity breaks. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Substrings	O(n³)	O(1)	Check every possible substring to see if it's alphabetically continuous
Sliding Window (One Pass)	O(n)	O(1)	Single pass tracking current consecutive sequence length

Brute Force - Check All Substrings — Algorithm Steps

Step 1: Generate all possible substrings of the input string
Step 2: For each substring, check if characters are consecutive in alphabet
Step 3: Track the maximum length of valid alphabetical continuous substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings

Check Continuity

Verify each substring is alphabetical

Track Maximum

Keep the longest valid length

Code -

solution.c — C

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

bool isAlphabeticalContinuous(char* s, int start, int end) {
    if (end - start <= 1) return true;
    
    for (int i = start + 1; i < end; i++) {
        if (s[i] != s[i-1] + 1) {
            return false;
        }
    }
    return true;
}

int solution(char* s) {
    int n = strlen(s);
    int maxLength = 1;  // At least one character
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (isAlphabeticalContinuous(s, i, j)) {
                int length = j - i;
                if (length > maxLength) {
                    maxLength = length;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;  // Remove newline
    
    int result = solution(s);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to check each substring

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track indices and maximum length

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

834 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 - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler