Видео

Can you not also start at the beginning and step forward? We keep track of the maximum distance you can travel at each step. Either your previous step -1 or the current steps.

Thanks for the nice explanation. Probably the best out there for free. Just wanted to make sure one thing. At 14:45 when you run heapify and heapop separately the time complexity of the overall function should be n+logn, not n+nlogn and hence O(n) a the end.

I feel you need to be good at math to crack this one on your own.

Is that any language proficient on execution in front of interviewer?

NICE SUPER EXCELLENT MOTIVATED

The visualization did wonders to help me tackle this problem. I didn't even have to look at the actual implementation to solve it after looking at it!

I would really like to see a neetcode add a daily question based on my progression in the road map. Like you said, some questions are derived from other questions. So a daily question based on which questions I’ve completed to allow me to flex my understanding to conform to a new yet similar problem would be great. Love your videos ❤

Doesn't resetting curSum to 0 assume that there are values in our array that are >= 0? What if all our values are negative?

for me I was able to come with recursive solution, no problem at all but not able to come with dp approach as was not able to find how the states would be saved and it does happen with me a lot. any idea on how to become better at this

Interview: do you talk the same way ? ADHD of FryingPan 😳🤣🤣

you dont need any other python video after seeing this one... the one I've seen previously is useless in comparison

What is the space complexity ? Since we are using HashMap and Set?

At 11:35 you say "Plus C again", but this is the most profound and mysterious part of the entire problem, and you just casually and flippantly throw that out there as if it's intuitive or known, while trying to intuitively explain the problem. You're trying to grant us intuition with a magical answer that reveals no intuitive understanding. 😬💡

Nice! Sir, I just love the way you explain the answers. I think we can also stop the iteration when R.next == nil so our L will be at position where we wanted. Then we won't need dummy node.

After watching previous video, I successfully solved this on my own. Upon reviewing your explanation, I realized that we arrived at the same solution. So happy that i improved, ty

Wonderful explanation. I have bachelor degree of IT and only now have I understood what big notation is all about. Thank you

Its a little unclear to me as how this would be a dp problem, as the title of the video states. I guess if you wanted to approach this as a DP, it would be good to draw this as a decision tree and where the DP kicks into the solution exactly. So far the approach with using two converging pointers is way easier to understand and use.

based of combination sum 1 and subset 2 : class Solution: def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: res = [] candidates.sort() def dfs(i,cur,total): if total == target: res.append(cur.copy()) return if i >= len(candidates) or total > target : return cur.append(candidates[i]) dfs(i+1, cur, total + candidates[i]) cur.pop() while i + 1 < len(candidates) and candidates[i] == candidates[i+1]: i += 1 dfs(i + 1, cur, total) dfs(0,[],0) return res

thanks goat

based of subset 1 and skipping the same elements on second path class Solution: def subsetsWithDup(self, nums: List[int]) -> List[List[int]]: sub, subs = [], [] nums.sort() def backtrack(i): if i >= len(nums): return subs.append(sub.copy()) sub.append(nums[i]) backtrack(i+1) sub.pop() while i + 1 < len(nums) and nums[i+1] == nums[i]: i += 1 backtrack(i+1) backtrack(0) return subs

I really recommend using whiteboard every time you make a technical challenge, specially in interviews, it shows you understood the problem and it makes you explain how you are designing the solution. It also (for example) helped me get the best solution in the 375 - Guess Number Higher or Lower just by drawing the problem. Never had a 0 milliseconds answer on a solution that I wrote on my own 😅

Tiny optimization but you don't have to start at len(arr)-3 you can start at len(arr)-4 bc the second to last element will never be smaller if it jumps to the last element first before the end of the staircase. It will always stay the same.

No one cares!!!!!!!!!

Thank you

I think understanding the cycle update and doing it with an outer loop is something that people would more likely come up in the interview! I wonder what is the better way to solve this in actual interview

I got asked this question in an internship interview @Microsoft. wtf 😂😂 When I was asked this question I thought it was kinda weird in a way that it sound easy but at the same time felt kinda off. Of course I didn't even come near this solution and when I looked it up my sus feelings were correct 😭😭

