Screencast || Spectral::Cup 2026 Round 2 (Codeforces Round 1100, Div. 1 + Div. 2)

Hinzugefügt: 2026-05-25

[00:00:03][clears throat] >> chicken Okay.

[00:00:18]They didn't start in some line where I slime is at position A I on the line you have to perform the following operations a number of times select integer X for each J is the name.

[00:00:28]If you have just this, then just do this or do this.

[00:00:39]For each slime count the difference and then the minimum.

[00:00:48]Is that the maximum?

[00:00:52]minimum maximum max maximum Yeah, int n c n and right. It's just the maximum difference from each element in n c n vector int a n for I equals zero I less than n I plus plus c n a of I right answer is equal to I will initialize by int max What is the value of a of I? It can be up to 10 to the power Oh, it's up to 1,000 only, right?

[00:01:43]for int I equal to zero I less than n plus plus for I uh int the value is equal to zero for int j equal to zero j less than n, j plus plus of val is equal to max of max of value comma absolute value of int of absolute value of a of i minus a of j uh answer is equal to min of answer comma value c out answer It's 2 0 I think n squared should pass because n is up to 1,000. Failed or what?

[00:03:00]I Okay.

[00:03:06]n is up to 1,000, no? i is equal to zero i less than equal to 1,000 I have to choose this, right? 1 to 1,000, right?

[00:03:20]1 to 1,000 and then just do i minus this.

[00:03:24]And then it should pass.

[00:03:35]Slimes on a line.

[00:03:36]I think they should pass, right?

[00:03:42]Because a of i is up to 1,000 oof Wait a minute.

[00:03:57]What if Huh, if sum of n doesn't exceed 1000, then it's good.

[00:04:04]Hmm, then it's good. Then it's not T 80.

[00:04:07]Ah, yeah, it's positive. Absolute cinema. You find yourself with two arrows of positive indices A and B both of length n. You are You are to perform the following operation a number of times. Select an integer i and swap A of i B of i. Determine the maximum value of max of A plus summation of B of i.

[00:04:25]Okay, so you can just apply any number of times. You can swap A of i and B of i.

[00:04:40]What is the maximum value that you can attain?

[00:04:42]All right.

[00:04:43]If let's suppose what because I need the maximum across B of i, right? So what I will do is A of i, B of i, whichever is maximum I'll update that to B.

[00:04:58]And Yeah, sure. That is just it's like go I just update the maximum values to B.

[00:05:12]That should work because all the values of B you will always take.

[00:05:25]Ah. [sighs] A of n, B of n, B of n.

[00:06:57]>> It should pass.

[00:06:58]3 3 18 27 Why it should pass because see uh I will always take the maximum value in B.

[00:07:10]Because if I don't, I won't include the value. But if I take I will always include that value. I can even for A I can have multiple maximum values.

[00:07:20]Uh if I read the question right.

[00:07:23]Then it has to be simple.

[00:07:30]But if I read the questions right.

[00:07:35]Just don't tell me key I read it wrong.

[00:07:38]And made Greater than 9, right? It should pass.

[00:07:48]What is my standings now?

[00:07:51]Oh.

[00:07:52]It's 1,000.

[00:07:56]Oh, nice. There are people who are Oh, tourist and everybody is solving faster than me.

[00:08:00]>> [snorts] >> This is the easy version of the problem.

[00:08:02]The difference between the version is that in this version you must minimize the sum. You can have the version before all the You have an array of length n which contains non-zero negative integers.

[00:08:10]But not non-zero.

[00:08:23]>> [snorts] >> So, you can take an index i where a of i is greater than zero, and for each index j which is less than this, you can you will do it my say that equal to minus of a of i.

[00:09:01]Ah, this is This is easy. What is the minimum now?

[00:09:11]Should be minimum. And what do you need to output?

[00:09:26]>> [clears throat] >> Okay. Okay, so you will do A of J to minus A of J. So, it's like you choose the positive element and then behind that multiply all the negative elements to negative one.

[00:10:04]So, I look three.

[00:10:18]So, let's suppose there are N indices and I choose to perform N operations.

[00:10:22]So, what will happen is if I do first operation and I do second operation after that, so the effect of the first operation would be cancelled because let's suppose first operation made some elements negative.

[00:10:32]It will make all the elements negative behind that. But the second operation will again make that all the elements positive and will make the between elements negative.

[00:10:43]Right. So, let's suppose I only have one operation. If I have one operation, the elements all the elements behind that would be negative. Like multiplied by negative one.

[00:10:52]The well, signum function will switch.

[00:10:57]And if I take three indices, let's suppose A, B, C, what will happen? We will swap this.

[00:11:02]Then it will we will when we do this, it will swap again and this will be swapped.

[00:11:09]This will original swapped original and when we do this, this is swapped, this is original, this is swapped.

[00:11:16]So, it's like you can do it possibly N times, right?

[00:11:20]So, what you can do is Okay. So, what you will do is you will try to Okay. So, And what is the hard version?

[00:11:40]This is the easy easy version.

[00:11:44]Minimal a maximizes the sum at the end. All right, all right.

[00:11:51]Hmm. So, what I'm saying is let's suppose I perform any m arbitrary operations on i1, i2, i3, i4, i5, which means what it will happen is if I do i4 i5, this will swap. This will remain original.

[00:12:08]This will swap and this will remain original.

[00:12:15]So, if I if I perform both of the operations, the last operation will decide though.

[00:12:22]So, like for m operations, i of m i of m will decide for i of m minus one also, whether it's parity would change or not.

[00:12:34]So, what is the we we need to minimize the sum.

[00:12:37]>> [snorts] >> We need to minimize the value. So, which means what we need to do is we need to for every positive integer this.

[00:12:45]So, let's suppose for i1 I swap, what will happen is either we will take this sum or we will take the So, okay. So, let's do this way.

[00:12:56]We let's assume all the values of positive integers where are the occurring.

[00:13:02]For the first set, we can calculate what is the sum. Second set, we can calculate the sum. Third set, fourth set, fifth set and so on until the last set we can calculate the sum.

[00:13:12]Now, what we will do is we know if I flip this one, this will become negative.

[00:13:20]But I flip this one, this will become negative, but this will become positive.

[00:13:26]Right?

[00:13:28]If I flip even this one, this will become negative.

[00:13:34]This will become positive and this will become negative.

[00:13:40]If I swap this one, so so it's just a positive negative positive negative sequence. And all the other sequences are stand alone different. So, let's suppose let's calculate all the values, store them in a vector.

[00:13:51]If I is zero, there are zero numbers we can not add any operation.

[00:13:58]Okay, we will just add at the end.

