# Length of the longest substring without repeating characters

Given a string str, find the length of the longest substring without repeating characters.

• For “ABDEFGABEF”, the longest substring are “BDEFGA” and “DEFGAB”, with length 6.
• For “BBBB” the longest substring is “B”, with length 1.
• For “GEEKSFORGEEKS”, there are two longest substrings shown in the below diagrams, with length 7
• .

The desired time complexity is O(n) where n is the length of the string.

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Method 1 (Simple : O(n3)): We can consider all substrings one by one and check for each substring whether it contains all unique characters or not. There will be n*(n+1)/2 substrings. Whether a substring contains all unique characters or not can be checked in linear time by scanning it from left to right and keeping a map of visited characters. Time complexity of this solution would be O(n^3).

## C++

 `// C++ program to find the length of the longest substring ` `// without repeating characters ` `#include ` `using` `namespace` `std; ` ` `  `// This functionr eturns true if all characters in str[i..j] ` `// are distinct, otherwise returns false ` `bool` `areDistinct(string str, ``int` `i, ``int` `j) ` `{ ` ` `  `    ``// Note : Default values in visited are false ` `    ``vector<``bool``> visited(26); ` ` `  `    ``for` `(``int` `k = i; k <= j; k++) { ` `        ``if` `(visited[str[k] - ``'a'``] == ``true``) ` `            ``return` `false``; ` `        ``visited[str[k] - ``'a'``] = ``true``; ` `    ``} ` `    ``return` `true``; ` `} ` ` `  `// Returns length of the longest substring ` `// with all distinct characters. ` `int` `longestUniqueSubsttr(string str) ` `{ ` `    ``int` `n = str.size(); ` `    ``int` `res = 0; ``// result ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``for` `(``int` `j = i; j < n; j++) ` `            ``if` `(areDistinct(str, i, j)) ` `                ``res = max(res, j - i + 1); ` `    ``return` `res; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string str = ``"geeksforgeeks"``; ` `    ``cout << ``"The input string is "` `<< str << endl; ` `    ``int` `len = longestUniqueSubsttr(str); ` `    ``cout << ``"The length of the longest non-repeating "` `            ``"character substring is "` `         ``<< len; ` `    ``return` `0; ` `} `

Output:

```The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7
```

Method 2 (Better : O(n2)) The idea is to use window sliding. Whenever we see repitition, we remove the pervious occurrance and slide the window.

## C++

 `// C++ program to find the length of the longest substring ` `// without repeating characters ` `#include ` `using` `namespace` `std; ` ` `  `int` `longestUniqueSubsttr(string str) ` `{ ` `    ``int` `n = str.size(); ` `    ``int` `res = 0; ``// result ` ` `  `    ``for` `(``int` `i = 0; i < n; i++) { ` `         `  `        ``// Note : Default values in visited are false ` `        ``vector<``bool``> visited(256);    ` ` `  `        ``for` `(``int` `j = i; j < n; j++) { ` ` `  `            ``// If current character is visited ` `            ``// Break the loop ` `            ``if` `(visited[str[j]] == ``true``) ` `                ``break``; ` ` `  `            ``// Else update the result if ` `            ``// this window is larger, and mark ` `            ``// current character as visited. ` `            ``else` `{ ` `                ``res = max(res, j - i + 1); ` `                ``visited[str[j]] = ``true``; ` `            ``} ` `        ``} ` ` `  `        ``// Remove the first character of previous ` `        ``// window ` `        ``visited[str[i]] = ``false``; ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string str = ``"geeksforgeeks"``; ` `    ``cout << ``"The input string is "` `<< str << endl; ` `    ``int` `len = longestUniqueSubsttr(str); ` `    ``cout << ``"The length of the longest non-repeating "` `            ``"character substring is "` `         ``<< len; ` `    ``return` `0; ` `} `

Output:

```The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7
```

Method 3 (Linear Time): Let us talk about the linear time solution now. This solution uses extra space to store the last indexes of already visited characters. The idea is to scan the string from left to right, keep track of the maximum length Non-Repeating Character Substring seen so far in res. When we traverse the string, to know the length of current window we need two indexes.
1) Ending index ( j ) : We consider current index as ending index.
2) Starting index ( i ) : It is same as previous window if current character was not present in the previous window. To check if the current character was present in the previous window or not, we store last index of every character in an array lasIndex[]. If lastIndex[str[j]] + 1 is more than previous start, then we updated the start index i. Else we keep same i.

Below is the implementation of the above approach :

