GeeksforGeeks App
Open App
Browser
Continue

# Length of the longest substring with no consecutive same letters

Given a string str, the task is to find the length of the longest sub-string which does not have any pair of consecutive same characters.
Examples:

Input: str = “abcdde”
Output:
“abcd” is the longest
Input: str = “ccccdeededff”
Output:
“ededf” is the longest

Approach: The following steps can be followed to solve the above problem:

• Initialize cnt and maxi as 1 initially, since this is the minimum answer of the length of the longest answer.
• Iterate in the string from 1 to n – 1 and increment cnt by 1 if str[i] != str[i – 1].
• If str[i] == str[i – 1], then re-initialize cnt as 1 and maxi to max(maxi, cnt).

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the length``// of the required sub-string``int` `longestSubstring(string s)``{``    ``int` `cnt = 1;``    ``int` `maxi = 1;` `    ``// Get the length of the string``    ``int` `n = s.length();` `    ``// Iterate in the string``    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Check for not consecutive``        ``if` `(s[i] != s[i - 1])``            ``cnt++;``        ``else` `{` `            ``// If cnt greater than maxi``            ``maxi = max(cnt, maxi);` `            ``// Re-initialize``            ``cnt = 1;``        ``}``    ``}` `    ``// Check after iteration``    ``// is complete``    ``maxi = max(cnt, maxi);` `    ``return` `maxi;``}` `// Driver code``int` `main()``{``    ``string s = ``"abcdde"``;``    ``cout << longestSubstring(s);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.lang.Math;` `class` `GfG``{` `    ``// Function to return the length``    ``// of the required sub-string``    ``static` `int` `longestSubstring(String s)``    ``{``        ``int` `cnt = ``1``, maxi = ``1``;``    ` `        ``// Get the length of the string``        ``int` `n = s.length();``    ` `        ``// Iterate in the string``        ``for` `(``int` `i = ``1``; i < n; i++)``        ``{``    ` `            ``// Check for not consecutive``            ``if` `(s.charAt(i) != s.charAt(i-``1``))``                ``cnt++;``            ``else``            ``{``    ` `                ``// If cnt greater than maxi``                ``maxi = Math.max(cnt, maxi);``    ` `                ``// Re-initialize``                ``cnt = ``1``;``            ``}``        ``}``    ` `        ``// Check after iteration is complete``        ``maxi = Math.max(cnt, maxi);``    ` `        ``return` `maxi;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String []args)``    ``{``        ` `        ``String s = ``"abcdde"``;``        ``System.out.println(longestSubstring(s));``    ``}``}` `// This code is contributed by Rituraj Jain`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GfG``{` `    ``// Function to return the length``    ``// of the required sub-string``    ``static` `int` `longestSubstring(``string` `s)``    ``{``        ``int` `cnt = 1, maxi = 1;``    ` `        ``// Get the length of the string``        ``int` `n = s.Length;``    ` `        ``// Iterate in the string``        ``for` `(``int` `i = 1; i < n; i++)``        ``{``    ` `            ``// Check for not consecutive``            ``if` `(s[i] != s[i - 1])``                ``cnt++;``            ``else``            ``{``    ` `                ``// If cnt greater than maxi``                ``maxi = Math.Max(cnt, maxi);``    ` `                ``// Re-initialize``                ``cnt = 1;``            ``}``        ``}``    ` `        ``// Check after iteration is complete``        ``maxi = Math.Max(cnt, maxi);``    ` `        ``return` `maxi;``    ``}` `    ``// Driver code``    ``static` `void` `Main()``    ``{``        ` `        ``string` `s = ``"abcdde"``;``        ``Console.WriteLine(longestSubstring(s));``    ``}``}` `// This code is contributed by mits`

## Python3

 `# Python3 implementation of the approach` `# Function to return the length``# of the required sub-string``def` `longestSubstring(s) :` `    ``cnt ``=` `1``;``    ``maxi ``=` `1``;` `    ``# Get the length of the string``    ``n ``=` `len``(s);` `    ``# Iterate in the string``    ``for` `i ``in` `range``(``1``, n) :` `        ``# Check for not consecutive``        ``if` `(s[i] !``=` `s[i ``-` `1``]) :``            ``cnt ``+``=` `1``;``            ` `        ``else` `:``            ` `            ``# If cnt greater than maxi``            ``maxi ``=` `max``(cnt, maxi);` `            ``# Re-initialize``            ``cnt ``=` `1``;` `    ``# Check after iteration``    ``# is complete``    ``maxi ``=` `max``(cnt, maxi);` `    ``return` `maxi;` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:``    ` `    ``s ``=` `"abcdde"``;``    ``print``(longestSubstring(s));``    ` `# This code is contributed by Ryuga`

