LeetCode Exercise In Java - Longest Substring Without Repeating Characters - FAST Solution

Sdílet
Vložit
  • čas přidán 23. 07. 2024
  • Full tutorial for solving the LeetCode longest substring without repeating characters problem in Java!
    Thanks to Mailgun for sponsoring this video! Go to mailgun.com/john to try Mailgun today.
    00:00 The Problem
    03:51 Brute Force Solution Discussion
    07:27 Brute Force Solution Implementation
    15:57 Brute Force Solution Results
    16:35 Coming Up With a Better Solution
    20:09 Fast Solution Discussion
    26:50 Fast Solution Implementation
    32:34 Fast Solution Results
    33:21 Even... FASTER?
    ☕Complete Java course:
    codingwithjohn.thinkific.com/...
    Are you starting to grind LeetCode in Java, but getting stuck on the how to figure out some of the trickier fast solutions?
    In this video we'll walk through a fast solution for the LeetCode longest substring without repeating characters problem, LeetCode Problem #3, written in Java!
    📕 THE best book to learn Java, Effective Java by Joshua Bloch
    amzn.to/36AfdUu
    📕 One of my favorite programming books, Clean Code by Robert Martin
    amzn.to/3GTPVhf
    🎧 Or get the audio version of Clean Code for FREE here with an Audible free trial
    www.audibletrial.com/johnclean...
    🖥️Standing desk brand I use for recording (get a code for $30 off through this link!)
    bit.ly/3QPNGko
    📹Camera I use for recording:
    amzn.to/3wlXcmR
    🎙️Microphone I use (classy, I know):
    amzn.to/3AYGdbz
    Donate with PayPal (Thank you so much!)
    www.paypal.com/donate/?hosted...
    ☕Complete Java course:
    codingwithjohn.thinkific.com/...
    codingwithjohn.com