[00:14:04]We'll count number of positive integers.

[00:14:07]If count is zero, then see out zero, return. And if count is this, you will get multiple answers. What you can do is one value will be this val, which is the current value. Second will be minus this.

[00:14:32]Or what if why do I want to do negative and if I'm doing this second one, why do I want to do this positive and this negative?

[00:14:43]So so what I mean is let's suppose I have calculated all the segment values.

[00:14:48]For all segment that is positive these values are positive, what I'll do is I'll just that at the end subtract the negative one.

[00:14:59]What is the maximum such that So, it's like I I can take the segment sums.

[00:15:14]And let's suppose this is positive, this is negative, this is positive, negative, negative, and positive.

[00:15:19]This is positive.

[00:15:20]Last segment I'll switch this, so this will become negative.

[00:15:26]Since this becomes negative, now this all changes. So, I will just flip that to make it positive again.

[00:15:33]To make it negative again.

[00:15:34]So, this is done two times.

[00:15:36]Which means it's still positive, so I'll swap this one to make this negative, but this will become positive.

[00:15:43]I will swap this one again to make it negative.

[00:15:58]>> [clears throat] >> So, just go till the back. If this is positive, swap this.

[00:16:07]If this is positive, swap this.

[00:16:20]If this is positive, I'll dissolve this group.

[00:16:32]And 21 Sure, thank you.

[00:16:36]Okay, so I'll just mix segments and I'll try to flip this such a way that I'll try to flip it positive become negative. Then if it's odd, this becomes positive. Oh, sure, that is the answer. N A of N, right?

[00:16:59]I'll have to sequentially do it.

[00:17:07]And I'll have to always do it from the back. Why from the back? Because the last operation determines what is the value of the previous operation, so it's better to start with the last one first.

[00:17:40]>> I'm just going to do max. What I'll do is I'll just set up on count also.

[00:17:53]I'll make a vector B.

[00:17:58]And I'll make some.

[00:18:06]If A of I And if A of I is positive, then what I'll do is I'll make every element including I negative, right?

[00:18:16]Mhm.

[00:18:18]If A of I greater than equal to zero, greater than zero, positive, then we don't push back some.

[00:18:25]And okay, so some plus is equal to A of I. I need to add this to the sum first.

[00:18:34]Add it to the sum. If A of I is positive, which means this sum will become push back to this.

[00:18:39]And then we'll do count plus plus.

[00:18:42]And if you do count plus plus, and then we'll then we'll set sum to zero again.

[00:18:49]Else, we'll just only do some.

[00:18:52]Else, we don't do anything. Because like if it's less than zero, it won't do anything. So, it's greater than zero. We will push back it to the sum, count plus plus, and sum this.

[00:19:04]And if some if sum greater than if sum not equal to zero Even if this is negative, then I have to make it positive. Even if it's just not this v.push_back sum Right?

[00:19:33]if count equal equal to zero c out zero end l return Okay, so I just need to return at this empty array and so let's see out zero end l Because if count is zero, then you cannot it and this, right?

[00:19:58]Just print one end of line.

[00:20:00]a zero end l c out end l end l return else vector int path Mhm. And vector int i n d indexes I will store this.

[00:20:17]i n d.push_back i So, what I'm doing is Okay, what do we Why do we even need to store this?

[00:20:38]We don't even need to store this as well because If there is no positive integer, if we can't even negate this out.

[00:20:45]There has to be a positive integer. So, this is good. It has to be commented out. Index and I'll just index put back this path.

[00:20:52]Okay, for int i equal to v.size i plus plus Oh.

[00:21:03]i greater than equal to zero i minus minus.

[00:21:08]I v.size minus 1.

[00:21:12]int step is equal to 0. How many steps we have taken till now?

[00:21:20]If steps mod 2 I got it's odd.

[00:21:26]Which means I have swapped once.

[00:21:31]So, let it let's suppose Okay, let's suppose it's even.

[00:21:35]When it's even So, if v of I is greater than 0 then path plus is equal to path dot push back IND of I because index of I will have the same size as this.

[00:22:06]x of I plus 1 and step plus plus.

[00:22:14]I could see I'm this is positive then I need to make minimize this, right?

[00:22:22]And if step is odd which means I have to negative this. If v of I is less than 0 path dot push back IND of I plus 1 and then step plus plus and for this, how many steps I have taken?

[00:22:43]c out step endl for int I equal to 0 I less than path.size I plus plus c out path of I Just put in the bar and then See what I did.

[00:23:07]So it should be zero, four, and then one four. Something like this.

[00:23:12]I'll just just test it once more.

[00:23:15]This should not be zero. Zero. Why? How?

[00:23:18]Zero.

[00:23:21]Okay.

[00:23:23]Minus one, minus two. This is zero.

[00:23:27]And I push back two.

[00:23:30]Then it's minus one.

[00:23:36]And I push back four.

[00:23:40]Okay. So after this, in second test case, this is made. So this is the Oh, what the I did?

[00:24:10]I just need to do first go from in find the first positive integer. Add that.

[00:24:15]That will become negative.

[00:24:17]And apart from that, everybody will become positive. So just go and do this, this, this.

[00:24:28]Just add three.

[00:24:30]Minus three, two, one.

[00:24:32]This will become positive.

[00:24:35]Oh, That is not the answer. I got it what I did wrong.

[00:24:41]Mhm.

[00:24:42]That is not required.

[00:24:46]I can just do I will do this.

[00:24:51]I'll do this. I'll do this. If count is equal equal to zero, then this.

[00:25:02]Not push back.

[00:25:04]I In index, I'll just push back the index of all positive elements. And I'll do count plus plus if this is this.

[00:25:12]Step is zero.

[00:25:16]Right? Path is zero. I will just tell for int I equal to zero I less than IND.size I plus plus Now what I'll do is if IND of I greater than zero see out >> [clears throat] >> Check if this is positive, add this to the path. This will become negative.

[00:29:18]I think do do one thing.

[00:29:21]If I indeed What it is?

[00:30:24]Five.

[00:30:35]I think this is I this was a easy all right. Did over thinking on this.

[00:30:40]It has to be just this only. You go from back, I check if it's positive, it's positive then subtract by minus one and then add that value to the path because all the positive elements will become negative one. And then check if there is any negative, add it to positive. Oh, if there is any negative, don't do anything because it's already negative. It will minimize the sum.

[00:30:55]I do make it positive, right? This was very easy. I overthink on this a lot.

[00:31:02]Which means I'll be pretty bad on my ranking.

[00:31:05]I'll have to make C and D fast.

[00:31:09]Uh no.

[00:31:12]I took a lot of time in solving this.