## PHP

 ``

## Javascript

 ``

Output

`4`

Time Complexity: O(n)
Auxiliary Space: O(1)

Approach 2: Using HashTable:

• Create a hash table to keep track of the most recent occurrence of each character.
• Initialize two pointers, left and right, to the beginning of the string.
• Iterate through the string with the right pointer, updating the hash table and the length of the current substring with each new character encountered.
• If a repeated character is encountered, move the left pointer to the next character after the previously occurring instance of that character and update the hash table and substring length accordingly.
• Keep track of the maximum substring length encountered so far.
• Return the maximum substring length.

Here’s the implementation of this approach in C++:

## C++

 `#include ``using` `namespace` `std;` `int` `longestSubstring(string s) {``    ``unordered_map<``char``, ``int``> mp;``    ``int` `left = 0, right = 0, maxLen = 0;``    ``while` `(right < s.length()) {``        ``char` `c = s[right];``        ``if` `(mp.find(c) != mp.end() && mp >= left) {``            ``left = mp + 1;``        ``}``        ``mp = right;``        ``maxLen = max(maxLen, right - left + 1);``        ``right++;``    ``}``    ``return` `maxLen;``}` `int` `main() {``    ``string s = ``"abcdde"``;``    ``cout << longestSubstring(s) << endl;``    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main {` `    ``public` `static` `int` `longestSubstring(String s) {``        ``Map mp = ``new` `HashMap<>();``        ``int` `left = ``0``, right = ``0``, maxLen = ``0``;``        ``while` `(right < s.length()) {``            ``char` `c = s.charAt(right);``            ``if` `(mp.containsKey(c) && mp.get(c) >= left) {``                ``left = mp.get(c) + ``1``;``            ``}``            ``mp.put(c, right);``            ``maxLen = Math.max(maxLen, right - left + ``1``);``            ``right++;``        ``}``        ``return` `maxLen;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``String s = ``"abcdde"``;``        ``System.out.println(longestSubstring(s));``    ``}``}`

## Python3

 `def` `longestSubstring(s):``    ``mp ``=` `{}``    ``left ``=` `0``    ``maxLen ``=` `0``    ``for` `right ``in` `range``(``len``(s)):``        ``if` `s[right] ``in` `mp ``and` `mp[s[right]] >``=` `left:``            ``left ``=` `mp[s[right]] ``+` `1``        ``mp[s[right]] ``=` `right``        ``maxLen ``=` `max``(maxLen, right ``-` `left ``+` `1``)``    ``return` `maxLen` `if` `__name__ ``=``=` `"__main__"``:``    ``s ``=` `"abcdde"``    ``maxLen ``=` `longestSubstring(s)``    ``print``(maxLen)`

## C#

 `// Added C# code for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `Program {``    ``static` `int` `LongestSubstring(``string` `s)``    ``{``        ``Dictionary<``char``, ``int``> mp``            ``= ``new` `Dictionary<``char``, ``int``>();``        ``int` `left = 0, right = 0, maxLen = 0;``        ``while` `(right < s.Length) {``            ``char` `c = s[right];``            ``if` `(mp.ContainsKey(c) && mp >= left) {``                ``left = mp + 1;``            ``}``            ``mp = right;``            ``maxLen = Math.Max(maxLen, right - left + 1);``            ``right++;``        ``}``        ``return` `maxLen;``    ``}` `    ``static` `void` `Main(``string``[] args)``    ``{``        ``string` `s = ``"abcdde"``;``        ``Console.WriteLine(LongestSubstring(s));``    ``}``}` `// Contributed by adityasha4x71`

## Javascript

 `function` `longestSubstring(s) {``  ``const mp = {};``  ``let left = 0;``  ``let maxLen = 0;``  ``for` `(let right = 0; right < s.length; right++) {``    ``if` `(s[right] ``in` `mp && mp[s[right]] >= left) {``      ``left = mp[s[right]] + 1;``    ``}``    ``mp[s[right]] = right;``    ``maxLen = Math.max(maxLen, right - left + 1);``  ``}``  ``return` `maxLen;``}` `const s = ``"abcdde"``;``const maxLen = longestSubstring(s);``console.log(maxLen);`

Output

`4`

Time Complexity: O(n)
Auxiliary Space: O(min(m, n))

My Personal Notes arrow_drop_up