Thanks to Mailgun for sponsoring this video! Head to mailgun.com/john to try Mailgun free today. Looking forward to seeing how you guys make this solution even better!
Not able to understand how this algo will work for some string like "abcdcga" as we will keep our left pointer at first a and we will increment right pointer, at when right pointer at second c it will get repeated letter and will increment left pointer to b and in next iteration it will move to g and will register length of bcdcg but this substring is already having repeated character. Rather than incrementing left pointer by one we should increment it by lastCharOccuredIndex+1
You genuinely have one of the best programming explanation videos on this site, honestly. Funny, I was discussing learning about the Sliding Window algorithm to practice Leetcode questions with a friend yesterday, and lo and behold you've uploaded a great explanation literally 24hrs later, legendary! Could you please upload more Leetcode explanation questions? If not on TH-cam, perhaps a course?
I had just solved this problem and found this video. You explained each solution and your approach in the best way. Your way to explaining make things crystal clear John !!
This is probably one of the best tutorials out there and i think TH-cam is with me in this.❤️ I could you not, even though I have watched it already it is every time the first video in my recommended 😂 Guess I'll watch it twice. Keep up the good work!
You have to be careful when using a MAP to lookup something because, even though its O(1) in time complexity, there is a lot of overhead. Let's say that the constant time for a lookup in a MAP is always 500 nanoseconds, if the indexOf (that has a time complexity of O(n)) takes only 300 nanoseconds because it finds the answer in the first few characters, then the indexOf will perform better. This obviously can be measured and we can come up with some threshold that tells us what algorithm to use in each situation. My guess is that in the English language indexOf will always perform better because we are dealing with words that are small in size (there is always the repeating space character).
Great job, please keep posting the leetcode solution videos in structural manner(for eg top 50 that includes most practices/datastructures) , this helps a lot in preparing for interviews.
For the brute force solution. I suggest checking if the max need to be updated in the "if contains part" that makes sure that we only do it right before we break. It is one time per substring. We fount a substring, now, let's check if it is better than the other we had so far. Second, I will suggest using HashSet instead of StringBuilder. HashSet has contains method and it is faster.
I'm currently just at the brute-force method in the video, but for the lookups I'd probably use a hashset. I would therefore prevent an O(n²) lookup. But the brute-force method was the first idea for me as well.
The reason for the final solution being faster is because while hash tables have "constant" lookup time it still takes time. Depending on the hashing function and the initial size of the hashmap the lookup, add, and resize functions may be more time consuming than just linearly looking through an array of characters. Especially if the hashing function has division, because of how bad computers are at it. So rather than your hashmap having O(1) time complexity for lookup its probably more like O(100) which is potentially smaller than the size of n. Sorry for the long rambling answer, but yeah hashmaps are great, if you know how the data is being put into them. They also take up a *bunch* of space, so finding an algorithm that is similar in functionality, but doesn't use them is always the way to go.
True, just to add your answer, hashmap has constant time complexity in average case, but O(n) in worst case. So it's not 100% perfect n effective in all cases
Interesting! I am very honest with myself, I am not seeing the full picture when it occurs to recursion; However, I did grasp the idea of the "quicksort" method a bit better, not 100% but we are learning. I can see this is almost similar to an array.
John, you’ve helped me understand DS&A in Java better than before. The way you explained things are easy to understand and follow. I’m a visual learner and your explanations makes it easier for me visualize & understand. Thank you and please keep these leet code videos coming. Your other videos on Java has truly helped me understand Java so much more than my professors lol you are incredible in the work that you’re doing for me and many. We cannot thank you enough ❤ I appreciate you.
Hey John! First of all thanks for the amazing video! Short answer for why indexOf is faster in this case: It is simply because in this case it has an O(1) runtime, how? here is how: Before you slide your right pointer to the right you have already made sure that this substring has different characters, which in the worst case will be 24 characters long. Since you know it will never be longer than 24 characters, or 34 if numbers are included in the string, then it is constant time, because no matter how big your string will be, it will be in the worst case that maximum substring :D so it is related to the valid substring and not to the input! :D And since the map indeed has access and write time of O(1) it still has an overhead for hash calculation and storing and etc... which take more operations / time than indexOf in that case, but since none of them is related to n, the one with the shorter/faster operations wins :D I hope that was helpful!
I know this is a bit late, but I believe Map is quite slow in runtime from what I heard and so it doesnt give off the best speed, Map is a great to use if you dont care much about speed as much as you want cleaner and simple code (tho run time is and should be priority)
Definitely one of the best explanations or just the best, starting from the basic one (brute force) just to kick off and let viewers like me grasp the idea before jumping to more complex solutions. Thank you!
given that there's a finite and constant number of letters, you could probably replace the HashMap with a regular array for a negligible decrease in time and memory
Yeah it could be the case that despite the technical time complexity being lower, because n will never be more than 50,000, simple sequential array searches might just be more performant
@@cipherxen2 and a character can be found in this array in O(1) time by - int lastEncountered = charIndexes[currentChar]; Initialize charIndexes[255] with all -1;
hi John, The way of explanation which you are giving is excellent. Since, I am mostly working JAVA. You videos are very mich helpful for me to achieve greater heights in my life. I mostly use ECLIPSE for my Java Projects. If possible please guide me in using Intellij with each and every shortcuts. Thanks in Advance, Logesh
I would never thought of HashMap is it possible to do the same thing with a list just if list.contains(a) list.remove(a) list.append(a). Could you pls make a video about how fast all these datastructures in comparison are. you can explain very good :)
I'm not entirely sure, but the answer to the difference in time complexity might be in how indexOf is implemented in the first place. I'm not an expert at all, but what if the indexOf method itself already utilizes the exact same Map implementation? Meaning, your Map implementation could be a duplicate of indexOf(), except indexOf() doesn't have the extra steps within the implementations of contains() and get() because it's already encapsulated in core Java. I'm just guessing here, of course. Pretty sure I could be wrong.
Thanks for the clear explanation. I'm struggling with tech interviews. How am I supposed to complete a challenge in a short time? I just got stuck in the last one. I'm trying so hard to understand. I've been practicing LeetCode exercises, but there's always something tricky, and I've never seen anything similar before. It's so frustrating
Hi John I like how you present your leetcode solutions, so easy to follow and understand. Hope to see more of this or if you have anothe platform teaching leetcode problems , I would be happy to know.. Thank you
I think maps are very performant in java, so it's not because of the map functions. What i think it's because of initialize an object of it and this takes time. I saw this while measuring a function using map in my performance project.
Hi there!! I really like your videos so much you make them easy to understand!! I want to ask you something can you recommend a book or books to improve our problem solving skill and to learn data structures
I'm assuming this last approach is faster because the window defined by 'left' and 'right' never ends up being long enough to operate less efficiently than when using a map. I mean, Imagine the 5*10^4 (50000) String where ALL its characters are different (this means, maxLength would be 50000). Everytime you call 'indexOf()', Java is basically running a O(N) algorithm, where N is the length of the window we use. Said window starts with length 0, it's increased each loop and its length ends up being 50000. We have a complexity O(50000!), don't we? For this kind of scenario, unless I am mistaken, using a map is a way better choice.
as for the better time, my best guess is a combination of the sample data and the relatively massive overhead of the default HashMap implementation, using arrays to implement your own map SHOULD in theory produce better results, I'll test it later. Or you could just pass 127 as the initial capacity of the map?
Thanks John for awesome video and great explanation. For the Map solution wouldn't it also help to add an exit condition to break the loop if (maxLength > input.length() - right + 1) - so we need not iterate the remaining characters in the input.
it's crazy to see that last solution. i am watching this after submitting my solution, which is almost identical. however, i didn't know you can set the start index of String.indexOf(), so I had a String t that was set to s.substring(left, right) every loop and String c that was set to s.charAt(right). I then had the left pointer move by using ```left = (t.contains(c)) ? left + t.indexOf(c) + 1 : left;``` lmao. Funny enough, it gave the exact same time of 5ms, but their version uses a bit less space (mine used 44.94MB)
The second solution is definitely better than the first one than the map purely because our domain is so small, so all of the map operations while "constant" probably take a tad bit longer than this linear search, but again this is just due to the domain. If this was not strings but instead an array of numbers, where the domain can be much larger, the map would probably outperform this approach, though that is just a guess.
for the version that uses the HashMap, I would suggest to have an else. when we are in the "if contains" we are always shortening the substring and hence no need to update the max.
Thanks John for the amazing video!! As for maps - what is the low level implementation of maps in JVM code? I mean, does it calculate the hash for the key when put or get methods are invoked? If it does, then adding or reading keys will be quite expensive , and explains why indexOf works faster.
The max possible substring is bounded by the number of possible characters in the string, m, which given the problem constraints seems to be at most ~100ish. And, I would imagine on average the actual distance between the left and right pointers will be much less than this. This then means you are *effectively* comparing two linear solutions (even though the indexOf solution is technically nm - m is small). I would imagine that for small values of m the simplicity of linearly looping through a few characters of a string would be much faster than map lookups and manipulation. It would be interesting to see if the map-based solution would surpass the indexOf solution by increasing m, by, for example, using all UTF-8 chars.
Well the problem states that the input string may be up to 50,000 characters long. But I do think it's a good insight that the max length of the longest substring is bounded by the number of unique characters in the character set being used. In this case it says "English letters, digits, symbols and spaces." I'd have to add all those up to be sure, but let's say it's maybe 100, which may be a big reason the map solution is overkill at this level
I think when creating a string object that object knows where is each character's index and when we call indexOf method its return the index that object saves ,butt i am not sure couse i know indexOf method is leanar search
@31:42 -> is there a better way to find length of the substring(right - left + 1)? Can we do something like s.subString(left, right) and pass this as an argument to s.length() somehow and return the length of that substring? thoughts?
I coded this way using a map and still ended up solving in 5ms class Solution { public int lengthOfLongestSubstring(String s) { if (s == null || s.length() == 0) { return 0; } int maxLength = 0; int start = 0; HashMap charIndexMap = new HashMap(); for (int end = 0; end < s.length(); end++) { char currentChar = s.charAt(end); if (charIndexMap.containsKey(currentChar)) { start = Math.max(start, charIndexMap.get(currentChar) + 1); } charIndexMap.put(currentChar, end); maxLength = Math.max(maxLength, end - start + 1); } return maxLength; } }
How about this solution. String s = "abcabcda"; char[] cc = s.toCharArray(); List stringList = new ArrayList(); int len = 0; for(int i =0 ;i < s.length(); i++){ char c = cc[i];
if (!stringList.contains(c)) { System.out.println("Adding to List " + c); stringList.add(c); } else { if(stringList.size() > len) { len = stringList.size();
Thanks to Mailgun for sponsoring this video! Head to mailgun.com/john to try Mailgun free today.
Looking forward to seeing how you guys make this solution even better!
Can you let us know the compiler you use for the videos?
Not able to understand how this algo will work for some string like "abcdcga" as we will keep our left pointer at first a and we will increment right pointer, at when right pointer at second c it will get repeated letter and will increment left pointer to b and in next iteration it will move to g and will register length of bcdcg but this substring is already having repeated character. Rather than incrementing left pointer by one we should increment it by lastCharOccuredIndex+1
The complexity of your first algorithm is n cubed, not n squared! There is one more loop hidden in String.indexOf, looking for a duplicate character.
Best java chanel on TH-cam
Excellent!!
You genuinely have one of the best programming explanation videos on this site, honestly. Funny, I was discussing learning about the Sliding Window algorithm to practice Leetcode questions with a friend yesterday, and lo and behold you've uploaded a great explanation literally 24hrs later, legendary! Could you please upload more Leetcode explanation questions? If not on TH-cam, perhaps a course?
i already signed up in his course but it does not contain any exercises i wonder if there is another course where he solves problems
Same feelings here, we need more leet code problems...
I had just solved this problem and found this video. You explained each solution and your approach in the best way. Your way to explaining make things crystal clear John !!
please keep doing these, your explanations are so much more in depth than other youtube channels
John, you are a wizard. Everythings looks so logical and simple. Please make more videos like this.
This is probably one of the best tutorials out there and i think TH-cam is with me in this.❤️ I could you not, even though I have watched it already it is every time the first video in my recommended 😂
Guess I'll watch it twice. Keep up the good work!
Would love to watch a complete java dsa course from you
DSA would be more easy and interesting with John 😀
You have to be careful when using a MAP to lookup something because, even though its O(1) in time complexity, there is a lot of overhead. Let's say that the constant time for a lookup in a MAP is always 500 nanoseconds, if the indexOf (that has a time complexity of O(n)) takes only 300 nanoseconds because it finds the answer in the first few characters, then the indexOf will perform better. This obviously can be measured and we can come up with some threshold that tells us what algorithm to use in each situation. My guess is that in the English language indexOf will always perform better because we are dealing with words that are small in size (there is always the repeating space character).
My thoughts exactly
An excellent in-depth explanation of two approaches to solving this problem. Thank you very much, John.
Great job, please keep posting the leetcode solution videos in structural manner(for eg top 50 that includes most practices/datastructures) , this helps a lot in preparing for interviews.
For the brute force solution. I suggest checking if the max need to be updated in the "if contains part" that makes sure that we only do it right before we break. It is one time per substring. We fount a substring, now, let's check if it is better than the other we had so far. Second, I will suggest using HashSet instead of StringBuilder. HashSet has contains method and it is faster.
I love this series. Thank you...
I'm currently just at the brute-force method in the video, but for the lookups I'd probably use a hashset.
I would therefore prevent an O(n²) lookup.
But the brute-force method was the first idea for me as well.
You are really a coding geek. Even the concepts known, still visit them and keep something. Your explanations are far reaching. Thank you.
It's great! Please, do more Leetcode Exercise explanations!🙏
I love the final thoughts on the differences of performance between the 2 last algorithms, answered all the questions I had to myself. Thnak you!
I appreciate that you go into the brute force solution and also the more clever solution. Thanks for these!!
A unique way of explanation, clear concise.
The reason for the final solution being faster is because while hash tables have "constant" lookup time it still takes time. Depending on the hashing function and the initial size of the hashmap the lookup, add, and resize functions may be more time consuming than just linearly looking through an array of characters. Especially if the hashing function has division, because of how bad computers are at it. So rather than your hashmap having O(1) time complexity for lookup its probably more like O(100) which is potentially smaller than the size of n.
Sorry for the long rambling answer, but yeah hashmaps are great, if you know how the data is being put into them. They also take up a *bunch* of space, so finding an algorithm that is similar in functionality, but doesn't use them is always the way to go.
True, just to add your answer, hashmap has constant time complexity in average case, but O(n) in worst case. So it's not 100% perfect n effective in all cases
Interesting!
I am very honest with myself, I am not seeing the full picture when it occurs to recursion;
However, I did grasp the idea of the "quicksort" method a bit better, not 100% but we are learning.
I can see this is almost similar to an array.
John, you’ve helped me understand DS&A in Java better than before. The way you explained things are easy to understand and follow. I’m a visual learner and your explanations makes it easier for me visualize & understand. Thank you and please keep these leet code videos coming. Your other videos on Java has truly helped me understand Java so much more than my professors lol you are incredible in the work that you’re doing for me and many. We cannot thank you enough ❤ I appreciate you.
Thanks so much for the very kind words!
when we get full playlist of leetcode in java you are amazing i am from india @@CodingWithJohn
Hey John! First of all thanks for the amazing video!
Short answer for why indexOf is faster in this case:
It is simply because in this case it has an O(1) runtime, how? here is how:
Before you slide your right pointer to the right you have already made sure that this substring has different characters, which in the worst case will be 24 characters long. Since you know it will never be longer than 24 characters, or 34 if numbers are included in the string, then it is constant time, because no matter how big your string will be, it will be in the worst case that maximum substring :D so it is related to the valid substring and not to the input! :D
And since the map indeed has access and write time of O(1) it still has an overhead for hash calculation and storing and etc... which take more operations / time than indexOf in that case, but since none of them is related to n, the one with the shorter/faster operations wins :D
I hope that was helpful!
I know this is a bit late, but I believe Map is quite slow in runtime from what I heard and so it doesnt give off the best speed, Map is a great to use if you dont care much about speed as much as you want cleaner and simple code (tho run time is and should be priority)
Definitely one of the best explanations or just the best, starting from the basic one (brute force) just to kick off and let viewers like me grasp the idea before jumping to more complex solutions. Thank you!
More videos like this with solutions for diferent letcode, hackerank problems this is very much usefull to improve skills, you explain as a master
given that there's a finite and constant number of letters, you could probably replace the HashMap with a regular array for a negligible decrease in time and memory
Yeah it could be the case that despite the technical time complexity being lower, because n will never be more than 50,000, simple sequential array searches might just be more performant
@@CodingWithJohn you don't need array of 50000 elements, just 255 for ASCII characters
@@cipherxen2 and a character can be found in this array in O(1) time by -
int lastEncountered = charIndexes[currentChar]; Initialize charIndexes[255] with all -1;
At 35:00 we should use indexOfFirstAppearenceInsubstring
hi John,
The way of explanation which you are giving is excellent.
Since, I am mostly working JAVA. You videos are very mich helpful for me to achieve greater heights in my life.
I mostly use ECLIPSE for my Java Projects. If possible please guide me in using Intellij with each and every shortcuts.
Thanks in Advance,
Logesh
I would never thought of HashMap is it possible to do the same thing with a list just if list.contains(a) list.remove(a) list.append(a). Could you pls make a video about how fast all these datastructures in comparison are.
you can explain very good :)
I watched till 25:32 and was able to come up with a solution. Thanks for this amazing explanation!
Best channel ever ! , please keep going with the leatcode series
this series is actually so good.
I tried a better idea to use a fixed size array for character mapping it got more optimised thanks for the video need more leetcode content
I liked your videos, you made them all easy to grasp! please do more leetcodes tutorials and data structures and algorithms content
This playlist is amazing, Why don't you continue this series of videos?
this channel has wonderful content, and easy to understand explaination.
Great explanation,thank you !
I'm not entirely sure, but the answer to the difference in time complexity might be in how indexOf is implemented in the first place. I'm not an expert at all, but what if the indexOf method itself already utilizes the exact same Map implementation? Meaning, your Map implementation could be a duplicate of indexOf(), except indexOf() doesn't have the extra steps within the implementations of contains() and get() because it's already encapsulated in core Java. I'm just guessing here, of course. Pretty sure I could be wrong.
Name of Map:
seenChars
Thanks for the clear explanation. I'm struggling with tech interviews. How am I supposed to complete a challenge in a short time? I just got stuck in the last one. I'm trying so hard to understand. I've been practicing LeetCode exercises, but there's always something tricky, and I've never seen anything similar before. It's so frustrating
Hi John I like how you present your leetcode solutions, so easy to follow and understand. Hope to see more of this or if you have anothe platform teaching leetcode problems , I would be happy to know.. Thank you
Thanks Please do more
You make programming easy and simple
Your explanations are very good. More leetcode!!!!!!!!!
Can you please make more of these leetcode java solutions videos. They are of great help and you make us understand wonderfully.
I will when I can!
Continue this series in java please.Thanks john.
Yes, please!
Most LeetCode videos out there are either Python or C++
Definitely want to see more LeetCode walkthroughs in Java (or Kotlin)
I think maps are very performant in java, so it's not because of the map functions. What i think it's because of initialize an object of it and this takes time. I saw this while measuring a function using map in my performance project.
Hi there!! I really like your videos so much you make them easy to understand!! I want to ask you something can you recommend a book or books to improve our problem solving skill and to learn data structures
Yum just a subscriber with the initial sponsor ad
Excellent explanation and solution. I clearly understood the problem and solution. thank you
This is awesome way of teaching! Thanks John!
I'm assuming this last approach is faster because the window defined by 'left' and 'right' never ends up being long enough to operate less efficiently than when using a map. I mean, Imagine the 5*10^4 (50000) String where ALL its characters are different (this means, maxLength would be 50000). Everytime you call 'indexOf()', Java is basically running a O(N) algorithm, where N is the length of the window we use. Said window starts with length 0, it's increased each loop and its length ends up being 50000. We have a complexity O(50000!), don't we? For this kind of scenario, unless I am mistaken, using a map is a way better choice.
If we're limited to the ASCII character set, then the maximum length will be < 128.
@@toby9999 fair enough
as for the better time, my best guess is a combination of the sample data and the relatively massive overhead of the default HashMap implementation, using arrays to implement your own map SHOULD in theory produce better results, I'll test it later. Or you could just pass 127 as the initial capacity of the map?
Nice to learn from you John, can you add more solutions from LeetCode?
Thanks John for awesome video and great explanation. For the Map solution wouldn't it also help to add an exit condition to break the loop
if (maxLength > input.length() - right + 1) - so we need not iterate the remaining characters in the input.
Thanks John. Always putting these awesome videos.
it's crazy to see that last solution. i am watching this after submitting my solution, which is almost identical. however, i didn't know you can set the start index of String.indexOf(), so I had a String t that was set to s.substring(left, right) every loop and String c that was set to s.charAt(right). I then had the left pointer move by using ```left = (t.contains(c)) ? left + t.indexOf(c) + 1 : left;``` lmao. Funny enough, it gave the exact same time of 5ms, but their version uses a bit less space (mine used 44.94MB)
if possible more videos like this, especially interested in thought process behind solutioon
Wow so easy to learn and understand , you have a new student sir.
I've been binging your videos. I feel like God sent you to me. Thank you
The second solution is definitely better than the first one than the map purely because our domain is so small, so all of the map operations while "constant" probably take a tad bit longer than this linear search, but again this is just due to the domain. If this was not strings but instead an array of numbers, where the domain can be much larger, the map would probably outperform this approach, though that is just a guess.
for the version that uses the HashMap, I would suggest to have an else. when we are in the "if contains" we are always shortening the substring and hence no need to update the max.
Hi Johnny sin, good to see in as a software developer role as well
wow pls, do more Leetcode exercise explanations!
Thanks John for the amazing video!! As for maps - what is the low level implementation of maps in JVM code? I mean, does it calculate the hash for the key when put or get methods are invoked? If it does, then adding or reading keys will be quite expensive , and explains why indexOf works faster.
The max possible substring is bounded by the number of possible characters in the string, m, which given the problem constraints seems to be at most ~100ish. And, I would imagine on average the actual distance between the left and right pointers will be much less than this. This then means you are *effectively* comparing two linear solutions (even though the indexOf solution is technically nm - m is small).
I would imagine that for small values of m the simplicity of linearly looping through a few characters of a string would be much faster than map lookups and manipulation. It would be interesting to see if the map-based solution would surpass the indexOf solution by increasing m, by, for example, using all UTF-8 chars.
Well the problem states that the input string may be up to 50,000 characters long. But I do think it's a good insight that the max length of the longest substring is bounded by the number of unique characters in the character set being used. In this case it says "English letters, digits, symbols and spaces." I'd have to add all those up to be sure, but let's say it's maybe 100, which may be a big reason the map solution is overkill at this level
need more tutorials please :) thank you!
Could you please do one about Polymorphic load/save methods for Java Io file handling
wow thanks 🙏
John could you solve this problem with an array list?
Hi can u upload a video on leetcode 992 ?
What are the java project that will be modern..Or i should have to learn other tech stack to make project to stand out??
Great Video! But what book would you recommend for learning java?
Long story short, here two algorithms are used ..1)sliding window algorithm of variable size
2) 2 pointer approach
can you please teach dynamic programming.
I think when creating a string object that object knows where is each character's index and when we call indexOf method its return the index that object saves ,butt i am not sure couse i know indexOf method is leanar search
@31:42 -> is there a better way to find length of the substring(right - left + 1)? Can we do something like s.subString(left, right) and pass this as an argument to s.length() somehow and return the length of that substring? thoughts?
Also at 30:00 why not just do a left++?
Want more of this
I'll definitely do more sometime soon!
hey jhon can you make a video about event listeners. im trying to make a simple game where you move a star char inside a list with arrow keys.
Make tutorias about algorithms DFS and BFS with Graphs
AMAZING!
Awesome best explanation 👏
Thanks for this explaination🥰
hi john I've a doubt over here, does using .toString or just +"" instead of String.valueOf makes any difference
thanks for the video !!
Thanks
More leetcode problems!!! I like this style of video 🧌
Is it just me, or "Coding With John" is the new "Alex Lee" when it comes to learning Java?
Hmm... lets see what we learn today!
easiest explanation ever. search for 10 other videos. this is the easiest. thanks.
BFS DFS next?
substringCharacterIndex, but then you have to remove characters to left
I used HashSet .... but i got 133 ms why do you think so ?
Map lastSeenCharacterLoopup;
Think of it this way: why there is no flight from San Jose to San Francisco?
Joke: Our beloved Johnny sins was so good at Java I didn't know was used to watch him in incognito now without it as well indeed he can be anything.
I think myMap is a perfect name
I coded this way using a map and still ended up solving in 5ms
class Solution {
public int lengthOfLongestSubstring(String s) {
if (s == null || s.length() == 0) {
return 0;
}
int maxLength = 0;
int start = 0;
HashMap charIndexMap = new HashMap();
for (int end = 0; end < s.length(); end++) {
char currentChar = s.charAt(end);
if (charIndexMap.containsKey(currentChar)) {
start = Math.max(start, charIndexMap.get(currentChar) + 1);
}
charIndexMap.put(currentChar, end);
maxLength = Math.max(maxLength, end - start + 1);
}
return maxLength;
}
}
How about this solution.
String s = "abcabcda";
char[] cc = s.toCharArray();
List stringList = new ArrayList();
int len = 0;
for(int i =0 ;i < s.length(); i++){
char c = cc[i];
if (!stringList.contains(c)) {
System.out.println("Adding to List " + c);
stringList.add(c);
} else {
if(stringList.size() > len) {
len = stringList.size();
stringList = new ArrayList();
stringList.add(c);
System.out.println("=======Reset List===== ");
}
}
}
System.out.println("Len "+len);