Video

Simple solution: /** * @param {number[]} nums * @param {number} k * @return {void} Do not return anything, modify nums in-place instead. */ var rotate = function (nums, k) { k = k % nums.length; nums = nums.slice(-k).concat(nums.slice(0, -k)); };

Please continue the series sir more leetcode solution please

I wish the helper functions would've been explained more, you just built upon the fact that everyone has read the book.

I understands codes more when it's been coded than explained on paper or board. You explained it very well, and it's actually easy to comprehend. Thank you!

thats was soo poorly explained

the audio is so low I can't hear you. but great job!

left + (right - left) === right

great explanation

Man, thank you so much. I am beginning to get pretty comfortable with linked lists, but this problem turned my brain into mush and I finally decided it was better to just see it demonstrated and then use that knowledge in future problems. Your explanation was so clear and concise, I finally actually understand this fully.

Best vid I found today for understanding quick sort. Thank you!

I hardly heard your voice, I don't know if it is from your microphone or you are not speaking louder...

hello, /** * @param {string} s * @return {boolean} */ var isValid = function(s) { let input=s.split(""); let count=0; for(let i=0;i<input.length;i++) { for(let j=i+1;j<input.length;j++) { if(input[i]=='('&& input[j]==')' || input[i]=='[' && input[j]==']' || input[i]=='{'&& input[j]=='}') { count++; } if( input[i]=='(' && input[j+1]==')' || input[i]=='{' && input[j+1]=='}' ||input[i]=='[' && input[j+1]==']') { return false; } } } if((count*2)==input.length) { return true; } else { return false; } };

thank you so much for this video!!!! helps me a lot

👌👌

Nice video 🤗, just that the sound wasn't clear enough

Thank you so much. This solution is the most understandable!

the 3rd example doesn't work, but needs an absolute value comparison in the diff calculation(values with less than zero)

Nice Explanation but your video sound is too low .

thank you

Thank you. Your explanation felt intuitive!

It seems there's no need to include 0 in your reducer. The method will still properly add up all your vaules.

Very solid explanation. Much appreciated!

Great Job! Love your content

Had to watch it 3 times, it makes sense, thanks for making this video!

What if all values in first array are greater than those in second array and the first pointer goes out of range first?

Your explaination is very incomplete, you totally skip explaining the update part.

you lost me on this one bro

for (let r = 0; r < matrix.length; r++) { for (let c = r; c < matrix[0].length; c++) { [matrix[c][r],matrix[r][c]] = [matrix[r][c],matrix[c][r]] } } Why this is generating error in leetcode IDE but runs in jsfiddle

Time complexity for this one is O(n*2) because Array.prototype.reverse has O(n) and next two reversals have k and n - k combined O(n) and all combined O(n*2). To make it O(n), we can use the same revNums function for whole array reverse as well.

var levelOrder = function(root) { if(!root) return []; let queue = [root]; let result = []; while(queue.length){ let len = queue.length; result.push(queue.map(node => node.val)); while(len--){ let node = queue.shift();// for(let child of node.children){ queue.push(child) } } } return result; };

ummmmmm but the last one doesn't make a region it just makes a 3rd branch from node one. IM so confused

/** * Definition for a binary tree node. * function TreeNode(val, left, right) { * this.val = (val===undefined ? 0 : val) * this.left = (left===undefined ? null : left) * this.right = (right===undefined ? null : right) * } */ /** * @param {TreeNode} root * @param {number} targetSum * @return {number[][]} */ var pathSum = function(root, targetSum) { if(!root) return []; const paths=[]; const dfs = (node, sum, slate) => { if(node.left === null && node.right === null){ if(sum === node.val){ slate.push(node.val); paths.push(slate.slice()); slate.pop(); } } if(node.left){ slate.push(node.val); dfs(node.left, sum - node.val, slate); slate.pop(); } if(node.right){ slate.push(node.val); dfs(node.left, sum - node.val, slate); slate.pop(); } } dfs(root, targetSum, []); return paths; };;

these videos are a life saver thanks andy

the content is great hope you get back soon

Well explained!

Can anyone tell me which 'drawing' software is he using plz?

Thanks a lot, I understand everthing!

This problem is so confusing even with this great explanation. i,j i-1, j-1 haha I need to slowly repeat this vid

Where do we start with your DSA videos?

Thanks for your insight and good content.

You could also use a map for parens which I feel is more intuitive. Here's a solution I found easier to understand. /** * @param {string} s * @return {boolean} */ var isValid = function (s) { //handle the edge case //create a map holding the opening brackets macthed to the closing bracket //create a stack to hold the opening bracket //loop through s and check if the bracket in the stack matches the current bracket //if not push item to the stack //if stack is empty return true else false if (s.length % 2 != 0) return false; const map = { "(": ")", "[": "]", "{": "}" } const stack = []; stack.push(s[0]); for (let i = 1; i < s.length; i++) { let stackEl = stack[stack.length - 1]; if (map[stackEl] == s[i]) { stack.pop(); } else { stack.push(s[i]); } } return stack.length == 0; };

blessed with your explanation !!

I appreciate that you kept the debuggining process in. Makes me feel better about making mistakes :)

Simply brilliant! Extremely intuitive and easy to remember - thanks so much for this and many of your other videos, Andy!

I think line 19 the else statement could be removed, because if the value is more than one the while loop wouldn't run, so it would never see it. Right? or am I missing something? great video btw

I have been trying a code using 2 for loops but somehow the output is not coming in the code editor of leet code but in the chrome console,it is coming as expected. Any help?

Thanks for the explanation. I initially started using a linked list stack and it got way too complicated. This solution is great👍🏾

Just wanted to share my solution with the community: const lengthOfLongestSubstring = (s) => { let seen = new Set () let max = 0 let left = 0 let right = 0 while(right < s.length){ if(!seen.has(s[right])){ seen.add(s[right]) max = Math.max(max, right - left + 1) right ++ } else { seen.delete(s[left]) left++ } } return max; }

voice is so low

function lengthOfLongestSubstring(s) { if (!s.length) return '' let max = -Infinity let set = new Set() // how do we shrink the run when we find a duplicate? let a = 0 for (let z = 0; z < s.length; z++) { if (set.has(s[z])) while (set.has(s[z])) set.delete(s[a++]) set.add(s[z]) max = Math.max(max, z - a + 1) } return max } The time complexity of the lengthOfLongestSubstring() function is O(n), where n is the length of the string s. This is because the function iterates over the string at most once, and each iteration performs a constant number of operations. The space complexity of the function is also O(n), because the function uses a set to store the unique characters in the current substring. In the worst case, all of the characters in the string will be unique, and the set will contain n elements. How does the function shrink the run when it finds a duplicate? The function shrinks the run by moving the left pointer (a) forward until it reaches the first character that is not in the set. This ensures that the substring always contains unique characters. For example, consider the string s = "abcabcbb". When the function reaches the character c at index 2, it will add it to the set and update the maximum length of the substring to 3. However, when the function reaches the next c at index 3, it will find that it is already in the set. Therefore, the function will move the left pointer forward to index 1, which is the first character that is not in the set. The function will then continue iterating over the string, starting at index 1. In the end, the function will return the maximum length of the substring, which is 3.