[00:31:14]I need to make C2 even faster. So, C2 is like we have to maximize the sum. So Now, if you want to maximize the sum, what we do is we want to subtract the negative values.

[00:31:27]And we will do only for this, right? If A if I greater than zero, then we will do for this. That is the constraint.

[00:31:33]Now, I need to do subset counting, something of sort of like that. So I think that then now the sub sequence counting will work.

[00:31:41]See.

[00:31:43]I just need to maximize this and I just need to give this output.

[00:31:50]So how will I maximize the sum? So, if I multiply this by negative one, so what means See, see. There's positive number. There are a lot of negative numbers behind it.

[00:32:12]Then there's positive, then there is negative.

[00:32:15]So, there is positive number, positive number, positive number, then there are negatives, negatives, negatives, and negatives. So, I can't touch these negatives. And there's positive one. I can't touch this positive, either. So, in this in this in this, I have some subsequence subsequence. If I choose I change this Let's let's suppose this value is positive, this is negative, this is negative. So, this become negative, this will become positive, this will become positive.

[00:32:41]So if it's positive, I'll not take this.

[00:32:44]I'll just definitely choose this.

[00:32:46]Because if this becomes positive and it also becomes positive.

[00:32:58]>> [clears throat] >> And this will also become negative, right? Then this is one segment. There are three segments.

[00:33:12]And let's say this was this will be discarded. Now this is positive, this is negative, negative, this is positive.

[00:33:18]I will not take this. I will change this one though.

[00:33:22]If this is negative, so this will become positive.

[00:33:25]Count will become one.

[00:33:28]This will become positive, this will become negative. If this is positive, I won't change this either.

[00:33:34]If this is negative it was positive.

[00:33:52]And if this doesn't becomes this Okay.

[00:33:59]So see how the solution looks like. So there are sub segments.

[00:34:07]If the sum is negative for this segment, then I'll just change flip this to make this positive.

[00:34:13]Which means now each and every value will flip.

[00:34:18]So I can't do it sub segment wise. So it's like, okay, and n is dependent on the fact that it is positive number.

[00:34:25]You decide to flip it or not.

[00:34:29]So why would I even flip it? I will flip it just only because before the next positive So, if I Okay.

[00:34:39]What will a positive flip do?

[00:34:42]So, a positive flip will flip all positives to negatives and all negatives to positives.

[00:34:48]Do I only flip once?

[00:34:52]If I flip multiple times, what will happen?

[00:34:55]See, after a flip, that particular index becomes negative.

[00:35:00]So, there's no point to do multiple flips.

[00:35:05]Right?

[00:35:06]Um I think this is not that hard. This is not that hard.

[00:35:13]There's no point to do multiple flips because each flip will turn that element to negative. So, I need to do a one flip for if I do a one flip, it will change all the positives to negatives and negatives to positives.

[00:35:31]So, I'll just maintain two arrays, prefix sums array, of total positive and count what total positive sum encountered so far and total negative sum encountered so far.

[00:35:40]If A of I is positive, and I check, okay, the total positive sum encountered so far is less than the total negative sum encountered. If I flip this bit, what it will do is it will in- make the positive sum equal to negative and negative equal to positive.

[00:36:02]So, the positive sum encountered so far will be greater than the negative sum encountered so far, which will maximize this.

[00:36:08]Now, it will still increase my step by one.

[00:36:13]Now, I go back and see, okay, till here, if A of I is negative now, because it would have been become positive.

[00:36:22]Up, positive negative or negative positive or negative If the total negative sum encountered so far which was the actual positive is greater than this. So, if it's odd if it's even steps are even if negative is greater than positive, swap.

[00:36:43]Step plus plus.

[00:36:45]Else, if positive is greater than negative swap.

[00:36:50]S plus plus.

[00:36:53]I think that should be the answer.

[00:36:56]L vector int P1 n comma 0 if n is greater than 0 P 1 of 0 is equal to A of 0 else P2 of 0 is equal to A of 0.

[00:37:28]Hm.

[00:37:31]For int I equal to 1 I less than n I plus plus if A of I greater than 0, then uh P one second.

[00:37:48]P1 of 0 is equal to P1 of Oh, P1 of I. What I'm doing?

[00:37:55]is equal to P1 of I minus 1 P2 of I is equal to P2 of I minus 1.

[00:38:07]Uh if A of I I can't hear you.

[00:38:20]greater than zero.

[00:38:24]Oh, damn.

[00:38:27]If your voice greater than zero, pre one of I plus is equal to A of I.

[00:38:38]else pre two of I plus is equal to A of I.

[00:38:49]Okay, and uh Count is zero to hey. Count will be the steps.

[00:38:55]Vector and indices is zero to hey.

[00:38:58]Okay.

[00:39:01]If count is equal to zero, Okay.

[00:39:12]If I were greater than zero, the count plus plus. If count is equal to zero, so I have zero to done in the length path.

[00:39:16]I'll give you a path for a minute.

[00:39:18]Value is this. Step is this.

[00:39:24]But I is equal to n minus one.

[00:39:27]I minus one is ticket.

[00:39:30]Now, A of I multiplied is equal to value.

[00:39:34]Right?

[00:39:37]If step mod two equal equal to zero. Which means it is the initial configuration to we have but if pre two If A of I is greater than Okay, shouldn't it be just DP?

[00:40:11]Because I have two choices, right?

[00:40:13]Either I take either I not take.

[00:40:17]For each value, I have two choices.

[00:40:23]I think I did I did I don't think.

[00:40:25]I think it should be DP instead of greedy.

[00:40:37]Is it DP? So, why is greedy not work?

[00:40:42]So, if I'm saying it's positive, no, but steps will also increase.

[00:40:49]If it's positive, don't just see.

[00:41:02]What if you make sure this is positive, if I is greater, you check if I is greater than this.

[00:41:23]And okay, so it's greater than zero and negative sum is way more greater, but negative sum was still here, was way high. Positive sum was way high. Here positive sum is way much, and here negative sum is very less. Like it's all positive, but then this is high. So, you do this.

[00:41:38]And there's also one positive here.

[00:41:44]Instead of doing this, you will do from start.

[00:42:20]>> So there's one positive integer, two positive integer, three positive integer, and so on. So if it's one positive integer here somewhere here I can just choose to flip this.

[00:42:31]I will choose check whether this satisfies or not. If it does, add this.

[00:42:36]How will I check?

[00:42:38]This sum if it's greater than Okay.

[00:42:54]Okay. Okay. Okay. Let's suppose this maximum was very high.

[00:43:05]>> [cough] [clears throat] >> This is a quite interesting problem, I suppose.

[00:45:16]Hmm.

