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

**Example 1:**

```
Input: s = "abcabcbb"
Output: 3
```

Explanation: The answer is “abc”, with the length of 3.

**Example 2:**

```
Input: s = "bbbbb"
Output: 1
```

Explanation: The answer is “b”, with the length of 1.

**Example 3:**

```
Input: s = "pwwkew"
Output: 3
```

Explanation: The answer is “wke”, with the length of 3.

**Note:**

```
1. 0 ≤ s.length ≤ 5 * 10^4
2. s consists of English letters, digits, symbols, and spaces.
```

**Understanding the problem**

This problem is asking us to find the length of the longest substring within a given string which does not contain any repeating characters. So for instance, if you had the string “abcabcbb”, the longest substring that does not contain any repeating characters would be “abc”. Therefore, the answer for this example would be 3.

Likewise, if you were given the string “pwwkew”, the longest substring here would be “wke”, so the answer for this example would be 3.

Remember that s can consist of English letters, digits, symbols, and spaces, but it will not exceed a length of 5 * 10^4 characters.

**How to solve this problem?**

If you want to solve this problem, it might help to brush up on your knowledge of string manipulation in Python. You could be especially familiar with the functions len(), split(), and for-loops. Additionally, this problem requires a bit of logic and an understanding of how to approach problems in a step-by-step manner to find a solution.

Other than that, it would be great if you had a general understanding of how to format your output based on the input.

**String Manipulation in Python**

String manipulation is a concept in programming which deals with extracting a different set of characters from a string. There are several convenient methods in Python that make string manipulation much easier.

For example, one method is the len() function which can be used to find the length of a string. So if you had the string “Hello World!”, running len(“Hello World!”) would give you 12.

Another useful function is split(), which can be used to split a string based on a certain character or substring. For instance, let’s say you have the string “Hello, World!”, if you ran the command “Hello, World!”.split(‘,’) this would return a list [“Hello”, “World!”].

For-loops are probably one of the more powerful tools when it comes to string manipulation. They allow you to go through each character of a string, and can be used to check for certain conditions or criteria.

**Approaching Problems Step-By-Step**

Approaching problems in a step-by-step manner is an invaluable skill to have when it comes to programming and problem solving. To do so, the first step is to really understand the problem at hand, so make sure you understand what your task is and what goal you’re trying to reach.

From there, it might be helpful to create a rough plan or outline that describes how you plan on solving the problem. Think about how you’d go about tackling the problem if you were to do it manually, and then try see if you can translate those steps into programming commands or functions.

When it comes to coding, going step-by-step is key because it helps ensure that you don’t miss any important steps or overlook any errors. It’s also helpful purely in terms of organization, so you can trace your code better and debug more efficiently should you encounter any errors.

## Let’s develop the solution

The best way to start tackling this problem is by understanding it: we want to find the length of the longest substring in a given string, which doesn’t contain any repeating characters.

For our solution, we’ll be using a sliding window approach; this consists of two pointers which will “slide” a window through the given string. The end points of the window, pointerA and pointerB, will be used to delimit our “substring”.

To get started, we’ll set pointerA to the first character of the string, and pointerB to the second character of the string. Inside a for-loop, we’ll then check to see if the two characters pointed by the pointers are the same (using conditionals) – if they’re not, we can move pointerB one character over. If the two characters are the same, we reset both pointers to the beginning of the string, and move pointerB to the next character.

To ensure our solution covers the edge case of the longest substring containing all the same characters, we can add an additional check at the end of the loop which checks the substring length. If the length of the substring is greater than the stored maximum length, we can update it to the new (longer) length.

The inner loop keeps sliding the pointers along until it reaches the end of the string, after which it’ll return the maximum length of the substring.

## Step By Step Solution

First, we’ll declare a variable maxLen to store the maximum length of the substring, and set pointerA and pointerB to the beginning of the string:

```
pointerA = 0
pointerB = 1
maxLen = 0
```

We can then create a for-loop which will slide the pointers through the string:

```
for i in range(len(s)):
if s[pointerA] != s[pointerB]: # check if characters are the same
pointerB += 1
else:
pointerA = 0
pointerB = i + 1
maxLen = max(maxLen, pointerB - pointerA) # check if maxLen should be updated
```

The inner loop keeps sliding the pointers along until it reaches the end of the string, after which it’ll return the maximum length of the substring:

`return maxLen`

And there you have it – a working solution to the longest substring problem in Python!

## Again, here’s the whole solution code

```
def max_len(s):
pointerA = 0
pointerB = 1
maxLen = 0
# loop through string
for i in range(len(s)):
# declare variables
if s[pointerA] != s[pointerB]: # check if characters are the same
pointerB += 1
else:
pointerA = 0
pointerB = i + 1
maxLen = max(maxLen, pointerB - pointerA) # check if maxLen should be updated
# return maxLength value
return maxLen
```

## Linear Time Complexity

The time complexity of this code is O(n), where n is the length of the given string. This is because the only two operations we are performing are checking if two characters are the same and updating the maximum length of the substring, both of which take constant time, meaning they won’t change depending on the size of the input. Therefore, the time complexity reduces to the number of characters in the string.

In order to optimize the code further, we could take into account the fact that strings in Python are immutable. It might be beneficial to look into ways to mutate them, as this could potentially reduce the time complexity to O(1).

## Linear Space Complexity

The space complexity of this code is also O(n), where n is the length of the given string, as we are only allocating memory for the two pointers and the maximum length. As a result, the amount of memory required is directly proportional to the size of the input.

In this case, allocating additional memory to the data structure we are using would not improve the code performance. However, if our input was large enough, it may become beneficial to consider the space complexity of our solution.

## Final Thoughts

Tackling the problem of the longest substring with no repeating characters is certainly a challenging task, and making sure you have a robust solution is crucial! You’ll need to think through the question carefully and come up with a plan of action that takes into account both the time and space complexities as well.

At the same time, it can be a great opportunity to practice your string manipulation techniques, break down the problem into manageable steps, and work on your debugging skills.

Good luck with this challenge!