Komentáře • 179

  • @CodingWithJohn
    @CodingWithJohn  Před rokem +15

    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!

    • @aryansanojraj6618
      @aryansanojraj6618 Před rokem +1

      Can you let us know the compiler you use for the videos?

    • @ripanpramanick425
      @ripanpramanick425 Před rokem +1

      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

    • @ZelenoJabko
      @ZelenoJabko Před měsícem

      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.

  • @playtopgames3261
    @playtopgames3261 Před rokem +67

    Best java chanel on CZcams

  • @nahomg6945
    @nahomg6945 Před rokem +55

    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 CZcams, perhaps a course?

    • @Achraf_0101
      @Achraf_0101 Před 3 měsíci

      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

    • @joydeep_
      @joydeep_ Před měsícem

      Same feelings here, we need more leet code problems...

  • @vijal-patel
    @vijal-patel Před rokem +25

    please keep doing these, your explanations are so much more in depth than other youtube channels

  • @jayshreebarathod6997
    @jayshreebarathod6997 Před rokem +13

    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 !!

  • @tund_101_hd9
    @tund_101_hd9 Před rokem +5

    This is probably one of the best tutorials out there and i think CZcams 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!

  • @thomas_m3092
    @thomas_m3092 Před rokem +7

    John, you are a wizard. Everythings looks so logical and simple. Please make more videos like this.

  • @isaacwhiz
    @isaacwhiz Před rokem

    You are really a coding geek. Even the concepts known, still visit them and keep something. Your explanations are far reaching. Thank you.

  • @minakianrad812
    @minakianrad812 Před rokem +3

    An excellent in-depth explanation of two approaches to solving this problem. Thank you very much, John.

  • @Michaelpschreib
    @Michaelpschreib Před 6 měsíci

    I appreciate that you go into the brute force solution and also the more clever solution. Thanks for these!!

  • @zerkinanastya4410
    @zerkinanastya4410 Před rokem

    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!

  • @yasasmaddumage
    @yasasmaddumage Před rokem +5

    I love this series. Thank you...

  • @ronakpatel8441
    @ronakpatel8441 Před rokem +2

    Hey John, I love all of your videos. Learning so many important skills. However, I have one suggestion, If you could make more of this type of problem-solving videos then it would be very helpful to the viewers as it will teach new programmers how to think of a solution to the given problem and how can we actually implement the solution using the programming language.
    By the way thanks again for all efforts that you put in to make this possible.
    Looking forward to seeing more problem-solving videos. Have a wonderful day.

  • @SimanAndGarfunkel
    @SimanAndGarfunkel Před 4 měsíci

    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!

  • @ArunKumar-jk5pq
    @ArunKumar-jk5pq Před rokem

    This is awesome way of teaching! Thanks John!

  • @rushio8673
    @rushio8673 Před rokem +2

    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.

  • @Tibetan-experience
    @Tibetan-experience Před rokem

    Thanks John. Always putting these awesome videos.

  • @zainahmed755
    @zainahmed755 Před rokem +1

    Best channel ever ! , please keep going with the leatcode series

  • @claytonalmeida6046
    @claytonalmeida6046 Před rokem +14

    Would love to watch a complete java dsa course from you

  • @Soromeister
    @Soromeister Před rokem +1

    Love the series and quite a nice explanation on the different approaches, although the last one is confusing for me.

  • @user-kuzya2023
    @user-kuzya2023 Před rokem

    Спасибо Джон. Продолжайте и дальше радовать нас своими видео. Thanks John. Continue to delight us with your videos

  • @lanatimmo3686
    @lanatimmo3686 Před rokem +4

    It's great! Please, do more Leetcode Exercise explanations!🙏

  • @kevolala
    @kevolala Před 8 měsíci

    This is the most detailed and accurate explanation of this problem I've seen. 👍

  • @gauravmehta6831
    @gauravmehta6831 Před 5 dny

    A unique way of explanation, clear concise.

  • @sankalp.m.patilsmp1472
    @sankalp.m.patilsmp1472 Před rokem +1

    this channel has wonderful content, and easy to understand explaination.

  • @EdgarRamirez-ry2je
    @EdgarRamirez-ry2je Před rokem +1

    Excelent explication of a leetcode coding challenge, thanks i hope to see more videos of coding challenges medium and hard

  • @olyamychko4315
    @olyamychko4315 Před rokem +1

    Thanks for great explanations!

  • @kafychannel
    @kafychannel Před rokem +1

    Great explanation,thank you !

  • @chrisjames278
    @chrisjames278 Před rokem

    great video. Keep them coming!

  • @zoflax
    @zoflax Před rokem +1

    this series is actually so good.

  • @OsaetinEvbuoma
    @OsaetinEvbuoma Před rokem +1

    Hi John. I previously implemented this solution (yours) using a while-loop (and using the map) instead of a for-loop and got similar runtime numbers to the last solution you found (6ms runtime). Not sure why that's the case. But yeah, the last solution, intuitively should be a worse runtime even though it seems like it performs better. It's also a clever solution too. Nice work!

  • @liamoua9192
    @liamoua9192 Před rokem

    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.

    • @CodingWithJohn
      @CodingWithJohn  Před rokem

      Thanks so much for the very kind words!

    • @91-ritikjain36
      @91-ritikjain36 Před 9 měsíci

      when we get full playlist of leetcode in java you are amazing i am from india @@CodingWithJohn

  • @SaifaldeenSAH
    @SaifaldeenSAH Před rokem

    The best explaining ever, hoping to make more videos plz or DS and Algo videos. Thank you.

  • @markmuyot2436
    @markmuyot2436 Před 4 měsíci

    I liked your videos, you made them all easy to grasp! please do more leetcodes tutorials and data structures and algorithms content

  • @deepakroy3476
    @deepakroy3476 Před 4 měsíci

    You make programming easy and simple

  • @gurjeevjohal5459
    @gurjeevjohal5459 Před rokem +1

    You're videos are so helpful, one 5 minute video is worth 6 hours reading a chapter in a book. Please can you do some videos or a playlist on design patterns. Thanks!

  • @ashashankar29
    @ashashankar29 Před rokem

    Excellent explanation and solution. I clearly understood the problem and solution. thank you

  • @pedroalves5482
    @pedroalves5482 Před rokem

    Hi, first time watching your videos, and I love the clarity of your explanation.
    I think I figured out the reason of Map been more slowest than last example, when you use the hash map you as writing and updating the data, to have the current letter position. On the other side the s.index only search if exist this value.

  • @elizabeth00653
    @elizabeth00653 Před 8 měsíci +1

    John I love your Java explanations, can you please add more leetcode to your channel or bootcamp? I would love to see more Java leetcode solution guides properly explained

  • @otisopoku37
    @otisopoku37 Před 7 měsíci

    Your explanations are very good. More leetcode!!!!!!!!!

  • @hendhasnaoui9419
    @hendhasnaoui9419 Před 11 měsíci

    i'm really impressed 👍👍. keep on going 👏👏👏

  • @adriangonzalez6564
    @adriangonzalez6564 Před rokem

    Awesome video!!!
    You are by far the best coding tecaher i could find in internet.
    Coud you do a video explaining how to read a csv file in Java?? It would be great.
    Really very good content, keep doing it

  • @thelazymim9338
    @thelazymim9338 Před rokem

    Best Explanation. Please make videos on All LeetCode's 145 top interview questions. You will be immortal for the Computer Programmers Community.

  • @MTB_Bay_Area
    @MTB_Bay_Area Před rokem +2

    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.

  • @markmuyot2436
    @markmuyot2436 Před 9 měsíci

    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

  • @shaileshsathe9779
    @shaileshsathe9779 Před rokem

    Great and in-depth explanation for every approach. I really liked this video. I have found another better approach
    final int n = s.length();
    int len = 0;
    int [] repeat = new int[128];
    for (int c = 0, j = 0, i = 0; j < n; j++) {
    c = s.charAt(j);
    i = Math.max(repeat[c], i);
    len = Math.max(len, j - i +1);
    repeat[c] = j+1;
    }
    return len;
    I somewhat understood, but it would be better if you can explain. Thanks John and keep creating more videos for different problems.

  • @158thavashankarrajakc9

    need more tutorials please :) thank you!

  • @logesh9141
    @logesh9141 Před rokem +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

  • @SimoLPers
    @SimoLPers Před rokem +1

    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.

  • @antonignatenko7776
    @antonignatenko7776 Před rokem

    if possible more videos like this, especially interested in thought process behind solutioon

  • @rcciit9226
    @rcciit9226 Před 10 měsíci

    Wow so easy to learn and understand , you have a new student sir.

  • @bendror8302
    @bendror8302 Před rokem

    Nice to learn from you John, can you add more solutions from LeetCode?

  • @sheko4515
    @sheko4515 Před 5 měsíci

    Can you please do more videos like this as you explain it in a great way.

  • @dadaboymasharipov2653
    @dadaboymasharipov2653 Před rokem +1

    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

  • @chinmayrath8494
    @chinmayrath8494 Před rokem

    thanks for the video !!

  • @psg9278
    @psg9278 Před rokem +1

    Thanks Please do more

  • @EdgarRamirez-ry2je
    @EdgarRamirez-ry2je Před 8 měsíci

    More videos like this with solutions for diferent letcode, hackerank problems this is very much usefull to improve skills, you explain as a master

  • @jatinkumar7287
    @jatinkumar7287 Před rokem

    Thanks for this explaination🥰

  • @Harsha._.
    @Harsha._. Před rokem

    Awesome best explanation 👏

  • @alexanderkomanov4151
    @alexanderkomanov4151 Před rokem

    AMAZING!

  • @blairliu9058
    @blairliu9058 Před rokem +4

    More leetcode videos plzzz! love this series.

  • @tiagocarvalho4119
    @tiagocarvalho4119 Před rokem +5

    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).

  • @saeednoshadi3922
    @saeednoshadi3922 Před rokem +1

    This playlist is amazing, Why don't you continue this series of videos?

  • @tiyoo6961
    @tiyoo6961 Před rokem

    Thank you

  • @aneeshdixit4
    @aneeshdixit4 Před rokem

    Thank you for the amazing and clear explaination.
    Can you explain this next? 992. Subarrays with K Different Integers.

  • @bendror8302
    @bendror8302 Před rokem +1

    wow thanks 🙏

  • @Shivam-gh2mq
    @Shivam-gh2mq Před rokem

    I watched till 25:32 and was able to come up with a solution. Thanks for this amazing explanation!

  • @swagatpandak7325
    @swagatpandak7325 Před rokem +1

    Continue this series in java please.Thanks john.

    • @CostaKazistov
      @CostaKazistov Před rokem

      Yes, please!
      Most LeetCode videos out there are either Python or C++
      Definitely want to see more LeetCode walkthroughs in Java (or Kotlin)

  • @NiChOlAs-gw7iw
    @NiChOlAs-gw7iw Před rokem

    wow pls, do more Leetcode exercise explanations!

  • @ozzDeveveloperOpenForWork

    perfect. you have more question answer videos, like a playlist of them? Thanks

  • @jonathanhawkins9147
    @jonathanhawkins9147 Před rokem

    Yum just a subscriber with the initial sponsor ad

  • @manambalaji9547
    @manambalaji9547 Před 9 měsíci

    Really you are awesome 🎉

  • @laharibasu9731
    @laharibasu9731 Před rokem

    Can you please make more of these leetcode java solutions videos. They are of great help and you make us understand wonderfully.

  • @Laughing_india_
    @Laughing_india_ Před rokem

    love from india❤️ Pls upload a problem on daily basis

  • @shakilansari8967
    @shakilansari8967 Před rokem

    Lots of love from India...

  • @rahulg1715
    @rahulg1715 Před 4 měsíci

    At 35:00 we should use indexOfFirstAppearenceInsubstring

  • @quandingleberry445
    @quandingleberry445 Před rokem

    Great video, also I think the last part might be bc of best case scenario

  • @rishiraj2548
    @rishiraj2548 Před rokem

    Thanks

  • @foratzoabi1311
    @foratzoabi1311 Před 6 měsíci

    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!

  • @jordanT_alker
    @jordanT_alker Před 2 měsíci

    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.

  • @germimonte
    @germimonte Před rokem +1

    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?

  • @raygilbertflies
    @raygilbertflies Před rokem

    Hello John, I have watched a lot of your videos and I like your teaching style. This is a lot off topic but I am currently trying to learn java. I have gone through iheritance and on to composition. I was really excited about composition and took the Vehicle/Car concept from inheritance and wrote a few more classes: Corvette, engine, transmission, accelerator. I made Corvette a composition of the four:
    Corvette vett = new Corvette(engine, transmission, accelerator, fuelTank) This works as long as the Corvette class does all the work because it has access to all the other classes. I am trying to find out if(itIsPossible) to make a composition within the composition so that as well as the car accessing the same engine, transmission and accelerator, the engine and transmission would likewise have access the same accelerator, the transmission and accelerator access the same engine and the accelerator accesses the same engine and transmission.
    So far, I have tried 27,354 different ways after looking at thousands of videos and forums,

  • @MTB_Bay_Area
    @MTB_Bay_Area Před rokem

    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.

  • @arthurmagamedov3179
    @arthurmagamedov3179 Před 11 měsíci

    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.

  • @VinuCP
    @VinuCP Před 9 měsíci

    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.

  • @twokatana
    @twokatana Před rokem

    Great Video! But what book would you recommend for learning java?

  • @nicovogel9924
    @nicovogel9924 Před rokem +2

    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 :)

  • @MTB_Bay_Area
    @MTB_Bay_Area Před rokem +1

    Maybe HashMap takes longer because I the calculation of the hash? To get to a value HashMap first calculate hash value, and only then go to the location.

  • @hasibulhasansiju
    @hasibulhasansiju Před rokem

    Want more of this

  • @rameezalam1968
    @rameezalam1968 Před 11 měsíci

    Hi Johnny sin, good to see in as a software developer role as well

  • @Verdarin
    @Verdarin Před rokem +1

    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)

  • @diegosuarezgarcia248
    @diegosuarezgarcia248 Před rokem +1

    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.

  • @germimonte
    @germimonte Před rokem +8

    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

    • @CodingWithJohn
      @CodingWithJohn  Před rokem +6

      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
      @cipherxen2 Před rokem +3

      @@CodingWithJohn you don't need array of 50000 elements, just 255 for ASCII characters

    • @bhaskarpurkayastha485
      @bhaskarpurkayastha485 Před rokem

      @@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;

  • @bekuostudio
    @bekuostudio Před 8 měsíci

    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

  • @ALEXGAYMAR2312
    @ALEXGAYMAR2312 Před rokem

    Could you please do one about Polymorphic load/save methods for Java Io file handling

  • @helcium2022
    @helcium2022 Před měsícem

    More leetcode examples please

  • @xeanluxcrille6847
    @xeanluxcrille6847 Před rokem +2

    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.

  • @ananthukkumar987
    @ananthukkumar987 Před rokem

    hi john I've a doubt over here, does using .toString or just +"" instead of String.valueOf makes any difference

  • @aamirshekh934
    @aamirshekh934 Před rokem

    What are the java project that will be modern..Or i should have to learn other tech stack to make project to stand out??

  • @_Anna_Nass_
    @_Anna_Nass_ Před rokem

    More leetcode problems!!! I like this style of video 🧌