[00:45:16]Goats was the solution to this. Oh, one second.

[00:45:38]No.

[00:45:42]How will I maximize this sum? I need to just need to maximize this sum, right?

[00:45:46]Okay, well, let me just check the D problem as well.

[00:45:49]Till then.

[00:45:51]I'm solving C2. C2 is easy.

[00:46:01]So, if I one positive it will always Okay.

[00:46:19]What if What if I use C1 only easy one.

[00:46:24]See there are negative positive numbers.

[00:46:28]A lot of positive numbers.

[00:46:29]Some negative negative negative. What if till this positive I consider this array only.

[00:46:37]And in this I do this.

[00:46:42]And I make sure this minimizes the sum.

[00:46:50]And then I just swap this.

[00:46:54]If this is positive.

[00:46:55]If this is positive I leave it alone.

[00:46:59]Else I swap this.

[00:47:04]Else I swap that. That is good. That is That is a brilliant approach. So my approach is So let's suppose there are n elements.

[00:47:12]The n elements out of which k are positive, right?

[00:47:15]So I'll So I can break the array into one to like a k minus one at the positive number which means this array A dash will be a new array and I can use C1, the code that I wrote to minimize this.

[00:47:29]Now if I minimize this minimize this, then this is always minimized. Then I can take the k-th positive number.

[00:47:38]If I minimize this if all the negative sum plus K is Okay, but there's one more problem in this.

[00:48:13]Even if I minimize till K minus one it and I have switch the bits through K.

[00:48:20]What if the K at number exceeds?

[00:49:01]I don't know.

[00:49:03]And both the cases it's this.

[00:49:09]And so see the code last sale.

[00:49:34]Correct.

[00:49:42]You can possibly use this to give positive number I have.

[00:49:48]It's the picture of positive number for sure.

[00:49:51]It's going to minimize the code.

[00:49:52]>> This is cool.

[00:49:57]chicken This.

[00:50:44]One thing.

[00:51:14]I think it's a solution. This is the solution key it's has to be something like he go from back.

[00:51:25]I think you can build it up on this be okay till this this is minimum. Now I swap this this become maximum. All the negative elements here change and this becomes negative.

[00:51:34]So this minimum plus this swaps this. But let's suppose this minimum plus this negative still is less than in the absolute value in terms of this positive number. So if I minimize negate this not maximize.

[00:51:50]Okay.

[00:51:57]Start from first.

[00:52:04]If there exist any arbitrary sequence key.

[00:52:12]I know those values will sum. So if there is there is something key there is existing arbitrary sequence key, so it will always start from I will always start to fill from back.

[00:52:27]Right?

[00:52:29]So let's suppose I decide to switch this positive number.

[00:52:32]That's the only case when the previous positive here.

[00:52:47]All right, now this will become negative.

[00:53:18]So what I can do is for a number till a number I can make all the numbers positive.

[00:53:23]All all the numbers negative I suppose.

[00:53:24]I mean.

[00:53:31]This all will become negative.

[00:53:35]Till this positive.

[00:53:42]That is one case.

[00:53:48]I can make all of this negative until this positive and one more.

[00:53:55]I can make this negative.

[00:54:00]All the other elements positive.

[00:54:03]I'm going to make This is the only case, right?

[00:54:08]And So, it's like I can make this all elements positive. Only this element negative. And this all the behind elements will be negative only.

[00:54:21]Or I can do the same for each positive number.

[00:54:36]Positive.

[00:55:52]>> So, let's suppose there are n positive numbers.

[00:55:55]n positive numbers I can make for i k till i k all the values positive then I can make i k minus one negative.

[00:56:12]And do I need to check for all values then?

[00:56:15]That is the concern.

[00:56:17]Do I need to check for all values then?

[00:57:12]So, I just need to check for the last index we need to subtract this value.

[00:57:25]So, if I apply an operation on like the last element of k, the last positive element will become negative one and all the positive elements before that can be made plus one.

[00:57:36]So, what is the last element that I choose?

[00:57:39]So, it's just either you choose the last, second last, third last, fourth last, fifth last, and so on.

[00:57:48]And that is the answer, I think. So, there are M positive elements or K positive elements, then you can make till if you choose the last element of a subsequence like this was M elements subsequence of M moves, you can make all the elements till the M-th positive number negative and then a positive and then M can be negative. M will be negative.

[00:58:11]Then M will be negative.

[00:58:13]But in that, if you're applying a pressure, you're making all the negative only. So, you're doing this only.

[00:58:18]So, you will just move prefix of this.

[00:58:20]So, A of zero uh I will just do prefix.

[00:58:27]Prefix of zero.

[00:58:34]And I will do int n suff n comma zero.

[00:58:47]Pre of zero is equal to absolute of A of zero.

[00:59:14]Absolute value of A of I.

[00:59:16]And moreover, uh suff of n minus one is equal to A of n minus one.

[00:59:28]And for int i equal to n minus two i greater than equal to zero i minus minus suff of i is equal to suff of i plus one and suff of i plus is equal to a of i Right, now I just need to check what is the right count plus plus count plus plus and then I just do this right if count equal to zero count is equal to equal to n c out zero because if it's n you need not do anything hmm hmm and if your count is n minus one if this is negative now what I will do is I can choose any positive number turn it to negative and turn all the numbers here positive that is what I'll do count is zero path is this right? Now, for int I equal to zero I less than n I plus plus if a of I is greater than zero.

[01:01:35]int val is equal to zero int i n d is equal to zero.

[01:01:40]All right, path p m public int i n d val is equal to max of value comma p of i plus sub of i and sub of i p i minus two times minus three times a of i.

[01:02:05]Right?

[01:02:08]int f val is equal to this.

[01:02:13]Okay.

[01:02:15]So, prefix of i plus suffix of i this will be two times this minus three times a value i.

[01:02:22]If if the value is greater than val val is equal to f val and i n d is equal to i.

[01:02:36]I'll just go ahead with this.

[01:02:40]Then I'll find the index of that positive number, okay? I'll make a change going to here. So, there will be some last positive integer that I'll change and I'll set this as this.

[01:02:50]Now, still index, right?

[01:02:57]int val is equal to one int val int mult multiplier is one.

[01:03:06]for int i is equal to i n d i is equal to zero.

[01:03:14]If a of i greater than zero.

[01:03:24]>> [snorts] >> Oh, let's suppose there are multiple positive integers.

[01:05:08]And it is part of the path now.

[01:07:18]>> Got to do anything any of I prefix suffix absolute of zero.

[01:07:29]Count is zero zero to count plus plus if count is equal to zero count is equal to n c out zero and then vector in path I and zero.

