Video

Clear Concise Awesome!!!!

Thanks 🙏 😊

what about this : [-2,1,-1,-2,-2] , this contains cycle at 1, -1 but leetcode says it does not, and expects a false for (int i = 0; i < nums.Length; i++) { int pointer = i; if (nums[pointer] == 0) continue; int prev = pointer; int steps = 0; Console.WriteLine($"i :{i}"); while (true) { Console.WriteLine($"steps : {steps}, prev : {prev}, pointer : {pointer}"); if (steps > 1 && nums[pointer] == 0) return true; int modNo = nums[pointer] < 0 ? nums.Length - Math.Abs(nums[pointer]) % nums.Length : nums[pointer]; int nextPos = (pointer + modNo) % nums.Length; Console.WriteLine($"nextPos : {nextPos}"); nums[pointer] = 0; prev = pointer; pointer = nextPos; steps++; if (prev == pointer) break; } } return false;

wahesh khaye l irfan!

Are you learning or Teaching?

Good

Non-optimal. Second part (Bucket) should be on heap.

merci le sang ggrace a toi j'ai eu un sur vinfgt

One more correction is that in else it will be like (stack.isEmpty()?i:i-1-s.peek())

Too good explanation but just a correction it will be if(stack.isEmpty() || hist[stack.peek()<=hist[I]) Thanks for the video it was very much helpful

Jesus jobs nowadays with such a tough interview and your job is not even secure

bhai kya bol raha hai

if (RectA.X1 < RectB.X2 && RectA.X2 > RectB.X1 && RectA.Y1 > RectB.Y2 && RectA.Y2 < RectB.Y1)

function areaOfOverlap([[ax1, ay1], [ax2, ay2]], [[bx1, by1], [bx2, by2]]) { const len = ([a1, b1], [a2, b2]) => Math.min(a1, b1) - Math.max(a2, b2) const ox = len([ax2, bx2], [ax1, bx1]) if (0 > ox) return 0 const oy = len([ay2, by2], [ay1, by1]) if (0 > oy) return 0 return ox * oy }

if we start at index 0 this is so easy that 1) I would not expect this at a Google interview and 2) there's an easier solution: if we can make N steps without going out of bounds, there's a loop. Same big-O complexity, but about twice faster in reality. If however a loop can start at any index, then it becomes interesting

Hi Irfan .. I wanted to ask can I get a testimonial for my CV from the owner of the repository after I have done my CONTRIBUTIONS

The solution for this could use a modified B+ tree where the interior nodes store the separators between the sets and the leaf nodes only store sequence start value + sequence length for each set. There would be one leaf node per consecutive sequence. The driver function would just build the B+ tree, and keep track of the largest sequence as it did so.

Great video and approach to answering the question for a coding interview by the way. One thing I would change based on your solution would be to start the iterators at 1 instead of zero. Not only would that save iterations (as you don't need to change the cloned values when i or j are zero, but it also removes the need to check if i or j are zero. Again, great video

I need answer for this question Given an array of Given an array of N integers where each number a[x] indicates a stack of cubical bricks of height a[x] Essentially the array represents N stacks of bricks. The goal is to determine the largest nxn matrix (square matrix ) embedded in this array of stack Input format: First line indicates the size of the integer array say N Each of the next N lines represent the height of the stack at index x where 12,+x<=N Constraints 1<=N<10^4 0<=x<10^4 Output Value of n where nxn matrix is the largest one embedded in the stacks.

When are new videos coming

main() {

this is my way

Sometimes I got zoned out. Nice effort but still room for improvement.

Bad. Most of programmers can’t even solve it with recursive, why everyone directly jump to DP without more detail in recursive way.

very great explanation.

In what language can a method return either boolean or int?

If we mark the index that the current index is pointing to by making that no. Negative ...so we can check if the no. Is already negative then it's visited that means it has cycle. So time complexity will be O(N) and space complexity will be O(1) as we are using the given array for marking.

this concept is not about which is better its about how well you understand stack and recursion'

Спасибо большое, дорогой учитель Ирфан

so, if stack is a million elements deep we are just using a million deep call STACK.... rrrrrrrrright.... well, thank you, I'm leaving - have no interest to work here :P

Dude, this man is going serious with the look and feel. He's even using blue shirts for FB videos.

Maybe I missed it but isn't it a big assumption to consider rectangles edges will be parallel to the x, y-axis? or rather two rectangles will be parallel.

watched this video twice and it worked for me

You spent the first 8 minutes saying you were going to do top down DP, then suddenly you started doing bottom up DP. If this was supposed to simulate a real interview, that was be pretty obvious you knew the solution already.

Time complexity for the solution would be O(n!) that is Big-O of n factorial

Thanks for showing we can cheat using a recursion call stack instead. I would have assumed this can not be done since I thought using recursion is basically using a stack and discarded this solution. Next time I would not assume things in the interview, rather just ask the interviewers if I can do it or not.

when Input= [1,2,3,4,5,0,9,8,0,1,2,3,6,0,5,4,7] ...?

Great video

Very helpful! Thanks so much

Do we have a case where one rectangle is parallel to x axis and the other not parallel (both in quadrant 1)?

Insightful! Thanks for sharing

I am also thinking the same

Great video, as always

very nice sir well explained!

I was expecting to see a different implementation because of the disconnection of E and F. Interesting to see its the same as a typical DFS.

Just a small note, do not completely rely on Grammarly. Grammarly occasionally makes mistakes. So if you're not 100% sure it's a mistake, do not submit a PR for it.

I would go about this differently... Since we know the input matrix is 4 rows and 5 columns, the largest square of 1s there can be is 4x4, so the only place that can be is at the upper left corner or 1 element to the right of that. As soon as we scan across the top row, we see a 0, and realize a 4x4 of 1s cannot be present. We repeat this logic with 3x3 and find it and then we are done. No need to fuss with squares of size 2x2 in this example because we are checking largest (4x4) to smallest (1x1) and stopping when we find one (in this case stopping at 3x3). More specifics about the algorithm at the 3x3 check step would be scan across until we find 3 ones in a row (literally), go back to that "home" position (the leftmost element), and scan down to see if there are 3 ones in a column. If so, now we have a 3x3 "outline" so check the remaining elements inside that (only 4 more elements to check). If all are ones, we are done. Actually an improvement of this algorithm can be to first count up the # of 1s. Since we only have 14, we know that a 4x4 square of 1s is not possible, so immediately start looking for 3x3s since there are at least 9 1s. There are likely many more algorithms that will solve this too. Probably dozens.

Actually, you can solve this problem in O(log(n)) time using matrices and binary exponentiation ( I don't know us it necessary in interviews)

XOR would be the simplest as suggested by a few others. If I was doing your solution, I'd add the new 'unvisited' element to a stack, pop the element when I see it next and whichever elements stays in the stack at the end is your guy.

What is a cycle?