## C++

 `// C++ program to find the length of the longest substring ` `// without repeating characters ` `#include ` `using` `namespace` `std; ` `#define NO_OF_CHARS 256 ` ` `  `int` `longestUniqueSubsttr(string str) ` `{ ` `    ``int` `n = str.size(); ` ` `  `    ``int` `res = 0; ``// result ` ` `  `    ``// last index of all characters is initialized ` `    ``// as -1 ` `    ``vector<``int``> lastIndex(NO_OF_CHARS, -1); ` ` `  `    ``// Initialize start of current window ` `    ``int` `i = 0; ` ` `  `    ``// Move end of current window ` `    ``for` `(``int` `j = 0; j < n; j++) { ` ` `  `        ``// Find the last index of str[j] ` `        ``// Update i (starting index of current window) ` `        ``// as maximum of current value of i and last ` `        ``// index plus 1 ` `        ``i = max(i, lastIndex[str[j]] + 1); ` ` `  `        ``// Update result if we get a larger window ` `        ``res = max(res, j - i + 1); ` ` `  `        ``// Update last index of j. ` `        ``lastIndex[str[j]] = j; ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``string str = ``"geeksforgeeks"``; ` `    ``cout << ``"The input string is "` `<< str << endl; ` `    ``int` `len = longestUniqueSubsttr(str); ` `    ``cout << ``"The length of the longest non-repeating "` `            ``"character substring is "` `         ``<< len; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find the length of the longest substring ` `// without repeating characters ` `import` `java.util.*; ` ` `  `public` `class` `GFG { ` ` `  `    ``static` `final` `int` `NO_OF_CHARS = ``256``; ` ` `  `    ``static` `int` `longestUniqueSubsttr(String str) ` `    ``{ ` `        ``int` `n = str.length(); ` ` `  `        ``int` `res = ``0``; ``// result ` ` `  `        ``// last index of all characters is initialized ` `        ``// as -1 ` `        ``int` `[] lastIndex = ``new` `int``[NO_OF_CHARS]; ` `        ``Arrays.fill(lastIndex, -``1``); ` ` `  `        ``// Initialize start of current window ` `        ``int` `i = ``0``; ` ` `  `        ``// Move end of current window ` `        ``for` `(``int` `j = ``0``; j < n; j++) { ` ` `  `            ``// Find the last index of str[j] ` `            ``// Update i (starting index of current window) ` `            ``// as maximum of current value of i and last ` `            ``// index plus 1 ` `            ``i = Math.max(i, lastIndex[str.charAt(j)] + ``1``); ` ` `  `            ``// Update result if we get a larger window ` `            ``res = Math.max(res, j - i + ``1``); ` ` `  `            ``// Update last index of j. ` `            ``lastIndex[str.charAt(j)] = j; ` `        ``} ` `        ``return` `res; ` `    ``} ` ` `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``String str = ``"geeksforgeeks"``; ` `        ``System.out.println(``"The input string is "` `+ str); ` `        ``int` `len = longestUniqueSubsttr(str); ` `        ``System.out.println(``"The length of "` `                           ``+ ``"the longest non repeating character is "` `+ len); ` `    ``} ` `} ` `// This code is contributed by Sumit Ghosh `

## Python

 `# Python program to find the length of the longest substring ` `# without repeating characters ` `NO_OF_CHARS ``=` `256` ` `  `def` `longestUniqueSubsttr(string): ` ` `  `    ``# Initialize the last index array as -1, -1 is used to store ` `    ``# last index of every character ` `    ``lastIndex ``=` `[``-``1``] ``*` `NO_OF_CHARS ` ` `  `    ``n ``=` `len``(string) ` `    ``res ``=` `0`   `# Result ` `    ``i ``=` `0` ` `  `    ``for` `j ``in` `range``(``0``, n): ` `        ``# Find the last index of str[j] ` `        ``# Update i (starting index of current window) ` `        ``# as maximum of current value of i and last ` `        ``# index plus 1 ` `        ``i ``=` `max``(i, lastIndex[``ord``(string[j])] ``+` `1``); ` ` `  `        ``# Update result if we get a larger window ` `        ``res ``=`  `max``(res, j ``-` `i ``+` `1``) ` ` `  `        ``# Update last index of j. ` `        ``lastIndex[``ord``(string[j])] ``=` `j; ` ` `  `    ``return` `res ` ` `  `# Driver program to test the above function ` `string ``=` `"geeksforgeeks"` `print` `(``"The input string is "` `+` `string) ` `length ``=` `longestUniqueSubsttr(string) ` `print` `(``"The length of the longest non-repeating character"` `+` `       ``" substring is "` `+` `str``(length)) ` ` `  `# This code is contributed by Bhavya Jain `

Output:

```The input string is geeksforgeeks
The length of the longest non-repeating character substring is 7
```

Time Complexity: O(n + d) where n is length of the input string and d is number of characters in input string alphabet. For example, if string consists of lowercase English characters then value of d is 26.
Auxiliary Space: O(d)

Alternate Implementation :

## Python

 `# Here, we are planning to implement a simple sliding window methodology ` `  `  `def` `longestUniqueSubsttr(string): ` `      `  `    ``# Creating a set to store the last positions of occurrence ` `    ``seen ``=` `{} ` `    ``maximum_length ``=` `0` `  `  `    ``# starting the inital point of window to index 0 ` `    ``start ``=` `0`  `      `  `    ``for` `end ``in` `range``(``len``(string)): ` `  `  `        ``# Checking if we have already seen the element or not ` `        ``if` `string[end] ``in` `seen: ` ` `  `            ``# If we have seen the number, move the start pointer ` `            ``# to position after the last occurrence ` `            ``start ``=` `max``(start, seen[string[end]] ``+` `1``) ` `  `  `        ``# Updating the last seen value of the character ` `        ``seen[string[end]] ``=` `end ` `        ``maximum_length ``=` `max``(maximum_length, end``-``start ``+` `1``) ` `    ``return` `maximum_length ` `  `  `# Driver Code ` `string ``=` `"geeksforgeeks"` `print``(``"The input string is"``, string) ` `length ``=` `longestUniqueSubsttr(string) ` `print``(``"The length of the longest non-repeating character substring is"``, length) `

Output:

```('The input string is', 'geeksforgeeks')
('The length of the longest non-repeating character substring is', 7)
```

As an exercise, try the modified version of the above problem where you need to print the maximum length NRCS also (the above program only prints the length of it).