[01:07:59]Yeah, this will work.

[01:08:01]I think I couldn't think of the solution.

[01:08:06]I think it should not give me this.

[01:08:09]One wrong needed to change.

[01:08:12]Wrong on the pretest two.

[01:08:22]I think it's too awesome.

[01:08:24]Big hit by a question.

[01:08:27]Okay.

[01:08:31]Why is this not working?

[01:08:48]X second X second X second.

[01:08:55]See one thing one thing here it is key in this I am always same.

[01:09:06]First of all, val has not to be zero. It has to be a long min.

[01:09:13]Because that can be the minimum value as well.

[01:09:20]The minimum value can be Suppose it's very less very negative value and you just flipped one coin.

[01:09:28]So, this can be done.

[01:09:30]But, there can also be one value where no one needs to be flipped.

[01:09:39]Okay, let's suppose all negatives There's one zero. All negative, there's one zero. There's all negatives.

[01:09:46]If this current positive this one and it is minus one.

[01:10:20]All right.

[01:11:06]>> So, in this case I was always taking into consideration this can be such that you always I have to take this. So, this is the baseline value of summation of all the values.

[01:11:20]And if this is greater than zero I'll have to run this again, right?

[01:11:29]Okay, see what I've done is I have set the baseline value to be the summation of all the values. If there is no value that is greater than this which means IND will always be that value.

[01:11:44]Skip this.

[01:11:50]Which means in that case you don't need to take any value.

[01:11:55]That would be a base case I'm missing.

[01:11:57]Okay, if there is no value that needs to be flipped.

[01:12:03]Okay, there can be one value that needs to be flipped, right?

[01:12:07]If you flip this.

[01:12:11]Don't do this. Just flip this.

[01:12:14]Because if there is one value I'm flipping that value to because it's Let's see what happens.

[01:12:29]Might be wrong.

[01:12:40]I need to set the baseline value to this.

[01:12:45]If I don't want to swap.

[01:12:47]This can be wrong.

[01:12:54]Flip this first. Come on, bhai. How can it be wrong, bhai? Many like this key on.

[01:12:59]How can it be wrong?

[01:13:00]Yeah, yeah.

[01:13:03]>> [sighs] >> Problem D is also cool. Cutest could solve it in this much time. Let's try problem D.

[01:13:14]Pretty bad rank, but take a chill.

[01:13:20]You are given two arrays of positive integers A and B both of length N. All right. You'll perform the following operation exactly N minus one times.

[01:13:30]Let M be the current length of A and B.

[01:13:31]Oh, Tejas was able to make it. Okay, Tejas made Tejas did not able to make it. Codes was able to make it. Hmm.

[01:13:42]Uh okay, you're given two positive integers A and two positive two arrays of positive integers.

[01:13:48]You are given X second. You call it or no?

[01:13:50]Hmm.

[01:13:51]>> [snorts] >> You're given two arrays of positive integers A and B both of length N. You will perform the following operation exactly N minus one times. Okay. Let M be the current length of A and B. Note that length will always be equal. All right. Select an integer in Okay, so let's select any index.

[01:14:10]Let S be the Okay, you can't select the last index though, but oh, okay.

[01:14:16]Let S be the multi set A Okay. Just if select any index, these two elements and B K these two elements will form a multi will be belong to multi set S.

[01:14:30]Sort the elements of S. All right.

[01:14:32]Now replace AI AI plus one with S2 BI BI plus one with S3. More formally replace A with all good and B with this.

[01:14:46]After performing all operations, there will be exactly one element [clears throat] remaining in both A and B.

[01:14:59]Okay, so what you are doing is so you take two elements from A, two elements from B, you sort them.

[01:15:06]You take Thus, out of those four, you take the second and third max element and then the second max you append to A, third max you append to B.

[01:15:20]And you want to do this while Okay, so we want to minimize the values A1, B1, right? So, which means we want to minimize So, we can also consider it as this ways. So, we have NA elements and NB elements.

[01:15:34]We can instead of considering them as different arrays, we can do A1, B1, A2, B2, A3, B3 and so on, ANBN. So, this is an array of 2N elements.

[01:15:48]Now, if I choose any index I like from A like 0 2 4 any even index.

[01:15:56]So, which means I'm choosing A3B3 and A4B4. So, I'm choosing four consecutive elements from this array of this array of 2N elements and then sorting them.

[01:16:13]And just putting in back the two different elements.

[01:16:19]And that is the answer. So, in So, I can tell what I'm doing is See.

[01:16:27]So, there's some observations that I'm making on this.

[01:16:33]Observations, right?

[01:16:36]Don't consider both arrays separately.

[01:16:48]See, >> [clears throat] >> what if let's suppose is an array from A1 and then you have A2, then you have A3 and so on till AN.

[01:16:58]Simple Similarly, you have B1, B2, B3 and so on till BN.

[01:17:06]Right? In one operation, you choose AI.

[01:17:08]Like I will make an array of length 2N elements. Why I'm doing so? It will look like this, A1, B1, A2, B2, A3, B3. And I'll tell you how will this make my problem very simple.

[01:17:24]And the last two elements will be AN, BN. So, how Why this makes my problem very simple is if I If I choose any two elements like I was choosing here, AI, I was choosing AI, A I + 1, I was choosing BI, B I + 1, right? So, in this way, I will be choosing just four elements from this, which means like this only, like you don't need to choose from two separate arrays. You will be choosing. So, the problem is boiled down to in this array, in this new array, I need to take substring I need to take substrings substrings of length four, then sort them and reduce them to length two and add back to the array.

[01:18:41]And this has made my problem very simple.

[01:18:46]Hmm. So, it's just like you have four elements to remove. Now, what would be the logic? If I go about Hmm. And what I need to do is I need to minimize this. So, up as this operation you have minus two elements to remove in every operation and so on.

[01:19:03]And 2n minus two elements 2n So, at the end there will be four elements remaining.

[01:19:11]Then last four elements will be this operation will be performed. Then this four two elements two elements will be remaining.

[01:19:17]And these two are the minimum elements that has to be maximized.

[01:19:25]All right. So, which means I need to in this array new array, I just need to it's simple. You just need to remove the for each substring you need to remove the minimum element and the maximum element. You will left you will be left with the two between elements.

[01:19:41]And you need to do this operation as many times you can.

[01:19:44]No, not as many times. Uh n minus one times you will be able to do.

[01:19:48]And in the last operation you will be getting four elements and you will be resolving them to two last elements.

[01:19:53]Okay. Now, let's make some observation more observations on this.

[01:19:58]Hmm.

[01:20:00]Wait.

[01:20:02]Some Oh, they are able to make this now.

