Skip to content
Related Articles
Length of the longest substring with consecutive characters
• Last Updated : 03 Jun, 2021

Given string str of lowercase alphabets, the task is to find the length of the longest substring of characters in alphabetical order i.e. string “dfabck” will return 3. Note that the alphabetical order here is considered circular i.e. a, b, c, d, e, …, x, y, z, a, b, c, ….

Examples:

Input: str = “abcabcdefabc”
Output:
All valid sub-strings are “abc”, “abcdef” and “abc”
And, the length of the longest of these is 6

Input: str = “zabcd”
Output:

Approach:

1. Initialize i = 0 and len = 0 and starting from i find the ending index of the longest valid sub-string and store it, in end.
2. Now, update len = max(end – i + 1, len) and i = end + 1 (to get the next valid sub-string starting from the index end + 1) and repeat step 1 until i < len(str).
3. Print the value of len in the end.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include``using` `namespace` `std;` `    ``// Function to return the ending index for the``    ``// largest valid sub-string starting from index i``    ``int` `getEndingIndex(string str, ``int` `n, ``int` `i)``    ``{``        ``i++;``        ``while` `(i < n)``        ``{``            ``char` `curr = str[i];``            ``char` `prev = str[i-1];` `            ``// If the current character appears after``            ``// the previous character according to``            ``// the given circular alphabetical order``            ``if` `((curr == ``'a'` `&& prev == ``'z'``) ||``                ``(curr - prev == 1))``                ``i++;``            ``else``                ``break``;``        ``}` `        ``return` `i - 1;``    ``}` `    ``// Function to return the length of the longest``    ``// sub-string of consecutive characters from str``    ``int` `largestSubStr(string str, ``int` `n)``    ``{``        ``int` `len = 0;` `        ``int` `i = 0;``        ``while` `(i < n)``        ``{` `            ``// Valid sub-string exists from index``            ``// i to end``            ``int` `end = getEndingIndex(str, n, i);` `            ``// Update the length``            ``len = max(end - i + 1, len);``            ``i = end + 1;``        ``}` `        ``return` `len;``    ``}` `    ``// Driver code``    ``int` `main()``    ``{``        ``string str = ``"abcabcdefabc"``;``        ``int` `n = str.length();``        ``cout << (largestSubStr(str, n));``    ``}` `// This code is contributed by``// Surendra_Gangwar`

## Java

 `// Java implementation of the approach``class` `GFG {` `    ``// Function to return the ending index for the``    ``// largest valid sub-string starting from index i``    ``static` `int` `getEndingIndex(String str, ``int` `n, ``int` `i)``    ``{``        ``i++;``        ``while` `(i < n) {``            ``char` `curr = str.charAt(i);``            ``char` `prev = str.charAt(i - ``1``);` `            ``// If the current character appears after``            ``// the previous character  according to``            ``// the given circular alphabetical order``            ``if` `((curr == ``'a'` `&& prev == ``'z'``) ||``                ``(curr - prev == ``1``))``                ``i++;``            ``else``                ``break``;``        ``}` `        ``return` `i - ``1``;``    ``}` `    ``// Function to return the length of the longest``    ``// sub-string of consecutive characters from str``    ``static` `int` `largestSubStr(String str, ``int` `n)``    ``{``        ``int` `len = ``0``;` `        ``int` `i = ``0``;``        ``while` `(i < n) {` `            ``// Valid sub-string exists from index``            ``// i to end``            ``int` `end = getEndingIndex(str, n, i);` `            ``// Update the length``            ``len = Math.max(end - i + ``1``, len);``            ``i = end + ``1``;``        ``}` `        ``return` `len;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``String str = ``"abcabcdefabc"``;``        ``int` `n = str.length();` `        ``System.out.print(largestSubStr(str, n));``    ``}``}`

## Python3

 `# Python3 implementation of the approach` `# Function to return the ending index for the``# largest valid sub-str1ing starting from index i``def` `getEndingIndex(str1, n, i):` `    ``i ``+``=` `1``    ``while` `(i < n):``    ` `        ``curr ``=` `str1[i]``        ``prev ``=` `str1[i ``-` `1``]` `        ``# If the current character appears after``        ``# the previous character according to``        ``# the given circular alphabetical order``        ``if` `((curr ``=``=` `'a'` `and` `prev ``=``=` `'z'``) ``or``            ``(``ord``(curr) ``-` `ord``(prev) ``=``=` `1``)):``            ``i ``+``=` `1``        ``else``:``            ``break``    ` `    ``return` `i ``-` `1` `# Function to return the length of the``# longest sub-str1ing of consecutive``# characters from str1``def` `largestSubstr1(str1, n):` `    ``Len` `=` `0` `    ``i ``=` `0``    ``while` `(i < n):``    ` `        ``# Valid sub-str1ing exists from``        ``# index i to end``        ``end ``=` `getEndingIndex(str1, n, i)` `        ``# Update the Length``        ``Len` `=` `max``(end ``-` `i ``+` `1``, ``Len``)``        ``i ``=` `end ``+` `1``    ` `    ``return` `Len` `# Driver code``str1 ``=` `"abcabcdefabc"``n ``=` `len``(str1)``print``(largestSubstr1(str1, n))` `# This code is contributed by``# Mohit Kumar 29`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{` `    ``// Function to return the ending index for the``    ``// largest valid sub-string starting from index i``    ``static` `int` `getEndingIndex(``string` `str, ``int` `n, ``int` `i)``    ``{``        ``i++;``        ``while` `(i < n)``        ``{``            ``char` `curr = str[i];``            ``char` `prev = str[i - 1];` `            ``// If the current character appears after``            ``// the previous character according to``            ``// the given circular alphabetical order``            ``if` `((curr == ``'a'` `&& prev == ``'z'``) ||``                ``(curr - prev == 1))``                ``i++;``            ``else``                ``break``;``        ``}``        ``return` `i - 1;``    ``}` `    ``// Function to return the length of the longest``    ``// sub-string of consecutive characters from str``    ``static` `int` `largestSubStr(``string` `str, ``int` `n)``    ``{``        ``int` `len = 0;` `        ``int` `i = 0;``        ``while` `(i < n)``        ``{` `            ``// Valid sub-string exists from index``            ``// i to end``            ``int` `end = getEndingIndex(str, n, i);` `            ``// Update the length``            ``len = Math.Max(end - i + 1, len);``            ``i = end + 1;``        ``}``        ``return` `len;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``string` `str = ``"abcabcdefabc"``;``        ``int` `n = str.Length;``        ``Console.Write(largestSubStr(str, n));``    ``}``}` `// This code is contributed``// by Akanksha Rai`

## PHP

 ``

## Javascript

 ``
Output:
`6`

Time Complexity: O(n) where n is the length of the input string. Note that we increase the index by the end.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up