Hey everyone, welcome back to the channel. I hope you guys are doing extremely well. So this is another lecture from the Stryber's A2Z DSA course.
Just in case you're for the first time here, this is world's most in-depth course on DS Algo. Why do I say that? Because in this course, I'll be covering over 455 modules and we will be solving more than 400 plus problems.
You can go across the internet, buy any of the paid courses on DS Algo. None of them will be covering DS Algo in such depth. So once you complete this particular course, you can actually clear. any of the ds algorithms in any of the companies in any part of the world so till now we have covered until step 3.1 this particular problem in this video i will be covering all these five problems in case you want a solution for a particular problem the timestamps will be there you can switch between problems if you want to do that so without waiting let's get started with the first problem that is finding missing number in an array so what does the problem state the problem states you'll be given an n And you'll be given n minus 1 numbers. Okay.
So these n minus 1 numbers will be containing numbers between 1 to n. So if you see 1 is there, 2 is there, 4 is there, 5 is there. Who is not there?
Yes. 3 is not there. So your answer will be 3 because 3 is not here. Since 3 is not here, the answer will be 3. So you have to find the number that is not there.
Between 1 to N. In this case, 1 to 5. So, 1, 2, 3, 4, 5. 1 was there. 2 was there. 4 was there. 5 was there.
3 was not there. So, this is what the problem states. So, if this question comes up in an interview, the first solution that you will be giving is definitely the brute force solution because you will never jump to the optimal solution because it's you who has to drive the interview. So, what is the brute force solution?
The brute force will be like... Okay, I know the numbers will be from 1 to n. So I'll be like, cool, let's take 1. Does 1 exist?
Yes. So 1 is not my answer. Let's take 2. Does 2 exist? Yes. So 2 is not my answer.
Let's take 3. Does 3 exist? No. So 3 is my answer. So what I will do is, I will take every number, and I'll check in the array if it exists or not by linear search. And if it doesn't, then that's my answer.
So that will be the initial brute force solution. How will the code look like? Let's check it out.
So basically you say for, I know the numbers will be from i till n. That's something which I know for sure. Now let's do a linear search.
For int j equal to 0, j lesser than, I know the size is n minus 1. So j lesser than n minus 1 and j plus plus. What I do is, I know the number is i. If array of.
j is like we can just scroll through and figure out figure it out if it does exist so flag can be set as maybe 0 and if this is equal to equal to I I can say that yes it does exist and we can break out quite simply and this can be inside the if and outside this for I can say if flag is still 0 which means this number was not there because if this number would have been there at any moment flag would have turned to one so if the number is not there i know my answer like you can directly go ahead and say i know my answer is i quite simple you pick up one you check entirely does it exist you pick up two you check entirely does it exist you pick up three you check entirely does it exist or not so what will be the time complexity two loops one for n they are the near about 10 so can i say two loops means the time complexity the worst case if i if the last number is not found and this gets executed at the last last assume five was not here assume five was not here and three was here in this case the loop will entirely run from one to five and when it comes to five it will not find five so the worst case will be this loop runs entirely and this loops keep on keeps on running every time like that's That's nearly the worst case, not exactly the worst case because a lot of times you'll find here, so the loop will break. So I can say the worst case, which is again, very impractical. The worst case is kind of n square.
Again, it's a hypothetical scenario because when you're looking for one, you found one here and you broke out. When you are looking for two, you found two here, you broke out. So this will never go till the end. So it's a hypothetical scenario.
Got it? That's how you explain to the interview. And the space complexity used is because of one.
That's my brute force solution. This is how you should explain to the interviewer so that your thought process, your concept clarity is clearly visible to the interviewer. So when you tell the brute force solution to the interviewer, he'll definitely not be happy and he'll ask you to optimize it.
That's when you go across and give him the better solution, not the optimal one. And you'll say, maybe I can use hashing. And how will you use hashing? So you know the numbers are between one to five. And if you want a hash 5 somewhere, you need that fifth index.
So if you need the fifth index, you will have to declare an array of size 6 as your hash array. So in the hash array, I will declare the array of size 6. I go ahead and declare the array of size 6. If you declare the array hash array of size 6, then you will get the fifth index, which will be your last index. Now what you will do is, once you have declared the hash array, you will start iterating.
So 3 is your number, so 3 is your answer. So we can easily solve it using hashing as well. Let's look at the code.
The code is going to be super simple. I'll be like okay hash of size n plus 1 and everything will be initially zero. And then we will be going across and saying let's go across the array and I know for that array element I have to mark in the hash array.
So array element is array of i. So I go to the hash and say plus plus or I can say mark equal to 1. I can simply say mark equal to 1. Done. Once I've done this, I know the numbers are from 1 to n.
So I'll go from 1 to n and I'll say if my hash of i is equal to equal to 0, that is going to be my answer. That is going to be my answer. And this will be your answer whenever you find out the hash i to be 0. So what will be the time complexity?
Let's analyze a single big O of n loop and another big O of n loop. So it's a time complexity of 2n at the worst case. So if I ask you about the space complexity, that's definitely big O of n because we are using a hash array in order to hash all the elements so that we can remember which one was not present.
Got it? So that will be your better solution. So when the interviewer again hears the better solution, he'll be like, okay, we did work on the time complexity, but now I'm not...
impressed with the space. Can we optimize the space complexity or not? Now this is when you'll come up with the optimal solution. Now remember one thing, this problem can have two optimal solutions. One is the sum, the other one is the zord.
And I'll tell you both and I'll tell you the minor difference between them. So something I know for sure is, if n is 5, the numbers in them will be 1, 2, 3, 4, 5. And if I sum them up, if I sum them up, I know in order to sum up the first n natural numbers. The formula goes as n into n plus 1 by 2. Very basic maths.
So it's like 5 into 6 by 2. So the summation is 15. You can also sum it up. You will get 15. So that is the summation of the first n natural numbers. Now I will go across and I will take an S2. And I'll start iterating.
Okay, 1. Maybe I'll just erase this so that I can reiterate. So I'll go to 1. I'll be like add up 1. So, 1 added. Then I'll go to 2. Add up 2. So, this will become 3. Then I'll go to 4. Add up 4. That will become 7. Then I'll go to 5. Add up 5. So, I'll be like, okay, 12. So, we have 12. Now, if one number is missing, then, can I say 15 and 12?
The difference will be that one number. Because you summed up every one. Whom did you not sum up?
The one number that is missing. So, if... You have to take the summation of the first n and summation of 1 missing.
So what will be your missing number? Yes, your missing number will be sum minus s2. Your missing number will be sum minus s2. So it's very simple.
Use a summation to have a formula of n into n plus 1 by 2. And then you say for i equal to n, you can keep s2 equal to 0. i equal to 0 to n. And you can keep s2 plus equal to array of i. And your number will be... Quite simple summation minus S2 will be your number. Very, very simple.
So this is how the summation works. What will be the time complexity? We're just running a single loop in order to submit all the R elements.
This is a straightaway formula. So the time complexity is b go of n and the space complexity is b go of 1. Is it better? This is the best we can do. But we can still do better.
That is Zor. Now you might ask me, but Straver, how can you... do a better with ZOR.
That's when I'll explain you this. Let's understand. So coming to the second optimal solution that I was talking about that involves ZOR. Now a lot of people might not be knowing ZOR. Do not worry.
I'll be covering ZOR in depth when I cover the bit manipulation part. But as of now, just understand one concept of ZOR. That is if you ZOR same numbers, the ZOR of that is always zero. What do I mean by same numbers? If you say two ZOR two, it will be zero.
If you say 5 ZOR 5, it will be 0. If you say 2 ZOR 2, ZOR 5 ZOR 5, that will also be 0. Why? This in itself is 0. This in itself is 0. 0 ZOR 0 will also be 0. Got it? If you say something like 2 ZOR 2 ZOR 2 ZOR 2, then it will be like 0 ZOR 0. That will be 0. If I say 2 ZOR 2 ZOR 2 ZOR 2 ZOR 2, it will be like this is 0. This is 0. ZORed with 2. So this is 0. Zod with 2. And 0 Zod with any number is the number itself.
Is the number itself. This is the thing that you have to remember. Nothing else. That's the thing that you have to remember.
So, coming to the most optimal solution. So, I hope you have understood. Till now. N is 5. So, when I say N is 5, I know N natural numbers. It's like 1, 2, 3, 4, 5. I know 5 natural numbers are these.
And if I... write this will it be like one two four five do you can you somehow relate this to Zor you can you'll say striver what I can say is there are same so if I if I try to do a Zor each of them will be zero and only this guy will be left because I know zero Zor any number is any number I'm like yeah that's true so what I will do is I'm like okay fine let's do one thing you Let's take a variable Zor1 and in that, do this. And remember when you do this, there will be a number stored. So we have one district, right?
Okay, Zor1 is done. What about Zor2? I will take Zor2 and I'll be like, I trade through the array.
Let's I trade through the array. So if I trade through the array, one is at first, then there's two, then there's four, then there's five. So Zor2 is computed.
This will be a certain number which will be computed. But in the back of the number, the computer knows that this is what it means mathematically. I know a number will be generated. But mathematically, it still means this.
So, what will happen? If you do a ZOR of 1, ZOR of 2, what will happen? Yes.
Yes. This and this will be together, which will be 0. 2 and 2 will be together, which will be 0. Then 3 and there's no 1 with 3. So 3 will be alone. 4 and 4 will be 0. And there's 5, which will again be 0. 5 and 5. So this 3 is alone. So apparently 0s or 3 will be 3. So you get the number 3. Because they will cut off.
They will cut off each other. They will cut off each other. And the only... number remaining will be 3. Quite simple. So in order to implement this, how do you write the code?
We'll be like, let's take ZOR 1 equal to 0. And then we start from, sorry, 1. And we go until n. And we go like ZOR 1 equal to ZOR 1. And I know the array size is, like we need ZOR 2. So ZOR 2 equal to 0. The array size goes on till n minus 1. whether this will be n minus 1 and i know xor2 will be xor2 xor array of i quite simply separately xor1 is computed xor2 is computed so the answer is xor1 xor of xor2 this will be your missing number can i say this will be your missing number i can and that's what you can easily return fine we have solved the problem where we have returned the answer Now the question comes up, but let's try one. We are using two for loops. Hence the complexity is 2n. How is this better than this one?
I'm like, I can still do it. I can still do something. Okay, let's erase this loop. I'm like, no, I will not run an extra loop. I will not run an extra loop in order to compute that.
I will try to put the Zor one over here. So this loop is running like if n is 5, This loop is running from 0 to 3. Can I say this? This loop is running from 0 to 3. Why?
Because the indexing is 0, 1, 2, 3. So the loop is running from 0 to 3. So if I write something like this, ZOR 1 equal to ZOR 1 ZOR i plus 1, what will happen? The loop that is running from 0 to 3 will end up ZORing 1 because instead of 0, I took... i plus one so it's like one is or two is or three is or four because zero to three means one more separately this will mean i'm running from one to four because i did a i plus one so i've absorbed everything in place for zor1 but if you remember zor1 was taking everyone till five so five the n the n is not zored so the end of the day you can say after the for loop zor1 will have to zor with n as well Because it did soar till 4. It requires n.
Once you have done this, you can do this. So now, the big O of 2n boils down to big O of n. And that's how you explain it to the interviewer. Because this will tell him about your thought process, about your thinking ability.
Got it? Done? Now, if I have 2, which one is better? Apparently, this one is slightly better.
Why? Imagine n is given as 10 to the power of 5. And summation is doing... n into n plus 1. Which means somewhere like 10 to the power 5 into 10 to the power 5 plus 1 divided by 2 which is nearly 10 to the power 10. Nearly. And this cannot be stored in an integer. It will overflow.
So you need a bigger data type. Something like a long. And if you take a bigger data type I'm not saying it is going to take a massive space. Slight.
Slight more memory will be required. That's why this is better. Why?
I did tell you. When we do ZOR The ZOR never exceeds the largest number. So at max, the ZOR will be 10 to the power 5. It will never exceed.
Thereby, the time complexity will be gone. But we're using integers. We're not using longs. It's slightly better.
Got it? So this is how you drive the interviewer from the brute to the better to the two optimals. And you tell him everything. Everything that you know. And trust me, this is where the interviewer gets impressed.
That's why I always prefer this method. Now the interviewer knows that you know the optimal, but when you show all the facets of your thought process, he knows, you know, brute, you know, hashing, you know, the sum concept, you know, the long, you know, the Zor one loop, you know, why Zor is better, you know, everything. That's when he says, let's hire him.
So coming back to the code editor, you have the code editor, the problem link will be in the description. I've written the same code. And this time what I'll do is, I'll just say Zor one.
as I said, Zor1, Zor, capital N. And I've taken the size as this. And now I will go ahead and try to submit this and see if it is running fine or not. It is and all the test cases do pass. So I can go back to the sheet and we can mark it because this is done.
Let's come to the next question, which is maximum consecutive ones. So what does the problem state? It's very simple. Maximum consecutive ones.
You will be given an array of zero and ones. So if I have to look at the consecutiveness of ones, so there are two ones here, there are three ones here, and there are two ones here. So consecutive ones are these ones.
So can I say the maximum consecutive ones is three? And that's what you have to tell me. Is that's what you have to tell me.
So the answer is three. Now, how do you solve this problem? So this question comes up in an interview. Do you go the same way as brood, better, optimal?
Now, if you... Start thinking about the root better. I think that will take a lot of time. Because the optimal solution is very straightforward.
So what do you say is, okay, as of now, I know that there are no 1s. I have not figured out any 1s. I'll keep a counter as 0, right? What I will do is, I'll start iterating. Okay, 1. Increase the counter by 1. So counter 1, that means the consecutiveness is 1. So the maximum gets updated.
okay let's move ahead the counter gets two the maximum gets updated let's move oh zero Wait, zero means there's a break. There's a break in the consecutiveness. If there's a break, do I still count?
No, if there's a break, I fall back to zero because the consecutiveness is broken. So I fall back to zero. I'll again continue.
One, again count. But is this one greater than the longest? No, so I do not replace. Then I move, again I increase. Then I again move, again I increase.
This time when I increase, I get 3. So the consecutiveness is 3, which will be replaced. Because now we have 3, which is better than 2. Let's move. 0, again broken. Fall back to 0. Let's move. 1, let's move.
2 is 2 greater than maximum. Iteration complete. When the iteration is complete, your maximum stores the maximum.
And that's your answer. And that's your answer. So what is the time complexity?
We go off n. Single iteration with just a minor if-else loop will do it. So if I have to write the code, it's very simple. You're given the nums array. So what I'll do is I'll keep the maximum as 0. And this is the answer that I'll return.
So we can return it. Perfect. And now I can keep the counter as 0 as well. So keep the counter as 0. Now let's iterate for this, which is like nums.size. And I know if nums of i is equal to 1, the counter increases, and the maximum will take the maximum of both.
If it is not, then what happens? That means if it is 0, I fall back to 0. Quite simple. 1 if, 1 else. And we are pretty much done.
So I will quickly go and submit this. So if I submit this, this is accept. Let's come back to the sheet and I can say that this problem is done. Now you'll be like, wait, this is looking something different.
Yes, why? Because previously there was this problem, find the row with maximum number of ones, which I moved into binary search. Why this?
Because this problem will be involving binary search. And I just realized that I haven't taught you binary search yet. Let's move it into the binary search. Now coming back here, we see that this problem has been split into two. So this problem is widely searched.
and i won't be covering this problem in this video why because i want my channel to be visible i want new people to discover my channel so i'll be making a separate video where i'll be covering both of these problems first one is finding the longest sub-array with given sum with just positives in the array the next one is longest sub-array with given sum which has positives and negatives in the array both of these i'll be covering in the next video for this video the last problem that i'll be covering is this one So what is the problem state? The problem states you'll be given an array where every number appears twice apart from one number that appears once. So you have to find that one number that appears once. I think you know how to do it.
We have already done a similar kind of approach in this problem where we were finding the missing number in an array using the Zor concept. So over here, if you carefully see, 4 is appearing twice. 3 is appearing twice.
1 is appearing twice. And the only number that isn't appearing twice is 2. So the answer will be 2. Now I'll quickly move on this problem. Whenever this problem comes up in an interview, what is the brute force approach? The brute force is very simple.
You pick up every number once. First you'll pick up 1. And you will do a linear search on how many times 1 appears. And you'll find that 1 appears twice. so that's not your answer next you will go to this one and you'll again do a linear search and say how many times do you appear it will again be two so that won't be your answer next you'll pick up two and you'll do a linear search and you'll find that two appears once so that will be your answer how do you do this you know the numbers like will be in the array so the number will be no one but the array of i that is something which i know now you'll again iterate in the array from zero to n And probably you can keep a counter equal to 0. And you can say if array of j, because you're iterating in the array, is equal to equal to number, you can do a counter plus plus.
So once the iteration is over, if the counter is 1, that means the answer is this particular number. That's how easily you can do it. If I ask you the time complexity, again, quite simple. n loop, n loop. So the time complexity is b go of n square because I'm picking up every element one by one, doing a linear search and counting it.
And at the end, I'm comparing the count. So the time complexity is n squared. And the space complexity is B go of 1. So that is how the brute force approach will look like. So you are done with the brute force solution. Now the interviewer will definitely ask you to optimize this.
That's when you come up to the better solution. Please hear me out properly for the better solution because the concept of time complexity and space complexity will be well explained using this particular problem. So better solution.
So the better solution will definitely be to use hashing. Very obvious. I just hash it. And then using that, I tell who appears first. But then what data structure am I going to use to hash it?
Let's analyze that. So over here, the maximum element that is kept is 4. So I can probably say, if I create an array of size 5, then it will have the last index as 4. And I can probably initialize everyone as 0. I can probably initialize everyone as 0. And I can start iterating. Okay. 1, okay, 2, okay, 1, okay, 3, okay, 3, okay, 4, okay, 4. So at the end of the day, only this particular guy 2 will have a hash value of 1. And that will be the guy who is appearing once. Understood?
Very simple. But the question is, what size of hash array do you define? What size of...
So... hash array do you define and the answer is pretty simple the maximum element you define the hash array to be size of max element plus one over here it was four so you defined a size of five very simple so can i say this can i say this first step if you are going to use an array for hashing will be to figure out the maximum element because without that you cannot create the hash array So maybe maxC equal to array of 0. Let's do it. And it will be like maxC equal to max of maxC comma array of i.
And this will give me my max element. Very obvious. And now I will define an hash array of size maxC, which is initially initialized to 0. Done. Now what I need to do?
I trade in the array from 0 to n. I'll say hash, can you do at your place of array of i to be plus plus? So kind of I can say, this loop ends up taking b go of n.
This loop for marking will end up taking b go of n for sure. Now what's my job? My job is to figure out who appears once. Who appears once.
So the best way that you can do is, you can say, hey listen, hey listen. I will probably start going from 0 to n again. And I'll just say. If hash of array of i is equal to 1, that array of i is my answer. Pretty simple.
Yes. And that's big O of n. And that's big O of n. So that's like big O of 3n.
And what is the space complexity? Can I say the space complexity is nothing but we're using... and hash of a size maximum element of a size maximum and that is something which will depend on the input you cannot specifically say so the time complexity is 3n and the space complexity is this now you can argue that this big of n can be trimmed why because over here it was like zero one two three four five six the size was seven you will end up at the worst case If 2 was placed at the last, I repeat. If 2 was placed at the last, you will end up iterating for bigo of 7 times. I could have done it better.
I could have done it better. If I would have iterated just from 1, like I know the minimum number might be 0. And the maximum might be 4. So if you could just iterate from 0 to 4, that will also do your job. And there will just be 5 iterations.
Which is better than 7 iterations. But again, what if instead of 4, 4, I had 8, 8. Then this loop will end up iterating 9 times, which is not good. So instead of this, this is better.
So depending on the input, it will vary. So you can tell that to the interviewer that, Sir, I'm not sure. Depending on the inputs, this is also okay.
If we use this, this will be the complexity. If we use the loop, where we go from zero to max element and for every element we see how many times the talk is Then it will be b go of max for the last loop, depending on what you're trying to use. Now, the interviewer might say, but can the hash array be used every time? And the answer to that is no.
Why the answer to that is no? Think on that. Imagine I tell you that the array has negatives.
The array has negatives. Can you hash negatives? Probably yes, probably no.
But what if the array has... Big numbers like 10 to the power 9 like 10 to the power 12 very very big numbers in that case in that case You cannot hash it you cannot hash it in an hash array That's when you have to use the map data structure with a bigger data type as a key With a bigger data type as a key and the value can be int So you have to use a map data structure and now this can be an unordered map in C++ Depending on what map you use will The time complexity will vary. Now what can I say?
Okay, if I use map data structure, I'll probably do the same thing. Well, re-iterate. Assume I re-iterate on 1 and the map data structure is empty. Iterate 1 once, 1 twice, 2 once, 3 once, 3 twice, 8 once, 8 twice. At the end of the day, your map data structure will look something like this now you can iterate on the map and it'll be like okay key one how many times two next key two how many times one so this key is your answer this key is your answer i trade in the map and get your answer let's analyze again if i have to code it can i say the first thing will be very simple i'll just go from zero to n and i'll say map data structure Can you do an array of I++?
Quite simple. What will be the type complexity? If we use an ordered map, it will be n logarithmic of n, where n is the length of the array and this n is the size of the map.
This n, like probably you can write m, this m is the size of the map. But if you use unordered map, the best case can be be GovN. I know the worst case of unordered map is big of n, but that rarely happens. So I can say big of n is the best case, but the worst case is n.
Like the unordered map might take big of n in order to find something. So the worst case still can be n square if we use unordered map. So you can tell that to the interviewer that this will not happen.
So we can use an unordered map, but if you're saying that the inputs are very critical, and the worst case can happen then i'll switch back to ordered map again i've explained this in the time complexity class so depending on what map you're using the time complexity will vary done what's the next step i'll just iterate in the map and that's very simple if you're doing c plus plus this is how you will be iterating the map if you're doing java you can definitely google or you can find it in the notes i know the value is what i have to check so the value is always stored in the second parameter So the second parameter is 1. I'll say it.first is my key. Is my key and that's my answer. Again, in order to iterate in the map, what will be the time complexity is my question to you.
Very simple. Time complexity is, how many elements did you store? 4. Where the size of the array was 7. Where the size of the array was 7. But you just stored 4. It's like, you stored n by 2 elements. Why? Every number appears twice.
Every number appears twice. So the number of elements you'll store is n by 2 plus 1. Why plus 1? The one guy who was appearing once. So this loop will run for n by 2 plus 1. Because most of the number appears twice.
So they're like, we'll take one occurrence of it. There's one guy who's appearing once. So this loop will run for these many times. The worst case.
The total over time complexity. boils down to n logarithmic of m but again m is the size of the map and the size of the map is n by 2 plus 1 plus b go off n by 2 plus 1 for this loop and the space complexity will be b go off n by 2 plus 1 for a map data structure again this logarithmic can vary if you're using an order map for the best case better is done if you tell these many things to the interviewer he will be like dude I don't need to hear the optimal. Anyways, let's go back. to the optimal solution why because definitely the interviewer will not be impressed with the extra time a lot of iterations so he might ask you to optimize this this is when you give the optimal solution so let's come to the optimal solution it's very simple what are we hearing every number appears twice twice twice twice there's one who appears once we have done the same problem using zorg property what we will say is okay listen Since everyone appears twice, if we do a ZOR, they will cancel off. Is it?
Yes, they will cancel off. So what we will do is, we will do a ZOR of all their elements. Because ZOR clearly states, if they are same numbers, and if you do a ZOR, the corresponding value is 0. So if you do a ZOR of all the numbers, it's like 1, ZOR 1, ZOR 2, ZOR 3, ZOR 3, ZOR 8, ZOR 8. So what will happen is, this will club to give 0, ZOR 2, this will club to give 0. This will club to give 0. 0, ZOR, 0, ZOR, 0, ZOR.
It will be like 0, ZOR, 2. 0, ZOR, any number is the number itself. You got your number. Pretty simple. It's just a one-liner that you have to write.
For ZOR can be kept as 0. You can start from 0 to n. And you can say ZOR equal to ZOR, ZOR, array of i. And your answer will be ZOR. Because when you do an entire ZOR, everyone will cancel. That one guy will be single and he will be left as an answer.
The optimal has a time complexity of bcof n and has a space complexity of bcof 1. This is where you end the solution in an interview. So if you want to solve the problem, the problem link will be in the description. You can go and try it out and submit the code. So going back to the sheet, I can say that this problem is also done.
And I'll be covering these couple of problems in the next video. So guys, I hope you've understood everything because my main focus was to teach you basics. I wanted to teach you how do you approach an interview in terms of brute, better, optimal because it's you who's going to drive the interview. So please be careful about that. So with this, I can say that we have done 12 basic problems.
After this, we'll be moving to the tougher versions of the problems. So mostly you'll find single video for most of the problems because These problems are searched a lot on YouTube and I want my channel to be visible. So mostly we'll find single videos for the long, like the tougher problems.
So with this, I will be wrapping up this video. But to continue our tradition, if you've understood everything, you got to comment understood beneath the video. And yes, if you're new to our channel, please, please do consider subscribing to us. You can find all the links in the description. With this, I'll be wrapping up this video.
Let's speed in some other video. Till then, bye-bye. Your heart is broken, don't ever forget your golden