[01:20:04]So, this is not that hard.

[01:20:08]Hmm.

[01:20:09]>> [clears throat] >> Okay. And what So, okay. And if I choose any two any four elements So, it's like you are moving the outer elements to move them out.

[01:20:24]Then later elements are in.

[01:20:27]I'm going to remove them again.

[01:20:29]So, two will be in between. Min max will be out again.

[01:20:35]>> So, if I perform these operations optimally n minus one times.

[01:20:49]So, I will remove n minus one maximums.

[01:20:57]All n minus one maximums not.

[01:20:59]I will not be removing the maximum.

[01:21:03]I'll remove local maximums.

[01:21:14]Local maxima and local minima.

[01:21:22]So, it's like you have both the elements and in one operation in all these four elements you are removing the local maxima and minima.

[01:21:43]Okay. So, this is the problem.

[01:21:51]Okay, so now I need to minimize the maximums, right?

[01:21:57]I need to maximize the minimums, sorry.

[01:21:59]So, I just need to remove all minimums and minimum elements that I can get as fast as I can.

[01:22:06]So, let's suppose there are minimum elements, no?

[01:22:10]So, also we will process in batches. So, like first batch will go zero to third index, both inclusive.

[01:22:18]Zero comma three.

[01:22:21]Then next batch will be of four comma seven.

[01:22:25]Four comma seven inclusive.

[01:22:28]The next batch will be of 8, 11.

[01:22:35]Or there can be intermediate batches as well of like 2, 5 2 3 4 5 and let's say so on.

[01:22:53]So, let's [clears throat] suppose I choose 2, 5.

[01:22:55]I remove some two elements, then what will happen is now I will include the first element.

[01:23:04]I remove these two elements.

[01:23:06]So, it's like this 0 1 2 3 4 5 Yeah, I don't know.

[01:23:14]And there was six.

[01:23:16]And there are seven. There were eight elements. So, I took 2 3 4 5.

[01:23:24]Then I got these two removed.

[01:23:28]Now, I can take this element. I can now again have four two one choice two choice three choices.

[01:23:37]Let's suppose these are the only elements. I need to maximize this. So, what I will do is you may now minimum to maximize it. So, I will just remove this first.

[01:23:49]All right.

[01:23:50]Can't I just do binary search?

[01:23:52]Okay. And what is the order of integer elements of n?

[01:23:55]A of I B of I are up to 2n.

[01:24:00]Can't I do binary search? Okay.

[01:24:04]See, if I can make mid to be the maximum value of the minimums, then I can make all values. No, no, I can't make all values because I'm already moving the minimum also in each step. I'm not just taking out the maximums.

[01:24:39]I'm removing minimums as well.

[01:24:45]So, for sure I will remove n minus one minimums.

[01:24:55]This is for sure. I will remove n minus one minimums. Okay, I just Let's not take the positive and negative consideration like the maximum numbers.

[01:25:05]In each operation, you're removing the minimum element. So, you will end up removing n minus one minimums like this only.

[01:25:13]So And can these n minus one minimums will depend on indexes.

[01:25:34]Let's assume the first minimum is with A1 B1 A2 if there are four indexes.

[01:25:39]This is the first minimum.

[01:25:41]This lies somewhere anywhere like somewhere in this.

[01:25:45]It will always be removed.

[01:25:59]>> [clears throat] >> So, you will remove n minus one minimums. So, these values can't be answers. So, like if it's 1 2, then 1 is the answer because there's no operation you can make. If it's 2 4 5 1 3 6, are you all right?

[01:26:10]2 4 5 1 3 6 >> Mhm.

[01:26:30]>> [snorts] >> Mhm. 24513682 It can be 21 4356. This is the array.

[01:26:41]Now, I can remove one.

[01:26:46]I can I will make two operations. I can remove one. I can remove two.

[01:26:54]When I remove one, I will remove three. I will remove four as well.

[01:27:00]And I will be removing five as well.

[01:27:11]So, three and six will be remaining.

[01:27:15]So, second answer will be three.

[01:27:22]Third may 74564788 I'll remove I'll do three times, right?

[01:27:32]Three operations. So, I will remove this four. I will remove this four. I will remove this five.

[01:27:38]So, when I remove the first element I have two options.

[01:27:53]Here, in this case.

[01:27:56]Whereas I have multiple options, I have three options.

[01:28:00]I will have multiple options, too.

[01:28:02]Because there can be four indices where this minimum element can lie.

[01:28:07]Mhm.

[01:28:08]I will end up removing seven four.

[01:28:10]Then, I'll take this one. I'll end up removing four eight.

[01:28:19]Then I'll take seven four is done.

[01:28:23]Four eight is gone.

[01:28:26]I'll take this one and I'll remove five and eight. Six and seven will remain, so six will be the answer.

[01:28:35]So, it's like last n minus one elements can't be there.

[01:28:40]But, the just bigger limit than that will be there.

[01:28:54]Mhm.

[01:28:57]This people will be able to make it right. This is not that hard, I suppose.

[01:29:01]I need to solve this.

[01:29:06]So, it's like mark all the Oh, we minimums. Because n minus one minimums because you will be removing those.

[01:29:25]Or else, what you can do is you Because we know only two elements will remain.

[01:29:32]Let's forget about the two elements.

[01:29:34]Just just see what minimum element will remain.

[01:29:44]Let's suppose this is the array. Two two two two four.

[01:29:51]What three elements will be remaining removing? One this, two this.

[01:30:14]>> [clears throat] [clears throat] [clears throat] >> key segmentary variation Is it there segmentary variation on this?

[01:32:14]Or is it a DP variation? What is N?

[01:32:18]N is 10 to the power 5.

[01:32:21]Is it some sort of DP variation? Okay, let me see.

[01:32:29]DP Mhm.

[01:32:34]Let's think from DP angle, no?

[01:32:41]All right.

[01:32:42]So, if I end up removing for I-th position, so I will remove I, I + 1, I + 2, I + 3. These four elements I'll remove.

[01:32:51]Then DP of I will go directly to DP of I - 4 {comma} DP of I + 4 min of this.

[01:33:14]No.

[01:33:16]No.

[01:33:17]Because you have removed two elements.

[01:33:21]I - 2 I + 2 And so the DP angle is ignored. No, there's no DP angle in this.

[01:33:29]Because DP of I depends on I - 1 as well.

[01:33:33]And DP of I depends on I + 2 as well.

[01:33:34]So, it's like it's dependent on both sides.

[01:33:39]So, there is no base case that can be formed. So, like DP of I is dependent on both the forward and the negative uh on the backward states.

[01:33:51]Or So, I will have to make some observations only, so N minus one minimums will be removed.

