# Longest Substring Without Repeating Characters

Clarify the problem:

- The problem requires us to find the length of the longest substring in a given string without repeating characters.
- We need to implement a function that takes a string as input and returns an integer representing the length of the longest substring without repeating characters.

Analyze the problem:

- Input: A string.
- Output: An integer representing the length of the longest substring without repeating characters.
- Constraints:
- The input string can contain any printable ASCII characters.
- The input string can be empty.
- The output should be a non-negative integer.

Design an algorithm:

- We can use a sliding window approach to solve the problem.
- We will maintain a set to keep track of the characters in the current substring.
- We will initialize two pointers,
`left`

and`right`

, to mark the boundaries of the current substring. - Initially, both pointers will be at the start of the string.
- We will iterate through the string using the
`right`

pointer and do the following:- Check if the character at the
`right`

pointer is already in the set. - If it is not in the set, we add it to the set and move the
`right`

pointer one step to the right. - If it is already in the set, it means we have a repeating character. In this case, we update the maximum length of the substring, remove the character at the
`left`

pointer from the set, and move the`left`

pointer one step to the right.

- Check if the character at the
- We continue this process until we reach the end of the string.
- Finally, we return the maximum length of the substring.

Explain your approach:

- We will implement a function called
`lengthOfLongestSubstring`

to solve the problem. - The function will take a string,
`s`

, as input. - We will initialize two pointers,
`left`

and`right`

, to mark the boundaries of the current substring. - We will also initialize an empty set called
`charSet`

to keep track of the characters in the current substring. - We will initialize a variable called
`maxLength`

to store the maximum length of the substring. - We will iterate through the string using the
`right`

pointer and perform the necessary checks and updates. - We will return the value of
`maxLength`

as the output.

- We will implement a function called
Write clean and readable code:

python`def lengthOfLongestSubstring(s): left = 0 right = 0 maxLength = 0 charSet = set() while right < len(s): if s[right] not in charSet: charSet.add(s[right]) maxLength = max(maxLength, right - left + 1) right += 1 else: charSet.remove(s[left]) left += 1 return maxLength`

Test your code:

python`# Test case 1 s = "abcabcbb" # The longest substring without repeating characters is "abc", which has a length of 3 assert lengthOfLongestSubstring(s) == 3 # Test case 2 s = "bbbbb" # The longest substring without repeating characters is "b", which has a length of 1 assert lengthOfLongestSubstring(s) == 1 # Test case 3 s = "pwwkew" # The longest substring without repeating characters is "wke", which has a length of 3 assert lengthOfLongestSubstring(s) == 3 # Test case 4 s = "" # The input string is empty, so the output should be 0 assert lengthOfLongestSubstring(s) == 0`

We have tested the code with multiple test cases, including cases with various lengths of input strings and different characters. The output for each test case matches the expected results.

Optimize if necessary:

- The current solution has a time complexity of O(N), where N is the length of the input string.
- This is because we iterate through the string using two pointers and perform constant-time operations.
- The space complexity is O(min(N, M)), where M is the size of the character set.
- In the worst case, where all characters in the string are distinct, the character set can contain up to N elements.
- However, the character set size will be limited by the number of distinct characters in the string.
- Therefore, the space complexity is bounded by O(min(N, M)).

Handle error cases:

- The code handles the case when the input string is empty and returns 0 as the output.
- The code assumes that the input is a valid string.

Discuss complexity analysis:

- Let N be the length of the input string.
- The time complexity of the solution is O(N) because we iterate through the string using two pointers.
- The space complexity is O(min(N, M)) because we use additional space to store the character set, where M is the size of the character set.
- The code can be further optimized by using a more efficient data structure, such as a dictionary, to store the indices of characters for faster lookup and removal. However, this would not change the overall time complexity.