The posDiag and negDiag solution is amazing!

Thanks a lot buddy... Very helpful ❤

If you guys are tired of multiplying -1 inorder to get max heap in python, I've implemented a simple code snippet. I hope it helps you :) Happy learning. import heapq from typing import * class BaseError(Exception): pass class IncorrectObject(BaseError): pass class MaxHeap: def __init__(self): self.elements = [] def __getitem__(self, ind): item = self.elements[ind] return -item def __len__(self): return len(self.elements) class MinHeap: def __init__(self): self.elements = [] def __getitem__(self, ind): item = self.elements[ind] return item def __len__(self): return len(self.elements) def heappush(hp: Union[MaxHeap, MinHeap], item: int) -> None: if isinstance(hp, MaxHeap): heapq.heappush(hp.elements, -item) elif isinstance(hp, MinHeap): heapq.heappush(hp.elements, item) else: raise IncorrectObject("Incorrect object passed") def heappop(hp: Union[MaxHeap, MinHeap]) -> int: if isinstance(hp, MaxHeap): return -heapq.heappop(hp.elements) elif isinstance(hp, MinHeap): return heapq.heappop(hp.elements) else: raise IncorrectObject("Incorrect object passed") if __name__ == '__main__': minHeap = MinHeap() maxHeap = MaxHeap() for item in [1, 2, 3, 4, 5, 100, 90, 70, 80]: heappush(minHeap, item) heappush(maxHeap, item) print("minHeap top:", minHeap[0], "maxHeap top:", maxHeap[0]) while minHeap and maxHeap: print("heapop minHeap:", heappop(minHeap), "heappop minHeap:", heappop(maxHeap))

I still don't quite get it. The problem description asks us to return the head. The merged linked list is the head?

Great to hear this..keep doing what you love bro

how the hell is this an easy problem

I wrote this way: def merge(self, intervals: List[List[int]]) -> List[List[int]]: i = 0 finalList = [] intervals.sort(key = lambda i: i[0]) while i < len(intervals): start = intervals[i][0] end = intervals[i][-1] while i+1 < len(intervals) and end >= intervals[i+1][0]: i+=1 end = max(end, intervals[i][-1]) finalList.append([start, end]) i += 1 return finalList

this question only increase my depression because it made me feel myself like a numb

Can't you just have a z pointer that goes through each element In the array and an i and j pointer that multiplies all elements before z and after z? That's the solution I came up with and it looks like this: class Solution: def productExceptSelf(self, nums: List[int]) -> List[int]: output = [] for z in range(len(nums)): product = 1 for i in range(z + 1, len(nums)): product *= nums[i] for j in range(z - 1, -1, -1): product *= nums[j] output.append(product) return output

I dont understand why it should be 1 when you're already on step 5

You believe in honor and problem solving until companies only hire the “other candidate” who does bullshit their way through. 5 months of job searching with morals ruins you, trust me

Explanation super difficult, code super easy hahahahha

@NeetCode - If output of this code/ our final result was allowed to be say a set of tuples(instead of List of lists of the triplets) could we have done without the need of sorting the input array, because then the set will automatically not contain duplicate tuples of 3 elements in it even if we add duplicate tuple of triplets, later on in the set. ? Haven't reworked your example code to this approach but worth trying.

thanks man

yo, bro, there is actually a better solution! using bfs you can each level just add to a res q[-1] node

fuck you and take my money. In all seriousness, i bought your course and in the process of grinding with the hope of getting into google.

U a God

return true if not false que porra é essa irmão?

Appreciate Your hard work. It was hard. I will need to review again a few times to figure out and remember.

In CPP, is there any elegant solution to this? I can't make the HashMap with the array due to some limitation. The go to solution it seems is to literally just use the sort algorithm and hashmap with a string of the sorted words.

this was asked to me in the first round of an interview

I think it should be O(n * log(k)) at 2:30

Nice, thanks for that

Both, the way you explain and the animations you provide, are truly awesome!