[01:33:59]That is one observation.

[01:34:02]Will be removed.

[01:34:07]Mhm.

[01:34:13]Okay, now what?

[01:34:22]Can I do something like this? Can I mark this element?

[01:34:26]Mark some element.

[01:34:31]And I say >> [clears throat] >> Can't this be removed?

[01:34:53]Can't this not be removed?

[01:34:55]But even if I mark an element and I say this cannot be removed what about the second element, next element?

[01:35:22]Can't you also say something similar? We are taking four elements and we are making a very good choice. See.

[01:35:37]We are making a good choice here.

[01:35:42]Mhm.

[01:35:50]Certainly this observation is good that I made, but there should be something more.

[01:36:03]There has to be some or more observations on this.

[01:36:13]That method try to get minus one minimum to remove.

[01:36:23]>> [snorts] >> It come guru.

[01:36:34]2016 area.

[01:36:37]Sorry, I mean it is a minimum smart guru.

[01:36:40]Mhm.

[01:37:53]>> They also have n minus one minimums marked up there.

[01:38:05]>> [cough] >> Right, I will just mark all the n minus one minimums.

[01:38:15]And then I will remove n minus two elements, no?

[01:38:18]So, you first mark them or the last mark them.

[01:38:23]And the each way I will check number of elements.

[01:38:28]>> [clears throat] >> n minus two is already in the team.

[01:38:38]Yeah, n minus two is already in the team.

[01:38:42]See.

[01:38:43]See, there are n minus one element.

[01:38:45]Here, minimums.

[01:38:51]So, let's say let's suppose the length is n minus two n minus two is better than putting up with it.

[01:38:57]Either two n will be either two n minus one will be, either two n minus two will be.

[01:39:04]I'm going to do or yeah.

[01:39:07]Two n minus two n.

[01:39:09]So, what I can do is is key under two sum of the gap.

[01:39:16]Is going to be good to go.

[01:39:19]Yes, I'm going to do this one too.

[01:39:24]You don't have to do this one too. You don't have to do this one too. You don't have to do this one too.

[01:39:29]Is key under >> Ooh, that is this is one more observation that I made. Okay, I'll go make way L or our range to remove color.

[01:40:11]Getting me operations for cellular range calendar to make a pass for me show range car men or maximum budget.

[01:40:25]What I think a lot of range calendar of a massage operations with a lot of it.

[01:40:29]So, it's range car minimum or it's range car maximum element to me show budget of my pass.

[01:40:34]So, I can do one thing.

[01:40:38]See.

[01:40:39]My pass the L or R equal range here.

[01:40:41]It's car minimum minimum to me. But, how many have had to go?

[01:40:50]Yeah, I had to go.

[01:40:52]Yeah, I had to go. Yeah, I had to go.

[01:40:54]Yeah, I had to go. So, L or million had to go with me each element to budget.

[01:41:04]L and budget to occur.

[01:41:09]I could [clears throat] be range to offside to end plus two size key.

[01:41:16]I could be two and size key.

[01:41:19]I could be two elements with income.

[01:41:21]So, I take this two range.

[01:41:23]So, what is this is up to what are the segments to break up even sizes?

[01:41:29]>> [clears throat] >> So, it's like you have your pass going even segment what are the segments here?

[01:41:35]Let's suppose I may put it to end size calendar cool as I make it to end one comma R one.

[01:41:40]And to L2 comma R2, I will break them into two segments, only two. Of even sizes.

[01:41:55]I got I got this is how you have.

[01:41:58]I got let's suppose even in here. Let's suppose six inches.

[01:42:01]Tell us what you do 80 minute and a half.

[01:42:20]Okay. If I'm able to break into these two segments, to make it a little bit.

[01:42:23]Don't know if you can reach the kitchen.

[01:42:30]So.

[01:42:41]Minimum.

[01:42:42]I'm going to go with those segments and pick them up.

[01:42:45]Of even length. Okay, go to the beach and watch again.

[01:43:07]>> [clears throat] >> Nico.

[01:43:15]I mean about those segments and I have.

[01:43:19]Agla, oh, that is the solution. Yeah, I got my N.

[01:43:24]I got two elements that I can get out of this one.

[01:43:26]Two elements in there, okay.

[01:43:28]Two elements in there, okay.

[01:43:29]I said I got two elements in there, okay. Multiple segments got five minutes.

[01:43:34]So.

[01:43:36]In the element remove column.

[01:43:38]Fair in the compare column. In the remove column.

[01:44:48]>> [clears throat] >> So.

[01:44:59]It's like he eat.

[01:45:02]Operation consider them as subsequences.

[01:45:13]Right.

[01:45:15]Consider them as subsequences. Yeah, this subsequence is there present in this. So, if there is a very big subsequence that I'm you don't even speak about anything else.

[01:45:31]Right?

[01:45:33]Mhm.

[01:45:34]So, it's very too simple now, okay?

[01:45:40]Go through.

[01:46:18]Will I always take the uh uh middle two elements?

[01:46:30]Will it always work?

[01:46:34]Will I always take the middle two elements?

[01:46:36]And will it always work?

[01:47:30]>> It's been a lot I can do.

[01:47:35]By 1,500 people made this, either they are using Gemini or I am low-skilled, right?

[01:47:43]The people in Rubik are not able to solve this fast, but Mhm.

[01:47:53]I need to make the pretty fast.

[01:48:03]Okay, so if I'm taking all the minimum ones, all the middle ones, then I'm taking the min- median ones, no?

[01:48:30]Mhm.

[01:48:49]Mhm.

[01:48:59]What are the observations we can we make?

[01:49:05]Is there any segment variation that we can use to solve it using segment trees?

[01:49:11]Okay, for these two elements Oop.

[01:49:17]Wait.

[01:49:19]Let's create a segment tree.

[01:49:27]Segment tree make out of three.

[01:49:30]This is the node.

[01:49:31]This will contain two elements.

[01:49:33]A B I get two notes ready. Left child and right child.

[01:49:42]Two left child over.

[01:49:50]Okay. What do we call it the right side?

[01:49:54]Right?

[01:49:55]The left child over will previous two elements take up left side say.

[01:50:11]Like A1 {comma} B1.

[01:50:14]Or yeah two elements take up this side say A2 {comma} B2.

[01:50:24]Mhm.

[01:50:25]Or root function give up segment three got it will be You will get four elements. You can just sort them.

[01:50:33]And then return.

[01:50:40]A one A2 Like the first, second, and third element.

[01:50:52]>> [clears throat] >> So which means And there will be two cases.

[01:51:02]Yeah, I will share the minute I know.

[01:51:06]The even is coming out and it's coming out. That's it.

