need to be in-place, so queue is not optimal

I used to either see solution for backtracking or simply skip Due to my incapability of coping with tedious work of dryrun Now I'm good Thanks to Eric❤ and striver❤

Love the way , he frames his own test cases and cross check the code

Just use sort(colours) And thank me later

I have started seriously doing leet code from August Ill be back and comment back i get a job Unlike @nguyenquoctran8423

Thanks

Thank you i learnt sorting 2d arrays while seeing this solution

Ill do it on my own after 6months lets see if can remember the logic

Man I want to do these problems on my own😢 You are great btw ❤

Thanks man

Thanks ❤ this needs practice and repetition

I didn't get how second for loop solves the issue that first for loop couldn't solve

Thanks it helped ❤

Thanks ❤

Good explanation mate

Eric Underrated and so much deserving tutor ❤

Great explanation！whats tool to draw on the board? Can I add into my interview?

🎉❤

❤❤❤

Thanks eric❤

Why can't we use Queue<Integer>q=new ArrayList<>(); I do got an error using this line , as soon as I change it to Linkedlist its accepted?

Thanks a lot ❤

Premium question ill pass

thank you.. one of the best explanation this is for the problem.

Thanks 😊

Why its hard to get for the first time

I understood the first approach so I skipped second one

How to come up with these ideas on my own 😮

How to come up with this idea on our own

Great approach

I didn't understand when to reverse and how we applied reverse, on what basis we do reverse,btw there are 2 reverse i understood second one but not 1st

Thanks

❤

Please Make your dsa tutorial public 😢😢

Make private videos public

Your first solution isn't working

Please enable private videos

Bro kindly enable to access your dsa tutorials ❤

Bro please make your tutorials public

Please make you tutorials public

can u solve and add 1610 in 2 pointer list and remind me after doing it?

Great explanation.

Great explanation!!

Really good explanation!!!

Thank you

Excellent video, thanks brother.

in a sequence 3 - 2 - 1, we have calculated the longest subarray starting at "2". But we cannot simply reuse that for 3->2, since the location of the 2' match in the other array may be disconnected from the location of the 3's match.

Why L+1<R? Ur reason It would be helpful for this community if you switch your algorithms playlists to public, Or i can pay if it's premium

Thank you, this helped me come up with the following solution in Javascript /** * @param {string} s * @param {number} numRows * @return {string} */ var convert = function(s, numRows) { if(numRows <= 1) return s; let hashMap = {}; let arrayOfIndexes = []; for(let i = 0; i < numRows; i++) { hashMap[i] = ''; arrayOfIndexes.push(i); } let superCounter = numRows - 1; let down = false; for(let j = 0; j < s.length; j++) { let index; if(j < numRows) { index = j; hashMap[index] += s[j]; continue; } if(down) { superCounter++; hashMap[superCounter] += s[j]; down = superCounter < numRows - 1; continue; } else { superCounter--; hashMap[superCounter] += s[j]; down = superCounter === 0; continue; } } let output = ''; for(h in hashMap) { output += hashMap[h]; } console.log(hashMap, output, 'hashMap'); return output; };

This is still one of the best explanation for that's out there for this logic. Thank you for making it.