[01:51:11]This is my two three written here. This is four five written here.

[01:53:18]>> [clears throat] [cough] >> But second case is key So, is me dekho.

[01:55:30]Then my approach is wrong, but if my answer same to my approach is correct.

[01:55:34]So, is me yeah or yeah element are there.

[01:55:49]So, yeah are there.

[01:55:50]Yeah to her jar there.

[01:56:40]I think this is a segmentary variation.

[01:56:43]Now I'm confirmed with this.

[01:56:46]But I'm just thinking how to apply segmentary on this.

[01:56:52]So, mera segmentary logic is good. Okay.

[01:56:56]Two elements, two elements. two elements two elements into two two two two two elements.

[01:57:01]Take max up then Add them to four.

[01:57:18]two two two three elements here now or two key direct answer direct use code in the group or square root of two ways Take care.

[01:57:34]I have two two ways here. In the two different answers I get or So for n is equal to three men two ways here.

[01:57:50]>> [clears throat] >> n is equal to four It's a way here.

[01:57:59]It's a final answer I got.

[01:58:08]It's maybe two ways here.

[01:58:17]It's maybe three ways here.

[01:58:22]So n is equal to three men two ways here.

[01:58:28]Take care take care for me.

[01:58:45]Take give away It's maybe two ways here.

[01:58:53]Okay, so this I think is the question.

[01:59:16]Okay.

[01:59:29]I need to make Oh, load and balancing.

[01:59:39]Okay, I think we are good here.

[01:59:42]E I don't know what I'm supposed to do with this.

[01:59:54]Hmm, I need to solve that, but what I'm thinking is how do we solve this?

[02:00:20]Yeah, this has to be something of this word.

[02:00:38]>> [cough] [clears throat] >> X second.

[02:01:45]I'm going to make first up >> [snorts] >> last random.

[02:02:22]Or should I just say this thing key four cases are there.

[02:02:30]First element, then you make a array of these elements or first two elements and then you make subarray of all the elements.

[02:02:42]Or some array of these elements, last two elements, and or array of all the elements, which means okay.

[02:02:56]Can we do something like this?

[02:03:07]This can be put first and last element to ignore for something.

[02:03:15]But such that I have another child element.

[02:03:43]Then we do not call the number.

[02:03:45]It's going to be a median.

[02:03:51]Okay, let me check again.

[02:03:53]N B N A N N A It will have to be a whole setup.

[02:04:14]I was going to make a lot of other yard earlier, but I was looking at the setup over thinking is the gap.

[02:04:19]Required as question two.

[02:04:25]Why I'm confident in this approach is key C but that there's no another case where I can exclude two elements.

[02:04:35]See, child elements may be after the emergency. In this map, two elements may choice to So, Let's suppose the element between me and you over I can take two elements.

[02:05:12]Let's suppose two elements between me and you over I like except that I had a loser.

[02:05:26]except that I had a a element there.

[02:05:30]a element there. That was a element and so on.

[02:05:34]together I don't know what kind of is me and you over.

[02:05:42]I don't know what kind of is me and you over.

[02:05:47]I don't know what kind of is me and you over. I don't know what kind of is me and you over. I don't know what kind of is me and you over. don't know what kind of is me up I don't know what kind of is me and you over.

[02:05:55]Which means I will have to use this for this sub area.

[02:06:01]Or I will have to use this.

[02:06:10]But, I can only make choices if the elements are corner elements.

[02:06:33]I don't know what kind of is me and you over. back B of I.

[02:06:39]See that? Uh I will make case one.

[02:06:42]Vector in C1.

[02:06:47]Vector in C2.

[02:06:59]Case four.

[02:07:00]Case four with the beginning.

[02:07:03]All n equal to zero. C4 is equal to C3.

[02:07:12]is equal to C.

[02:07:13]C3 is equal to C.

[02:07:20]>> [sighs] >> C1 may I'm going to uh I'm saying minus one is already there. C2 may I'm going to I'm going to do that.

[02:08:14]Two C and side on the C3 I'm going to C cable over there, but C3 pop back two more times.

[02:08:42]>> C 2 C 1 C 2 up ASC C 1 C C 2 C 4 Case 1 now up case 1 here here C of 0 Given not PB C of N - 1 Okay, let's go.

[02:09:30]If N is less than equal to 2 Hm.

[02:10:25]>> No. I'll guess one case two, right? Even is this.

[02:10:34]two You will not push back.

[02:11:13]You will not push back.

[02:11:17]C1 of eight You will not push back C1 of mid minus one Right?

[02:11:31]ASC A1 Val is equal to min max of val comma A1 of one Clear.

[02:12:03]Yep, vector in data in a little bit of vector int A2 A2 make out A2 EB C of zero A2.PBC of one A2.PB C2 of mid A2.PB C2 of mid minus one Mhm.

[02:12:44]A S C A2 URL is equal to max of 12 comma A2 of one Right.

[02:12:57]And similarly, I have to do A3 as well.

[02:13:04]A3 last two element remove in a Mhm.

[02:13:08]A3 may N minus one karna hai.

[02:13:13]N minus two karna hai.

[02:13:16]C3 of mid karna hai.

[02:13:18]C3 of mid minus one karna hai.

[02:13:21]C3 karna A3 karna hai. Idhar bhi A3 karna hai.

[02:13:24]Idhar bhi four karna hai.

[02:13:27]A4 Ye ho gaya.

[02:13:35]Or C4 C4 C out val and del Pata nahi chalega ki nahi. Mereko lagta to hai chal jana chahiye.

[02:14:13]Isiliye mereko lagta hai wrong bhi hai ye.

[02:14:15]This is some segment problem so I'm not able to understand that the post.

[02:14:28]Segment three I need to ask the machine segment three like I mean that's the most probably.

[02:14:41]Mhm.

[02:14:56]Mhm. What can be the answer for this?

[02:15:06]I'm just replacing it with the medians.

[02:15:08]>> [clears throat] >> Mhm.

[02:15:14]Right, I'm replacing it with medians.

[02:15:17]Always.

[02:15:27]I think it's D9. It's not that easy.

[02:15:31]I think I'll have to solve it.

[02:15:56]Are you up?

[02:15:57]Top standings we got to take the one one.

[02:16:10]>> Bro, how come the order is just so done?

[02:17:44]So, it's like you sequentially process them. Not like you sequentially process them.

[02:17:52]There is a sequence in which I need to process these elements.

[02:18:26]>> Mhm.

[02:18:27]>> [clears throat] >> I think I'll stop this. I'll go go for dinner then.

[02:18:31]>> [snorts] >> Bye-bye. This is still here only.